emx-onnx-cgen 0.3.8__py3-none-any.whl → 0.4.2.dev0__py3-none-any.whl

emx_onnx_cgen/codegen/c_emitter.py

@@ -9,7 +9,7 @@ import re
 import struct
 from typing import Mapping, Sequence
 
-from jinja2 import Environment, FileSystemLoader, Template, select_autoescape
+from jinja2 import Environment, FileSystemLoader, PackageLoader, Template, select_autoescape
 import numpy as np
 
 from ..errors import CodegenError
@@ -37,15 +37,18 @@ from ..ir.ops import (
     AttentionOp,
     AveragePoolOp,
     BatchNormOp,
+    BernoulliOp,
     BinaryOp,
     CastOp,
     ClipOp,
     ConcatOp,
     ConstantOfShapeOp,
     ConvOp,
+    ConvIntegerOp,
     ConvTransposeOp,
     CumSumOp,
     DepthToSpaceOp,
+    DequantizeLinearOp,
     EinsumKind,
     EinsumOp,
     ExpandOp,
@@ -54,8 +57,10 @@ from ..ir.ops import (
     GatherNDOp,
     GatherOp,
     GemmOp,
+    GruOp,
     GridSampleOp,
     GroupNormalizationOp,
+    HammingWindowOp,
     HardmaxOp,
     IdentityOp,
     InstanceNormalizationOp,
@@ -73,8 +78,11 @@ from ..ir.ops import (
     NonMaxSuppressionOp,
     NonZeroOp,
     OneHotOp,
+    OptionalHasElementOp,
     PadOp,
     QuantizeLinearOp,
+    PowOp,
+    QLinearMulOp,
     QLinearMatMulOp,
     RangeOp,
     ReduceOp,
@@ -91,6 +99,7 @@ from ..ir.ops import (
     SpaceToDepthOp,
     SplitOp,
     TensorScatterOp,
+    TfIdfVectorizerOp,
     TileOp,
     TopKOp,
     TransposeOp,
@@ -278,9 +287,11 @@ class ModelHeader:
 class LoweredModel:
     name: str
     input_names: tuple[str, ...]
+    input_optional_names: tuple[str | None, ...]
     input_shapes: tuple[tuple[int, ...], ...]
     input_dtypes: tuple[ScalarType, ...]
     output_names: tuple[str, ...]
+    output_optional_names: tuple[str | None, ...]
     output_shapes: tuple[tuple[int, ...], ...]
     output_dtypes: tuple[ScalarType, ...]
     constants: tuple[ConstTensor, ...]
@@ -304,20 +315,37 @@ class _EmitState:
 class CEmitter:
     def __init__(
         self,
-        template_dir: Path,
+        template_dir: Path | None,
         *,
         restrict_arrays: bool = True,
+        fp32_accumulation_strategy: str = "fp64",
+        fp16_accumulation_strategy: str = "fp32",
         truncate_weights_after: int | None = None,
         large_temp_threshold_bytes: int = 1024,
         large_weight_threshold: int = 1024,
     ) -> None:
+        loader = (
+            FileSystemLoader(str(template_dir))
+            if template_dir is not None
+            else PackageLoader("emx_onnx_cgen", "templates")
+        )
         self._env = Environment(
-            loader=FileSystemLoader(str(template_dir)),
+            loader=loader,
             autoescape=select_autoescape(enabled_extensions=()),
             trim_blocks=True,
             lstrip_blocks=True,
         )
         self._restrict_arrays = restrict_arrays
+        if fp32_accumulation_strategy not in {"simple", "fp64"}:
+            raise CodegenError(
+                "fp32_accumulation_strategy must be 'simple' or 'fp64'"
+            )
+        self._fp32_accumulation_strategy = fp32_accumulation_strategy
+        if fp16_accumulation_strategy not in {"simple", "fp32"}:
+            raise CodegenError(
+                "fp16_accumulation_strategy must be 'simple' or 'fp32'"
+            )
+        self._fp16_accumulation_strategy = fp16_accumulation_strategy
         if truncate_weights_after is not None and truncate_weights_after < 1:
             raise CodegenError("truncate_weights_after must be >= 1")
         self._truncate_weights_after = truncate_weights_after
@@ -390,6 +418,21 @@ class CEmitter:
             mapped[key] = unique
         return mapped
 
+    def _accumulation_dtype(self, dtype: ScalarType) -> ScalarType:
+        if dtype == ScalarType.F32:
+            return (
+                ScalarType.F32
+                if self._fp32_accumulation_strategy == "simple"
+                else ScalarType.F64
+            )
+        if dtype == ScalarType.F16:
+            return (
+                ScalarType.F16
+                if self._fp16_accumulation_strategy == "simple"
+                else ScalarType.F32
+            )
+        return dtype
+
     def _ctx_name(self, name: str) -> str:
         if self._emit_state is None:
             raise CodegenError("Emitter state not initialized")
@@ -410,6 +453,12 @@ class CEmitter:
             raise CodegenError("Emitter state not initialized")
         return self._emit_state.op_context.require_derived(op, key)
 
+    def _maybe_derived(self, op: OpBase, key: str) -> object | None:
+        if self._emit_state is None:
+            raise CodegenError("Emitter state not initialized")
+        value = self._emit_state.op_context.get_derived(op, key, None)
+        return value
+
     @staticmethod
     def _build_param_decls(
         specs: Sequence[tuple[str | None, str, str, bool]]
@@ -447,6 +496,8 @@ class CEmitter:
         | ClipOp
         | CastOp
         | QuantizeLinearOp
+        | DequantizeLinearOp
+        | QLinearMulOp
         | QLinearMatMulOp
         | MatMulOp
         | EinsumOp
@@ -454,6 +505,7 @@ class CEmitter:
         | AttentionOp
         | RotaryEmbeddingOp
         | ConvOp
+        | ConvIntegerOp
         | AveragePoolOp
         | BatchNormOp
         | LpNormalizationOp
@@ -463,6 +515,7 @@ class CEmitter:
         | MeanVarianceNormalizationOp
         | RMSNormalizationOp
         | LrnOp
+        | GruOp
         | LstmOp
         | AdagradOp
         | SoftmaxOp
@@ -480,6 +533,7 @@ class CEmitter:
         | TransposeOp
         | ReshapeOp
         | IdentityOp
+        | BernoulliOp
         | EyeLikeOp
         | TriluOp
         | TileOp
@@ -495,11 +549,13 @@ class CEmitter:
         | ConstantOfShapeOp
         | ShapeOp
         | SizeOp
+        | OptionalHasElementOp
         | NonZeroOp
         | NonMaxSuppressionOp
         | ExpandOp
         | CumSumOp
         | RangeOp
+        | HammingWindowOp
         | OneHotOp
         | SplitOp,
     ) -> tuple[str, ...]:
@@ -527,6 +583,24 @@ class CEmitter:
                 names.append(op.zero_point)
             names.append(op.output)
             return tuple(names)
+        if isinstance(op, DequantizeLinearOp):
+            names = [op.input0, op.scale]
+            if op.zero_point is not None:
+                names.append(op.zero_point)
+            names.append(op.output)
+            return tuple(names)
+        if isinstance(op, QLinearMulOp):
+            return (
+                op.input0,
+                op.input0_scale,
+                op.input0_zero_point,
+                op.input1,
+                op.input1_scale,
+                op.input1_zero_point,
+                op.output_scale,
+                op.output_zero_point,
+                op.output,
+            )
         if isinstance(op, QLinearMatMulOp):
             return (
                 op.input0,
@@ -579,6 +653,14 @@ class CEmitter:
                 names.append(op.bias)
             names.append(op.output)
             return tuple(names)
+        if isinstance(op, ConvIntegerOp):
+            names = [op.input0, op.weights]
+            if op.x_zero_point is not None:
+                names.append(op.x_zero_point)
+            if op.w_zero_point is not None:
+                names.append(op.w_zero_point)
+            names.append(op.output)
+            return tuple(names)
         if isinstance(op, ConvTransposeOp):
             names = [op.input0, op.weights]
             if op.bias is not None:
@@ -611,6 +693,19 @@ class CEmitter:
             return (op.input0, op.output)
         if isinstance(op, RMSNormalizationOp):
             return (op.input0, op.scale, op.output)
+        if isinstance(op, GruOp):
+            names = [op.input_x, op.input_w, op.input_r]
+            if op.input_b is not None:
+                names.append(op.input_b)
+            if op.input_sequence_lens is not None:
+                names.append(op.input_sequence_lens)
+            if op.input_initial_h is not None:
+                names.append(op.input_initial_h)
+            if op.output_y is not None:
+                names.append(op.output_y)
+            if op.output_y_h is not None:
+                names.append(op.output_y_h)
+            return tuple(names)
         if isinstance(op, LstmOp):
             names = [op.input_x, op.input_w, op.input_r]
             if op.input_b is not None:
@@ -705,14 +800,20 @@ class CEmitter:
             return tuple(names)
         if isinstance(op, RangeOp):
             return (op.start, op.limit, op.delta, op.output)
+        if isinstance(op, HammingWindowOp):
+            return (op.size, op.output)
         if isinstance(op, OneHotOp):
             return (op.indices, op.depth, op.values, op.output)
+        if isinstance(op, TfIdfVectorizerOp):
+            return (op.input0, op.output)
         if isinstance(op, SplitOp):
             return (op.input0, *op.outputs)
         if isinstance(op, ReshapeOp):
             return (op.input0, op.output)
         if isinstance(op, IdentityOp):
             return (op.input0, op.output)
+        if isinstance(op, BernoulliOp):
+            return (op.input0, op.output)
         if isinstance(op, EyeLikeOp):
             return (op.input0, op.output)
         if isinstance(op, TriluOp):
@@ -761,7 +862,12 @@ class CEmitter:
         if isinstance(op, GridSampleOp):
             return (op.input0, op.grid, op.output)
         if isinstance(op, TopKOp):
-            return (op.input0, op.output_values, op.output_indices)
+            return (
+                op.input0,
+                op.k_input,
+                op.output_values,
+                op.output_indices,
+            )
         if isinstance(op, ReduceOp):
             names = [op.input0]
             if op.axes_input is not None:
@@ -777,6 +883,12 @@ class CEmitter:
         names = [model.name]
         names.extend(model.input_names)
         names.extend(model.output_names)
+        names.extend(
+            name for name in model.input_optional_names if name is not None
+        )
+        names.extend(
+            name for name in model.output_optional_names if name is not None
+        )
         for op in model.ops:
             names.extend(
                 name for name in self._op_names(op) if name not in constant_names
@@ -809,12 +921,15 @@ class CEmitter:
     def _map_op_names(
         self,
         op: BinaryOp
+        | PowOp
         | MultiInputBinaryOp
         | WhereOp
         | UnaryOp
         | ClipOp
         | CastOp
         | QuantizeLinearOp
+        | DequantizeLinearOp
+        | QLinearMulOp
         | QLinearMatMulOp
         | MatMulOp
         | EinsumOp
@@ -822,6 +937,7 @@ class CEmitter:
         | AttentionOp
         | RotaryEmbeddingOp
         | ConvOp
+        | ConvIntegerOp
         | ConvTransposeOp
         | AveragePoolOp
         | LpPoolOp
@@ -833,6 +949,7 @@ class CEmitter:
         | MeanVarianceNormalizationOp
         | RMSNormalizationOp
         | LrnOp
+        | GruOp
         | LstmOp
         | AdagradOp
         | SoftmaxOp
@@ -865,22 +982,28 @@ class CEmitter:
         | ConstantOfShapeOp
         | ShapeOp
         | SizeOp
+        | OptionalHasElementOp
         | NonZeroOp
         | NonMaxSuppressionOp
         | ExpandOp
         | CumSumOp
         | RangeOp
+        | HammingWindowOp
         | OneHotOp
+        | TfIdfVectorizerOp
         | SplitOp,
         name_map: dict[str, str],
     ) -> (
         BinaryOp
+        | PowOp
         | MultiInputBinaryOp
         | WhereOp
         | UnaryOp
         | ClipOp
         | CastOp
         | QuantizeLinearOp
+        | DequantizeLinearOp
+        | QLinearMulOp
         | QLinearMatMulOp
         | MatMulOp
         | EinsumOp
@@ -888,6 +1011,7 @@ class CEmitter:
         | AttentionOp
         | RotaryEmbeddingOp
         | ConvOp
+        | ConvIntegerOp
         | ConvTransposeOp
         | AveragePoolOp
         | LpPoolOp
@@ -899,6 +1023,7 @@ class CEmitter:
         | MeanVarianceNormalizationOp
         | RMSNormalizationOp
         | LrnOp
+        | GruOp
         | LstmOp
         | AdagradOp
         | SoftmaxOp
@@ -931,14 +1056,25 @@ class CEmitter:
         | ConstantOfShapeOp
         | ShapeOp
         | SizeOp
+        | OptionalHasElementOp
         | NonZeroOp
         | NonMaxSuppressionOp
         | ExpandOp
         | CumSumOp
         | RangeOp
+        | HammingWindowOp
         | OneHotOp
         | SplitOp
+        | TfIdfVectorizerOp
     ):
+        if isinstance(op, PowOp):
+            return PowOp(
+                input0=name_map.get(op.input0, op.input0),
+                input1=name_map.get(op.input1, op.input1),
+                output=name_map.get(op.output, op.output),
+                function=op.function,
+                operator_kind=op.operator_kind,
+            )
         if isinstance(op, BinaryOp):
             return BinaryOp(
                 input0=name_map.get(op.input0, op.input0),
@@ -946,11 +1082,6 @@ class CEmitter:
                 output=name_map.get(op.output, op.output),
                 function=op.function,
                 operator_kind=op.operator_kind,
-                input0_shape=op.input0_shape,
-                input1_shape=op.input1_shape,
-                shape=op.shape,
-                dtype=op.dtype,
-                input_dtype=op.input_dtype,
             )
         if isinstance(op, MultiInputBinaryOp):
             return MultiInputBinaryOp(
@@ -968,20 +1099,12 @@ class CEmitter:
                 input_x=name_map.get(op.input_x, op.input_x),
                 input_y=name_map.get(op.input_y, op.input_y),
                 output=name_map.get(op.output, op.output),
-                condition_shape=op.condition_shape,
-                x_shape=op.x_shape,
-                y_shape=op.y_shape,
-                output_shape=op.output_shape,
-                dtype=op.dtype,
             )
         if isinstance(op, UnaryOp):
             return UnaryOp(
                 input0=name_map.get(op.input0, op.input0),
                 output=name_map.get(op.output, op.output),
                 function=op.function,
-                shape=op.shape,
-                dtype=op.dtype,
-                input_dtype=op.input_dtype,
                 params=op.params,
             )
         if isinstance(op, ClipOp):
@@ -990,11 +1113,8 @@ class CEmitter:
                 input_min=self._map_optional_name(name_map, op.input_min),
                 input_max=self._map_optional_name(name_map, op.input_max),
                 output=name_map.get(op.output, op.output),
-                input_shape=op.input_shape,
-                min_shape=op.min_shape,
-                max_shape=op.max_shape,
-                output_shape=op.output_shape,
-                dtype=op.dtype,
+                min_value=op.min_value,
+                max_value=op.max_value,
             )
         if isinstance(op, CastOp):
             return CastOp(
@@ -1016,8 +1136,21 @@ class CEmitter:
                 input_dtype=op.input_dtype,
                 scale_dtype=op.scale_dtype,
             )
-        if isinstance(op, QLinearMatMulOp):
-            return QLinearMatMulOp(
+        if isinstance(op, DequantizeLinearOp):
+            return DequantizeLinearOp(
+                input0=name_map.get(op.input0, op.input0),
+                scale=name_map.get(op.scale, op.scale),
+                zero_point=self._map_optional_name(name_map, op.zero_point),
+                output=name_map.get(op.output, op.output),
+                input_shape=op.input_shape,
+                axis=op.axis,
+                block_size=op.block_size,
+                dtype=op.dtype,
+                input_dtype=op.input_dtype,
+                scale_dtype=op.scale_dtype,
+            )
+        if isinstance(op, QLinearMulOp):
+            return QLinearMulOp(
                 input0=name_map.get(op.input0, op.input0),
                 input0_scale=name_map.get(op.input0_scale, op.input0_scale),
                 input0_zero_point=name_map.get(
@@ -1036,14 +1169,6 @@ class CEmitter:
                 input0_shape=op.input0_shape,
                 input1_shape=op.input1_shape,
                 output_shape=op.output_shape,
-                batch_shape=op.batch_shape,
-                input0_batch_shape=op.input0_batch_shape,
-                input1_batch_shape=op.input1_batch_shape,
-                m=op.m,
-                n=op.n,
-                k=op.k,
-                left_vector=op.left_vector,
-                right_vector=op.right_vector,
                 input0_dtype=op.input0_dtype,
                 input1_dtype=op.input1_dtype,
                 dtype=op.dtype,
@@ -1057,10 +1182,22 @@ class CEmitter:
                 input1_zero_shape=op.input1_zero_shape,
                 output_zero_shape=op.output_zero_shape,
             )
-        if isinstance(op, MatMulOp):
-            return MatMulOp(
+        if isinstance(op, QLinearMatMulOp):
+            return QLinearMatMulOp(
                 input0=name_map.get(op.input0, op.input0),
+                input0_scale=name_map.get(op.input0_scale, op.input0_scale),
+                input0_zero_point=name_map.get(
+                    op.input0_zero_point, op.input0_zero_point
+                ),
                 input1=name_map.get(op.input1, op.input1),
+                input1_scale=name_map.get(op.input1_scale, op.input1_scale),
+                input1_zero_point=name_map.get(
+                    op.input1_zero_point, op.input1_zero_point
+                ),
+                output_scale=name_map.get(op.output_scale, op.output_scale),
+                output_zero_point=name_map.get(
+                    op.output_zero_point, op.output_zero_point
+                ),
                 output=name_map.get(op.output, op.output),
                 input0_shape=op.input0_shape,
                 input1_shape=op.input1_shape,
@@ -1073,7 +1210,24 @@ class CEmitter:
                 k=op.k,
                 left_vector=op.left_vector,
                 right_vector=op.right_vector,
+                input0_dtype=op.input0_dtype,
+                input1_dtype=op.input1_dtype,
                 dtype=op.dtype,
+                input0_scale_dtype=op.input0_scale_dtype,
+                input1_scale_dtype=op.input1_scale_dtype,
+                output_scale_dtype=op.output_scale_dtype,
+                input0_scale_shape=op.input0_scale_shape,
+                input1_scale_shape=op.input1_scale_shape,
+                output_scale_shape=op.output_scale_shape,
+                input0_zero_shape=op.input0_zero_shape,
+                input1_zero_shape=op.input1_zero_shape,
+                output_zero_shape=op.output_zero_shape,
+            )
+        if isinstance(op, MatMulOp):
+            return MatMulOp(
+                input0=name_map.get(op.input0, op.input0),
+                input1=name_map.get(op.input1, op.input1),
+                output=name_map.get(op.output, op.output),
             )
         if isinstance(op, EinsumOp):
             return EinsumOp(
@@ -1091,15 +1245,10 @@ class CEmitter:
                 input_b=name_map.get(op.input_b, op.input_b),
                 input_c=self._map_optional_name(name_map, op.input_c),
                 output=name_map.get(op.output, op.output),
-                m=op.m,
-                n=op.n,
-                k=op.k,
                 trans_a=op.trans_a,
                 trans_b=op.trans_b,
                 alpha=op.alpha,
                 beta=op.beta,
-                c_shape=op.c_shape,
-                dtype=op.dtype,
             )
         if isinstance(op, AttentionOp):
             return AttentionOp(
@@ -1202,6 +1351,35 @@ class CEmitter:
                 group=op.group,
                 dtype=op.dtype,
             )
+        if isinstance(op, ConvIntegerOp):
+            return ConvIntegerOp(
+                input0=name_map.get(op.input0, op.input0),
+                weights=name_map.get(op.weights, op.weights),
+                x_zero_point=self._map_optional_name(
+                    name_map, op.x_zero_point
+                ),
+                w_zero_point=self._map_optional_name(
+                    name_map, op.w_zero_point
+                ),
+                output=name_map.get(op.output, op.output),
+                batch=op.batch,
+                in_channels=op.in_channels,
+                out_channels=op.out_channels,
+                spatial_rank=op.spatial_rank,
+                in_spatial=op.in_spatial,
+                out_spatial=op.out_spatial,
+                kernel_shape=op.kernel_shape,
+                strides=op.strides,
+                pads=op.pads,
+                dilations=op.dilations,
+                group=op.group,
+                input_dtype=op.input_dtype,
+                weight_dtype=op.weight_dtype,
+                dtype=op.dtype,
+                x_zero_point_shape=op.x_zero_point_shape,
+                w_zero_point_shape=op.w_zero_point_shape,
+                w_zero_point_per_channel=op.w_zero_point_per_channel,
+            )
         if isinstance(op, ConvTransposeOp):
             return ConvTransposeOp(
                 input0=name_map.get(op.input0, op.input0),
@@ -1228,16 +1406,26 @@ class CEmitter:
                 output=name_map.get(op.output, op.output),
                 batch=op.batch,
                 channels=op.channels,
+                spatial_rank=op.spatial_rank,
+                in_d=op.in_d,
                 in_h=op.in_h,
                 in_w=op.in_w,
+                out_d=op.out_d,
                 out_h=op.out_h,
                 out_w=op.out_w,
+                kernel_d=op.kernel_d,
                 kernel_h=op.kernel_h,
                 kernel_w=op.kernel_w,
+                dilation_d=op.dilation_d,
+                dilation_h=op.dilation_h,
+                dilation_w=op.dilation_w,
+                stride_d=op.stride_d,
                 stride_h=op.stride_h,
                 stride_w=op.stride_w,
+                pad_front=op.pad_front,
                 pad_top=op.pad_top,
                 pad_left=op.pad_left,
+                pad_back=op.pad_back,
                 pad_bottom=op.pad_bottom,
                 pad_right=op.pad_right,
                 count_include_pad=op.count_include_pad,
@@ -1255,6 +1443,8 @@ class CEmitter:
                 out_w=op.out_w,
                 kernel_h=op.kernel_h,
                 kernel_w=op.kernel_w,
+                dilation_h=op.dilation_h,
+                dilation_w=op.dilation_w,
                 stride_h=op.stride_h,
                 stride_w=op.stride_w,
                 pad_top=op.pad_top,
@@ -1371,6 +1561,35 @@ class CEmitter:
                 bias=op.bias,
                 dtype=op.dtype,
             )
+        if isinstance(op, GruOp):
+            return GruOp(
+                input_x=name_map.get(op.input_x, op.input_x),
+                input_w=name_map.get(op.input_w, op.input_w),
+                input_r=name_map.get(op.input_r, op.input_r),
+                input_b=self._map_optional_name(name_map, op.input_b),
+                input_sequence_lens=self._map_optional_name(
+                    name_map, op.input_sequence_lens
+                ),
+                input_initial_h=self._map_optional_name(
+                    name_map, op.input_initial_h
+                ),
+                output_y=self._map_optional_name(name_map, op.output_y),
+                output_y_h=self._map_optional_name(name_map, op.output_y_h),
+                seq_length=op.seq_length,
+                batch_size=op.batch_size,
+                input_size=op.input_size,
+                hidden_size=op.hidden_size,
+                num_directions=op.num_directions,
+                direction=op.direction,
+                layout=op.layout,
+                linear_before_reset=op.linear_before_reset,
+                clip=op.clip,
+                activation_kinds=op.activation_kinds,
+                activation_alphas=op.activation_alphas,
+                activation_betas=op.activation_betas,
+                dtype=op.dtype,
+                sequence_lens_dtype=op.sequence_lens_dtype,
+            )
         if isinstance(op, LstmOp):
             return LstmOp(
                 input_x=name_map.get(op.input_x, op.input_x),
@@ -1436,34 +1655,19 @@ class CEmitter:
             return SoftmaxOp(
                 input0=name_map.get(op.input0, op.input0),
                 output=name_map.get(op.output, op.output),
-                outer=op.outer,
-                axis_size=op.axis_size,
-                inner=op.inner,
                 axis=op.axis,
-                shape=op.shape,
-                dtype=op.dtype,
             )
         if isinstance(op, LogSoftmaxOp):
             return LogSoftmaxOp(
                 input0=name_map.get(op.input0, op.input0),
                 output=name_map.get(op.output, op.output),
-                outer=op.outer,
-                axis_size=op.axis_size,
-                inner=op.inner,
                 axis=op.axis,
-                shape=op.shape,
-                dtype=op.dtype,
             )
         if isinstance(op, HardmaxOp):
             return HardmaxOp(
                 input0=name_map.get(op.input0, op.input0),
                 output=name_map.get(op.output, op.output),
-                outer=op.outer,
-                axis_size=op.axis_size,
-                inner=op.inner,
                 axis=op.axis,
-                shape=op.shape,
-                dtype=op.dtype,
             )
         if isinstance(op, NegativeLogLikelihoodLossOp):
             return NegativeLogLikelihoodLossOp(
@@ -1624,9 +1828,6 @@ class CEmitter:
             return IdentityOp(
                 input0=name_map.get(op.input0, op.input0),
                 output=name_map.get(op.output, op.output),
-                shape=op.shape,
-                dtype=op.dtype,
-                input_dtype=op.input_dtype,
             )
         if isinstance(op, EyeLikeOp):
             return EyeLikeOp(
@@ -1782,45 +1983,32 @@ class CEmitter:
             return ReduceOp(
                 input0=name_map.get(op.input0, op.input0),
                 output=name_map.get(op.output, op.output),
-                input_shape=op.input_shape,
-                output_shape=op.output_shape,
                 axes=op.axes,
                 axes_input=self._map_optional_name(name_map, op.axes_input),
-                axes_input_shape=op.axes_input_shape,
-                axes_input_dtype=op.axes_input_dtype,
                 keepdims=op.keepdims,
                 noop_with_empty_axes=op.noop_with_empty_axes,
                 reduce_kind=op.reduce_kind,
                 reduce_count=op.reduce_count,
-                dtype=op.dtype,
             )
         if isinstance(op, ArgReduceOp):
             return ArgReduceOp(
                 input0=name_map.get(op.input0, op.input0),
                 output=name_map.get(op.output, op.output),
-                input_shape=op.input_shape,
-                output_shape=op.output_shape,
                 axis=op.axis,
                 keepdims=op.keepdims,
                 select_last_index=op.select_last_index,
                 reduce_kind=op.reduce_kind,
-                input_dtype=op.input_dtype,
-                output_dtype=op.output_dtype,
             )
         if isinstance(op, TopKOp):
             return TopKOp(
                 input0=name_map.get(op.input0, op.input0),
+                k_input=name_map.get(op.k_input, op.k_input),
                 output_values=name_map.get(op.output_values, op.output_values),
                 output_indices=name_map.get(op.output_indices, op.output_indices),
-                input_shape=op.input_shape,
-                output_shape=op.output_shape,
                 axis=op.axis,
                 k=op.k,
                 largest=op.largest,
                 sorted=op.sorted,
-                input_dtype=op.input_dtype,
-                output_values_dtype=op.output_values_dtype,
-                output_indices_dtype=op.output_indices_dtype,
             )
         if isinstance(op, ConstantOfShapeOp):
             return ConstantOfShapeOp(
@@ -1852,6 +2040,11 @@ class CEmitter:
                 dtype=op.dtype,
                 input_dtype=op.input_dtype,
             )
+        if isinstance(op, OptionalHasElementOp):
+            return OptionalHasElementOp(
+                input0=name_map.get(op.input0, op.input0),
+                output=name_map.get(op.output, op.output),
+            )
         if isinstance(op, NonZeroOp):
             return NonZeroOp(
                 input0=name_map.get(op.input0, op.input0),
@@ -1918,6 +2111,25 @@ class CEmitter:
                 dtype=op.dtype,
                 input_dtype=op.input_dtype,
             )
+        if isinstance(op, HammingWindowOp):
+            return HammingWindowOp(
+                size=name_map.get(op.size, op.size),
+                output=name_map.get(op.output, op.output),
+                output_shape=op.output_shape,
+                periodic=op.periodic,
+                dtype=op.dtype,
+                input_dtype=op.input_dtype,
+            )
+        if isinstance(op, BernoulliOp):
+            return BernoulliOp(
+                input0=name_map.get(op.input0, op.input0),
+                output=name_map.get(op.output, op.output),
+                input_shape=op.input_shape,
+                output_shape=op.output_shape,
+                input_dtype=op.input_dtype,
+                dtype=op.dtype,
+                seed=op.seed,
+            )
         if isinstance(op, OneHotOp):
             return OneHotOp(
                 indices=name_map.get(op.indices, op.indices),
@@ -1933,6 +2145,23 @@ class CEmitter:
                 indices_dtype=op.indices_dtype,
                 depth_dtype=op.depth_dtype,
             )
+        if isinstance(op, TfIdfVectorizerOp):
+            return TfIdfVectorizerOp(
+                input0=name_map.get(op.input0, op.input0),
+                output=name_map.get(op.output, op.output),
+                input_shape=op.input_shape,
+                output_shape=op.output_shape,
+                input_dtype=op.input_dtype,
+                output_dtype=op.output_dtype,
+                min_gram_length=op.min_gram_length,
+                max_gram_length=op.max_gram_length,
+                max_skip_count=op.max_skip_count,
+                mode=op.mode,
+                ngram_counts=op.ngram_counts,
+                ngram_indexes=op.ngram_indexes,
+                pool_int64s=op.pool_int64s,
+                weights=op.weights,
+            )
         if isinstance(op, SplitOp):
             return SplitOp(
                 input0=name_map.get(op.input0, op.input0),
@@ -1973,11 +2202,19 @@ class CEmitter:
             input_names=tuple(
                 name_map.get(name, name) for name in model.input_names
             ),
+            input_optional_names=tuple(
+                name_map.get(name, name) if name is not None else None
+                for name in model.input_optional_names
+            ),
             input_shapes=model.input_shapes,
             input_dtypes=model.input_dtypes,
             output_names=tuple(
                 name_map.get(name, name) for name in model.output_names
             ),
+            output_optional_names=tuple(
+                name_map.get(name, name) if name is not None else None
+                for name in model.output_optional_names
+            ),
             output_shapes=model.output_shapes,
             output_dtypes=model.output_dtypes,
             constants=constants,
@@ -2024,6 +2261,18 @@ class CEmitter:
             for name, values in testbench_inputs.items()
         }
 
+    @staticmethod
+    def _sanitize_testbench_optional_inputs(
+        testbench_optional_inputs: Mapping[str, bool] | None,
+        name_map: Mapping[str, str],
+    ) -> Mapping[str, bool] | None:
+        if not testbench_optional_inputs:
+            return None
+        return {
+            name_map.get(name, name): value
+            for name, value in testbench_optional_inputs.items()
+        }
+
     def _load_templates(self, emit_testbench: bool) -> dict[str, Template]:
         try:
             templates = {
@@ -2038,6 +2287,10 @@ class CEmitter:
                 "quantize_linear": self._env.get_template(
                     "quantize_linear_op.c.j2"
                 ),
+                "dequantize_linear": self._env.get_template(
+                    "dequantize_linear_op.c.j2"
+                ),
+                "qlinear_mul": self._env.get_template("qlinear_mul_op.c.j2"),
                 "qlinear_matmul": self._env.get_template(
                     "qlinear_matmul_op.c.j2"
                 ),
@@ -2049,6 +2302,7 @@ class CEmitter:
                     "rotary_embedding_op.c.j2"
                 ),
                 "conv": self._env.get_template("conv_op.c.j2"),
+                "conv_integer": self._env.get_template("conv_integer_op.c.j2"),
                 "conv_transpose": self._env.get_template(
                     "conv_transpose_op.c.j2"
                 ),
@@ -2070,6 +2324,7 @@ class CEmitter:
                 ),
                 "rms_norm": self._env.get_template("rms_normalization_op.c.j2"),
                 "lrn": self._env.get_template("lrn_op.c.j2"),
+                "gru": self._env.get_template("gru_op.c.j2"),
                 "lstm": self._env.get_template("lstm_op.c.j2"),
                 "adagrad": self._env.get_template("adagrad_op.c.j2"),
                 "softmax": self._env.get_template("softmax_op.c.j2"),
@@ -2093,6 +2348,7 @@ class CEmitter:
                 "transpose": self._env.get_template("transpose_op.c.j2"),
                 "reshape": self._env.get_template("reshape_op.c.j2"),
                 "identity": self._env.get_template("identity_op.c.j2"),
+                "bernoulli": self._env.get_template("bernoulli_op.c.j2"),
                 "eye_like": self._env.get_template("eye_like_op.c.j2"),
                 "trilu": self._env.get_template("trilu_op.c.j2"),
                 "tile": self._env.get_template("tile_op.c.j2"),
@@ -2116,6 +2372,9 @@ class CEmitter:
                 ),
                 "shape": self._env.get_template("shape_op.c.j2"),
                 "size": self._env.get_template("size_op.c.j2"),
+                "optional_has_element": self._env.get_template(
+                    "optional_has_element_op.c.j2"
+                ),
                 "nonzero": self._env.get_template("nonzero_op.c.j2"),
                 "nonmax_suppression": self._env.get_template(
                     "nonmax_suppression_op.c.j2"
@@ -2123,7 +2382,13 @@ class CEmitter:
                 "expand": self._env.get_template("expand_op.c.j2"),
                 "cumsum": self._env.get_template("cumsum_op.c.j2"),
                 "range": self._env.get_template("range_op.c.j2"),
+                "hamming_window": self._env.get_template(
+                    "hamming_window_op.c.j2"
+                ),
                 "one_hot": self._env.get_template("one_hot_op.c.j2"),
+                "tfidf_vectorizer": self._env.get_template(
+                    "tfidf_vectorizer_op.c.j2"
+                ),
                 "split": self._env.get_template("split_op.c.j2"),
             }
             if emit_testbench:
@@ -2138,6 +2403,7 @@ class CEmitter:
         *,
         emit_testbench: bool = False,
         testbench_inputs: Mapping[str, tuple[float | int | bool, ...]] | None = None,
+        testbench_optional_inputs: Mapping[str, bool] | None = None,
         variable_dim_inputs: Mapping[int, Mapping[int, str]] | None = None,
         variable_dim_outputs: Mapping[int, Mapping[int, str]] | None = None,
     ) -> str:
@@ -2147,6 +2413,9 @@ class CEmitter:
         testbench_inputs = self._sanitize_testbench_inputs(
             testbench_inputs, name_map
         )
+        testbench_optional_inputs = self._sanitize_testbench_optional_inputs(
+            testbench_optional_inputs, name_map
+        )
         inline_constants, large_constants = self._partition_constants(
             model.constants
         )
@@ -2184,6 +2453,8 @@ class CEmitter:
             model.name,
             *model.input_names,
             *model.output_names,
+            *(name for name in model.input_optional_names if name is not None),
+            *(name for name in model.output_optional_names if name is not None),
             *(const.name for const in model.constants),
         }
         temp_buffers = self._temp_buffers(model, reserved_names=reserved_names)
@@ -2235,16 +2506,27 @@ class CEmitter:
             *includes,
             "",
             self._emit_index_type_define(),
+            self._emit_unused_define(),
         ]
         if scalar_preamble:
             sections.extend(("", *scalar_preamble))
         sections.append("")
-        constants_section = self._emit_constant_definitions(inline_constants)
+        constants_section = self._emit_constant_declarations(inline_constants)
         if constants_section:
             sections.extend((constants_section.rstrip(), ""))
-        large_constants_section = self._emit_constant_storage_definitions(
+        storage_declarations = self._emit_constant_storage_declarations(
             large_constants
         )
+        if storage_declarations:
+            sections.extend((storage_declarations.rstrip(), ""))
+        constants_section = self._emit_constant_definitions(
+            inline_constants, storage_prefix="const"
+        )
+        if constants_section:
+            sections.extend((constants_section.rstrip(), ""))
+        large_constants_section = self._emit_constant_storage_definitions(
+            large_constants, storage_prefix=""
+        )
         if large_constants_section:
             sections.extend((large_constants_section.rstrip(), ""))
         if scalar_functions:
@@ -2267,6 +2549,7 @@ class CEmitter:
                         model,
                         testbench_template,
                         testbench_inputs=testbench_inputs,
+                        testbench_optional_inputs=testbench_optional_inputs,
                         dim_order=dim_order,
                         dim_values=dim_values,
                         weight_data_filename=self._weight_data_filename(model),
@@ -2285,6 +2568,7 @@ class CEmitter:
         *,
         emit_testbench: bool = False,
         testbench_inputs: Mapping[str, tuple[float | int | bool, ...]] | None = None,
+        testbench_optional_inputs: Mapping[str, bool] | None = None,
         variable_dim_inputs: Mapping[int, Mapping[int, str]] | None = None,
         variable_dim_outputs: Mapping[int, Mapping[int, str]] | None = None,
     ) -> tuple[str, str]:
@@ -2294,6 +2578,9 @@ class CEmitter:
         testbench_inputs = self._sanitize_testbench_inputs(
             testbench_inputs, name_map
         )
+        testbench_optional_inputs = self._sanitize_testbench_optional_inputs(
+            testbench_optional_inputs, name_map
+        )
         inline_constants, large_constants = self._partition_constants(
             model.constants
         )
@@ -2331,6 +2618,8 @@ class CEmitter:
             model.name,
             *model.input_names,
             *model.output_names,
+            *(name for name in model.input_optional_names if name is not None),
+            *(name for name in model.output_optional_names if name is not None),
             *(const.name for const in model.constants),
         }
         temp_buffers = self._temp_buffers(model, reserved_names=reserved_names)
@@ -2389,9 +2678,14 @@ class CEmitter:
         constants_section = self._emit_constant_declarations(inline_constants)
         if constants_section:
             sections.extend((constants_section.rstrip(), ""))
-        large_constants_section = self._emit_constant_storage_definitions(
+        storage_declarations = self._emit_constant_storage_declarations(
             large_constants
         )
+        if storage_declarations:
+            sections.extend((storage_declarations.rstrip(), ""))
+        large_constants_section = self._emit_constant_storage_definitions(
+            large_constants, storage_prefix=""
+        )
         if large_constants_section:
             sections.extend((large_constants_section.rstrip(), ""))
         if scalar_functions:
@@ -2414,6 +2708,7 @@ class CEmitter:
                         model,
                         testbench_template,
                         testbench_inputs=testbench_inputs,
+                        testbench_optional_inputs=testbench_optional_inputs,
                         dim_order=dim_order,
                         dim_values=dim_values,
                         weight_data_filename=self._weight_data_filename(model),
@@ -2656,7 +2951,7 @@ class CEmitter:
         except ScalarFunctionError:
             return None
 
-    def _lstm_activation_function_name(
+    def _rnn_activation_function_name(
         self,
         kind: int,
         alpha: float,
@@ -2667,7 +2962,7 @@ class CEmitter:
         spec = _LSTM_ACTIVATION_SPECS.get(kind)
         if spec is None:
             raise CodegenError(
-                f"Unsupported LSTM activation kind for codegen: {kind}"
+                f"Unsupported RNN activation kind for codegen: {kind}"
             )
         function, param_count = spec
         if param_count == 0:
@@ -2681,7 +2976,7 @@ class CEmitter:
         )
         if name is None:
             raise CodegenError(
-                f"Failed to resolve scalar function for LSTM activation kind {kind}"
+                f"Failed to resolve scalar function for RNN activation kind {kind}"
             )
         return name
 
@@ -2695,12 +2990,15 @@ class CEmitter:
             | ClipOp
             | CastOp
             | QuantizeLinearOp
+            | DequantizeLinearOp
+            | QLinearMulOp
             | QLinearMatMulOp
             | MatMulOp
             | EinsumOp
             | GemmOp
             | AttentionOp
             | ConvOp
+            | ConvIntegerOp
             | ConvTransposeOp
             | AveragePoolOp
             | LpPoolOp
@@ -2712,6 +3010,7 @@ class CEmitter:
             | MeanVarianceNormalizationOp
             | RMSNormalizationOp
             | LrnOp
+            | GruOp
             | LstmOp
             | AdagradOp
             | SoftmaxOp
@@ -2743,11 +3042,13 @@ class CEmitter:
             | ConstantOfShapeOp
             | ShapeOp
             | SizeOp
+            | OptionalHasElementOp
             | NonZeroOp
             | NonMaxSuppressionOp
             | ExpandOp
             | CumSumOp
             | RangeOp
+            | HammingWindowOp
             | OneHotOp
             | SplitOp
         ],
@@ -2787,6 +3088,8 @@ class CEmitter:
                 return model.op_context.dtype(op.data)
             if isinstance(op, ExpandOp):
                 return model.op_context.dtype(op.input0)
+            if hasattr(op, "output") and isinstance(op.output, str):
+                return model.op_context.dtype(op.output)
             return op.dtype
 
         model_dtypes.update(
@@ -2798,7 +3101,10 @@ class CEmitter:
             dtype
             for op in resolved_ops
             if isinstance(op, ArgReduceOp)
-            for dtype in (op.input_dtype, op.output_dtype)
+            for dtype in (
+                model.op_context.dtype(op.input0),
+                model.op_context.dtype(op.output),
+            )
         }
         model_dtypes.update(arg_reduce_dtypes)
         topk_dtypes = {
@@ -2806,9 +3112,9 @@ class CEmitter:
             for op in resolved_ops
             if isinstance(op, TopKOp)
             for dtype in (
-                op.input_dtype,
-                op.output_values_dtype,
-                op.output_indices_dtype,
+                model.op_context.dtype(op.input0),
+                model.op_context.dtype(op.output_values),
+                model.op_context.dtype(op.output_indices),
             )
         }
         model_dtypes.update(topk_dtypes)
@@ -2867,15 +3173,18 @@ class CEmitter:
             includes.add("#include <stdbool.h>")
         if any(
             isinstance(op, UnaryOp)
-            and unary_op_symbol(op.function, dtype=op.dtype) in {"llabs", "abs"}
+            and unary_op_symbol(
+                op.function, dtype=model.op_context.dtype(op.output)
+            )
+            in {"llabs", "abs"}
             for op in resolved_ops
         ):
             includes.add("#include <stdlib.h>")
         if any(isinstance(op, PadOp) for op in resolved_ops):
             includes.add("#include <stddef.h>")
-        if CEmitter._needs_math(resolved_ops):
+        if CEmitter._needs_math(resolved_ops, model.op_context):
             includes.add("#include <math.h>")
-        if CEmitter._needs_limits(resolved_ops):
+        if CEmitter._needs_limits(resolved_ops, model.op_context):
             includes.add("#include <limits.h>")
         if any(
             isinstance(op, (ConcatOp, ReshapeOp, SplitOp, IdentityOp))
@@ -2905,6 +3214,20 @@ class CEmitter:
             )
         )
 
+    @staticmethod
+    def _emit_unused_define() -> str:
+        return "\n".join(
+            (
+                "#ifndef EMX_UNUSED",
+                "#if defined(__GNUC__) || defined(__clang__)",
+                "#define EMX_UNUSED __attribute__((unused))",
+                "#else",
+                "#define EMX_UNUSED",
+                "#endif",
+                "#endif",
+            )
+        )
+
     @staticmethod
     def _needs_stdint(
         model_dtypes: set[ScalarType],
@@ -2940,12 +3263,15 @@ class CEmitter:
             | ClipOp
             | CastOp
             | QuantizeLinearOp
+            | DequantizeLinearOp
+            | QLinearMulOp
             | QLinearMatMulOp
             | MatMulOp
             | EinsumOp
             | GemmOp
             | AttentionOp
             | ConvOp
+            | ConvIntegerOp
             | ConvTransposeOp
             | AveragePoolOp
             | LpPoolOp
@@ -2957,6 +3283,7 @@ class CEmitter:
             | MeanVarianceNormalizationOp
             | RMSNormalizationOp
             | LrnOp
+            | GruOp
             | LstmOp
             | AdagradOp
             | SoftmaxOp
@@ -2988,14 +3315,17 @@ class CEmitter:
             | ConstantOfShapeOp
             | ShapeOp
             | SizeOp
+            | OptionalHasElementOp
             | NonZeroOp
             | NonMaxSuppressionOp
             | ExpandOp
             | CumSumOp
             | RangeOp
+            | HammingWindowOp
             | OneHotOp
             | SplitOp
         ],
+        op_context: OpContext,
     ) -> bool:
         math_ops = {
             "atanhf",
@@ -3014,13 +3344,18 @@ class CEmitter:
 
         def is_binary_math_op(op: BinaryOp) -> bool:
             op_spec = binary_op_symbol(
-                op.function, dtype=op.input_dtype, validate_attrs=False
+                op.function,
+                dtype=op_context.dtype(op.input0),
+                validate_attrs=False,
             )
             return op_spec is not None and op_spec.operator in binary_math_ops
 
         if any(
             isinstance(op, UnaryOp)
-            and unary_op_symbol(op.function, dtype=op.dtype) in math_ops
+            and unary_op_symbol(
+                op.function, dtype=op_context.dtype(op.output)
+            )
+            in math_ops
             for op in resolved_ops
         ):
             return True
@@ -3038,7 +3373,7 @@ class CEmitter:
             return True
         if any(
             isinstance(op, ClipOp)
-            and op.dtype.is_float
+            and op_context.dtype(op.output).is_float
             and (op.input_min is None or op.input_max is None)
             for op in resolved_ops
         ):
@@ -3061,6 +3396,7 @@ class CEmitter:
                     MeanVarianceNormalizationOp,
                     RMSNormalizationOp,
                     LrnOp,
+                    GruOp,
                     LstmOp,
                     AdagradOp,
                     SoftmaxOp,
@@ -3082,7 +3418,7 @@ class CEmitter:
         if any(
             isinstance(op, ReduceOp)
             and op.reduce_kind in {"min", "max"}
-            and op.dtype.is_float
+            and op_context.dtype(op.output).is_float
             for op in resolved_ops
         ):
             return True
@@ -3092,10 +3428,20 @@ class CEmitter:
         ):
             return True
         if any(
-            isinstance(op, (LpPoolOp, QuantizeLinearOp, QLinearMatMulOp))
+            isinstance(
+                op,
+                (
+                    LpPoolOp,
+                    QuantizeLinearOp,
+                    QLinearMulOp,
+                    QLinearMatMulOp,
+                ),
+            )
             for op in resolved_ops
         ):
             return True
+        if any(isinstance(op, HammingWindowOp) for op in resolved_ops):
+            return True
         return False
 
     @staticmethod
@@ -3106,12 +3452,15 @@ class CEmitter:
             | ClipOp
             | CastOp
             | QuantizeLinearOp
+            | DequantizeLinearOp
+            | QLinearMulOp
             | QLinearMatMulOp
             | MatMulOp
             | EinsumOp
             | GemmOp
             | AttentionOp
             | ConvOp
+            | ConvIntegerOp
             | ConvTransposeOp
             | AveragePoolOp
             | LpPoolOp
@@ -3123,6 +3472,7 @@ class CEmitter:
             | MeanVarianceNormalizationOp
             | RMSNormalizationOp
             | LrnOp
+            | GruOp
             | LstmOp
             | SoftmaxOp
             | LogSoftmaxOp
@@ -3151,19 +3501,23 @@ class CEmitter:
             | ConstantOfShapeOp
             | ShapeOp
             | SizeOp
+            | OptionalHasElementOp
             | NonZeroOp
             | NonMaxSuppressionOp
             | ExpandOp
             | CumSumOp
             | RangeOp
+            | HammingWindowOp
             | OneHotOp
             | SplitOp
         ],
+        op_context: OpContext,
     ) -> bool:
         if any(
             isinstance(op, ReduceOp)
             and op.reduce_kind in {"min", "max"}
-            and op.dtype in {
+            and op_context.dtype(op.output)
+            in {
                 ScalarType.I64,
                 ScalarType.I32,
                 ScalarType.I16,
@@ -3174,7 +3528,7 @@ class CEmitter:
             return True
         if any(
             isinstance(op, ClipOp)
-            and op.dtype.is_integer
+            and op_context.dtype(op.output).is_integer
             and (op.input_min is None or op.input_max is None)
             for op in resolved_ops
         ):
@@ -3187,7 +3541,7 @@ class CEmitter:
         ):
             return True
         if any(
-            isinstance(op, (QuantizeLinearOp, QLinearMatMulOp))
+            isinstance(op, (QuantizeLinearOp, QLinearMulOp, QLinearMatMulOp))
             and op.dtype.is_integer
             for op in resolved_ops
         ):
@@ -3206,12 +3560,15 @@ class CEmitter:
             | ClipOp
             | CastOp
             | QuantizeLinearOp
+            | DequantizeLinearOp
+            | QLinearMulOp
             | QLinearMatMulOp
             | MatMulOp
             | EinsumOp
             | GemmOp
             | AttentionOp
             | ConvOp
+            | ConvIntegerOp
             | ConvTransposeOp
             | AveragePoolOp
             | LpPoolOp
@@ -3223,6 +3580,7 @@ class CEmitter:
             | MeanVarianceNormalizationOp
             | RMSNormalizationOp
             | LrnOp
+            | GruOp
             | LstmOp
             | SoftmaxOp
             | LogSoftmaxOp
@@ -3256,6 +3614,7 @@ class CEmitter:
             | ExpandOp
             | CumSumOp
             | RangeOp
+            | HammingWindowOp
             | OneHotOp
             | SplitOp
         ],
@@ -3266,6 +3625,7 @@ class CEmitter:
         output_dim_names: Mapping[int, Mapping[int, str]],
     ) -> str:
         params = []
+        optional_flags = self._optional_input_flag_map(model)
         if dim_order:
             params.extend(self._format_dim_args(dim_order))
         for index, (name, shape, dtype) in enumerate(
@@ -3273,14 +3633,17 @@ class CEmitter:
         ):
             params.append(
                 f"const {dtype.c_type} {name}"
-                f"{self._param_array_suffix(shape, input_dim_names.get(index))}"
+                f"{self._param_array_suffix(shape, input_dim_names.get(index), use_restrict=True)}"
             )
+            optional_flag = optional_flags.get(name)
+            if optional_flag is not None:
+                params.append(f"_Bool {optional_flag}")
         for index, (name, shape, dtype) in enumerate(
             zip(model.output_names, model.output_shapes, model.output_dtypes)
         ):
             params.append(
                 f"{dtype.c_type} {name}"
-                f"{self._param_array_suffix(shape, output_dim_names.get(index))}"
+                f"{self._param_array_suffix(shape, output_dim_names.get(index), use_restrict=True)}"
             )
         signature = ", ".join(params)
         lines = [f"void {model.name}({signature}) {{"]
@@ -3297,7 +3660,7 @@ class CEmitter:
             )
         for index, op in enumerate(resolved_ops):
             op_name = self._op_function_name(model, index)
-            call = self._build_op_call(op, dim_order)
+            call = self._build_op_call(op, dim_order, optional_flags)
             lines.append(f"    {op_name}({call});")
         lines.append("}")
         return "\n".join(lines)
@@ -3309,14 +3672,16 @@ class CEmitter:
             element_count *= dim
         return element_count * temp.dtype.np_dtype.itemsize
 
-    @staticmethod
     def _build_op_call(
+        self,
         op: BinaryOp
         | WhereOp
         | UnaryOp
         | ClipOp
         | CastOp
         | QuantizeLinearOp
+        | DequantizeLinearOp
+        | QLinearMulOp
         | QLinearMatMulOp
         | MatMulOp
         | EinsumOp
@@ -3324,6 +3689,7 @@ class CEmitter:
         | AttentionOp
         | RotaryEmbeddingOp
         | ConvOp
+        | ConvIntegerOp
         | ConvTransposeOp
         | AveragePoolOp
         | LpPoolOp
@@ -3335,6 +3701,7 @@ class CEmitter:
         | MeanVarianceNormalizationOp
         | RMSNormalizationOp
         | LrnOp
+        | GruOp
         | LstmOp
         | AdagradOp
         | SoftmaxOp
@@ -3367,16 +3734,21 @@ class CEmitter:
         | ConstantOfShapeOp
         | ShapeOp
         | SizeOp
+        | OptionalHasElementOp
         | NonZeroOp
         | NonMaxSuppressionOp
         | ExpandOp
         | CumSumOp
         | RangeOp
+        | HammingWindowOp
         | OneHotOp
-        | SplitOp,
+        | SplitOp
+        | OptionalHasElementOp,
         dim_order: Sequence[str],
+        optional_flags: Mapping[str, str] | None = None,
     ) -> str:
         args: list[str] = []
+        optional_flags = optional_flags or {}
         if dim_order:
             args.extend(dim_order)
         if isinstance(op, BinaryOp):
@@ -3388,6 +3760,21 @@ class CEmitter:
         if isinstance(op, WhereOp):
             args.extend([op.condition, op.input_x, op.input_y, op.output])
             return ", ".join(args)
+        if isinstance(op, QLinearMulOp):
+            args.extend(
+                [
+                    op.input0,
+                    op.input0_scale,
+                    op.input0_zero_point,
+                    op.input1,
+                    op.input1_scale,
+                    op.input1_zero_point,
+                    op.output_scale,
+                    op.output_zero_point,
+                    op.output,
+                ]
+            )
+            return ", ".join(args)
         if isinstance(op, QLinearMatMulOp):
             args.extend(
                 [
@@ -3434,6 +3821,13 @@ class CEmitter:
             call_parts.append(op.output)
             args.extend(call_parts)
             return ", ".join(args)
+        if isinstance(op, DequantizeLinearOp):
+            call_parts = [op.input0, op.scale]
+            if op.zero_point is not None:
+                call_parts.append(op.zero_point)
+            call_parts.append(op.output)
+            args.extend(call_parts)
+            return ", ".join(args)
         if isinstance(op, AttentionOp):
             call_parts = [op.input_q, op.input_k, op.input_v]
             if op.input_attn_mask is not None:
@@ -3453,12 +3847,27 @@ class CEmitter:
                 call_parts.append(op.output_qk_matmul)
             args.extend(call_parts)
             return ", ".join(args)
+        if isinstance(op, RotaryEmbeddingOp):
+            call_parts = [op.input0, op.cos_cache, op.sin_cache]
+            if op.position_ids is not None:
+                call_parts.append(op.position_ids)
+            call_parts.append(op.output)
+            args.extend(call_parts)
+            return ", ".join(args)
         if isinstance(op, ConvOp):
             if op.bias is None:
                 args.extend([op.input0, op.weights, op.output])
                 return ", ".join(args)
             args.extend([op.input0, op.weights, op.bias, op.output])
             return ", ".join(args)
+        if isinstance(op, ConvIntegerOp):
+            args.extend([op.input0, op.weights])
+            if op.x_zero_point is not None:
+                args.append(op.x_zero_point)
+            if op.w_zero_point is not None:
+                args.append(op.w_zero_point)
+            args.append(op.output)
+            return ", ".join(args)
         if isinstance(op, ConvTransposeOp):
             if op.bias is None:
                 args.extend([op.input0, op.weights, op.output])
@@ -3502,6 +3911,20 @@ class CEmitter:
         if isinstance(op, RMSNormalizationOp):
             args.extend([op.input0, op.scale, op.output])
             return ", ".join(args)
+        if isinstance(op, GruOp):
+            call_parts = [op.input_x, op.input_w, op.input_r]
+            if op.input_b is not None:
+                call_parts.append(op.input_b)
+            if op.input_sequence_lens is not None:
+                call_parts.append(op.input_sequence_lens)
+            if op.input_initial_h is not None:
+                call_parts.append(op.input_initial_h)
+            if op.output_y is not None:
+                call_parts.append(op.output_y)
+            if op.output_y_h is not None:
+                call_parts.append(op.output_y_h)
+            args.extend(call_parts)
+            return ", ".join(args)
         if isinstance(op, LstmOp):
             call_parts = [op.input_x, op.input_w, op.input_r]
             if op.input_b is not None:
@@ -3523,17 +3946,18 @@ class CEmitter:
             args.extend(call_parts)
             return ", ".join(args)
         if isinstance(op, AdagradOp):
-            args.extend(
-                [
-                    op.rate,
-                    op.timestep,
-                    *op.inputs,
-                    *op.gradients,
-                    *op.accumulators,
-                    *op.outputs,
-                    *op.accumulator_outputs,
-                ]
-            )
+            args.append(op.rate)
+            args.append(op.timestep)
+            for index in range(len(op.inputs)):
+                args.extend(
+                    [
+                        op.inputs[index],
+                        op.gradients[index],
+                        op.accumulators[index],
+                        op.outputs[index],
+                        op.accumulator_outputs[index],
+                    ]
+                )
             return ", ".join(args)
         if isinstance(op, (SoftmaxOp, LogSoftmaxOp, HardmaxOp)):
             args.extend([op.input0, op.output])
@@ -3590,6 +4014,14 @@ class CEmitter:
         if isinstance(op, SizeOp):
             args.extend([op.input0, op.output])
             return ", ".join(args)
+        if isinstance(op, OptionalHasElementOp):
+            input_flag = optional_flags.get(op.input0)
+            if input_flag is None:
+                raise CodegenError(
+                    "OptionalHasElement expects an optional input flag."
+                )
+            args.extend([op.input0, input_flag, op.output])
+            return ", ".join(args)
         if isinstance(op, NonZeroOp):
             args.extend([op.input0, op.output])
             return ", ".join(args)
@@ -3622,6 +4054,9 @@ class CEmitter:
         if isinstance(op, RangeOp):
             args.extend([op.start, op.limit, op.delta, op.output])
             return ", ".join(args)
+        if isinstance(op, HammingWindowOp):
+            args.extend([op.size, op.output])
+            return ", ".join(args)
         if isinstance(op, OneHotOp):
             args.extend([op.indices, op.depth, op.values, op.output])
             return ", ".join(args)
@@ -3732,12 +4167,15 @@ class CEmitter:
     @staticmethod
     def _resolve_op(
         op: BinaryOp
+        | PowOp
         | MultiInputBinaryOp
         | WhereOp
         | UnaryOp
         | ClipOp
         | CastOp
         | QuantizeLinearOp
+        | DequantizeLinearOp
+        | QLinearMulOp
         | QLinearMatMulOp
         | MatMulOp
         | EinsumOp
@@ -3745,6 +4183,7 @@ class CEmitter:
         | AttentionOp
         | RotaryEmbeddingOp
         | ConvOp
+        | ConvIntegerOp
         | ConvTransposeOp
         | AveragePoolOp
         | LpPoolOp
@@ -3756,6 +4195,7 @@ class CEmitter:
         | MeanVarianceNormalizationOp
         | RMSNormalizationOp
         | LrnOp
+        | GruOp
         | LstmOp
         | AdagradOp
         | SoftmaxOp
@@ -3792,23 +4232,29 @@ class CEmitter:
         | ExpandOp
         | CumSumOp
         | RangeOp
+        | HammingWindowOp
         | OneHotOp
+        | TfIdfVectorizerOp
         | SplitOp,
         temp_map: dict[str, str],
     ) -> (
         BinaryOp
+        | PowOp
         | MultiInputBinaryOp
         | WhereOp
         | UnaryOp
         | ClipOp
         | CastOp
         | QuantizeLinearOp
+        | DequantizeLinearOp
+        | QLinearMulOp
         | QLinearMatMulOp
         | MatMulOp
         | EinsumOp
         | GemmOp
         | AttentionOp
         | ConvOp
+        | ConvIntegerOp
         | ConvTransposeOp
         | AveragePoolOp
         | LpPoolOp
@@ -3820,6 +4266,7 @@ class CEmitter:
         | MeanVarianceNormalizationOp
         | RMSNormalizationOp
         | LrnOp
+        | GruOp
         | LstmOp
         | AdagradOp
         | SoftmaxOp
@@ -3856,9 +4303,19 @@ class CEmitter:
         | ExpandOp
         | CumSumOp
         | RangeOp
+        | HammingWindowOp
         | OneHotOp
         | SplitOp
+        | TfIdfVectorizerOp
     ):
+        if isinstance(op, PowOp):
+            return PowOp(
+                input0=temp_map.get(op.input0, op.input0),
+                input1=temp_map.get(op.input1, op.input1),
+                output=temp_map.get(op.output, op.output),
+                function=op.function,
+                operator_kind=op.operator_kind,
+            )
         if isinstance(op, BinaryOp):
             return BinaryOp(
                 input0=temp_map.get(op.input0, op.input0),
@@ -3866,11 +4323,6 @@ class CEmitter:
                 output=temp_map.get(op.output, op.output),
                 function=op.function,
                 operator_kind=op.operator_kind,
-                input0_shape=op.input0_shape,
-                input1_shape=op.input1_shape,
-                shape=op.shape,
-                dtype=op.dtype,
-                input_dtype=op.input_dtype,
             )
         if isinstance(op, MultiInputBinaryOp):
             return MultiInputBinaryOp(
@@ -3888,20 +4340,12 @@ class CEmitter:
                 input_x=temp_map.get(op.input_x, op.input_x),
                 input_y=temp_map.get(op.input_y, op.input_y),
                 output=temp_map.get(op.output, op.output),
-                condition_shape=op.condition_shape,
-                x_shape=op.x_shape,
-                y_shape=op.y_shape,
-                output_shape=op.output_shape,
-                dtype=op.dtype,
             )
         if isinstance(op, UnaryOp):
             return UnaryOp(
                 input0=temp_map.get(op.input0, op.input0),
                 output=temp_map.get(op.output, op.output),
                 function=op.function,
-                shape=op.shape,
-                dtype=op.dtype,
-                input_dtype=op.input_dtype,
                 params=op.params,
             )
         if isinstance(op, ClipOp):
@@ -3914,29 +4358,14 @@ class CEmitter:
                 if op.input_max is not None
                 else None,
                 output=temp_map.get(op.output, op.output),
-                input_shape=op.input_shape,
-                min_shape=op.min_shape,
-                max_shape=op.max_shape,
-                output_shape=op.output_shape,
-                dtype=op.dtype,
+                min_value=op.min_value,
+                max_value=op.max_value,
             )
         if isinstance(op, MatMulOp):
             return MatMulOp(
                 input0=temp_map.get(op.input0, op.input0),
                 input1=temp_map.get(op.input1, op.input1),
                 output=temp_map.get(op.output, op.output),
-                input0_shape=op.input0_shape,
-                input1_shape=op.input1_shape,
-                output_shape=op.output_shape,
-                batch_shape=op.batch_shape,
-                input0_batch_shape=op.input0_batch_shape,
-                input1_batch_shape=op.input1_batch_shape,
-                m=op.m,
-                n=op.n,
-                k=op.k,
-                left_vector=op.left_vector,
-                right_vector=op.right_vector,
-                dtype=op.dtype,
             )
         if isinstance(op, EinsumOp):
             return EinsumOp(
@@ -3972,6 +4401,56 @@ class CEmitter:
                 input_dtype=op.input_dtype,
                 scale_dtype=op.scale_dtype,
             )
+        if isinstance(op, DequantizeLinearOp):
+            return DequantizeLinearOp(
+                input0=temp_map.get(op.input0, op.input0),
+                scale=temp_map.get(op.scale, op.scale),
+                zero_point=(
+                    temp_map.get(op.zero_point, op.zero_point)
+                    if op.zero_point is not None
+                    else None
+                ),
+                output=temp_map.get(op.output, op.output),
+                input_shape=op.input_shape,
+                axis=op.axis,
+                block_size=op.block_size,
+                dtype=op.dtype,
+                input_dtype=op.input_dtype,
+                scale_dtype=op.scale_dtype,
+            )
+        if isinstance(op, QLinearMulOp):
+            return QLinearMulOp(
+                input0=temp_map.get(op.input0, op.input0),
+                input0_scale=temp_map.get(op.input0_scale, op.input0_scale),
+                input0_zero_point=temp_map.get(
+                    op.input0_zero_point, op.input0_zero_point
+                ),
+                input1=temp_map.get(op.input1, op.input1),
+                input1_scale=temp_map.get(op.input1_scale, op.input1_scale),
+                input1_zero_point=temp_map.get(
+                    op.input1_zero_point, op.input1_zero_point
+                ),
+                output_scale=temp_map.get(op.output_scale, op.output_scale),
+                output_zero_point=temp_map.get(
+                    op.output_zero_point, op.output_zero_point
+                ),
+                output=temp_map.get(op.output, op.output),
+                input0_shape=op.input0_shape,
+                input1_shape=op.input1_shape,
+                output_shape=op.output_shape,
+                input0_dtype=op.input0_dtype,
+                input1_dtype=op.input1_dtype,
+                dtype=op.dtype,
+                input0_scale_dtype=op.input0_scale_dtype,
+                input1_scale_dtype=op.input1_scale_dtype,
+                output_scale_dtype=op.output_scale_dtype,
+                input0_scale_shape=op.input0_scale_shape,
+                input1_scale_shape=op.input1_scale_shape,
+                output_scale_shape=op.output_scale_shape,
+                input0_zero_shape=op.input0_zero_shape,
+                input1_zero_shape=op.input1_zero_shape,
+                output_zero_shape=op.output_zero_shape,
+            )
         if isinstance(op, QLinearMatMulOp):
             return QLinearMatMulOp(
                 input0=temp_map.get(op.input0, op.input0),
@@ -4023,15 +4502,10 @@ class CEmitter:
                     else None
                 ),
                 output=temp_map.get(op.output, op.output),
-                m=op.m,
-                n=op.n,
-                k=op.k,
                 trans_a=op.trans_a,
                 trans_b=op.trans_b,
                 alpha=op.alpha,
                 beta=op.beta,
-                c_shape=op.c_shape,
-                dtype=op.dtype,
             )
         if isinstance(op, AttentionOp):
             return AttentionOp(
@@ -4133,6 +4607,51 @@ class CEmitter:
                 input_rank=op.input_rank,
                 interleaved=op.interleaved,
             )
+        if isinstance(op, GruOp):
+            return GruOp(
+                input_x=temp_map.get(op.input_x, op.input_x),
+                input_w=temp_map.get(op.input_w, op.input_w),
+                input_r=temp_map.get(op.input_r, op.input_r),
+                input_b=(
+                    temp_map.get(op.input_b, op.input_b)
+                    if op.input_b is not None
+                    else None
+                ),
+                input_sequence_lens=(
+                    temp_map.get(op.input_sequence_lens, op.input_sequence_lens)
+                    if op.input_sequence_lens is not None
+                    else None
+                ),
+                input_initial_h=(
+                    temp_map.get(op.input_initial_h, op.input_initial_h)
+                    if op.input_initial_h is not None
+                    else None
+                ),
+                output_y=(
+                    temp_map.get(op.output_y, op.output_y)
+                    if op.output_y is not None
+                    else None
+                ),
+                output_y_h=(
+                    temp_map.get(op.output_y_h, op.output_y_h)
+                    if op.output_y_h is not None
+                    else None
+                ),
+                seq_length=op.seq_length,
+                batch_size=op.batch_size,
+                input_size=op.input_size,
+                hidden_size=op.hidden_size,
+                num_directions=op.num_directions,
+                direction=op.direction,
+                layout=op.layout,
+                linear_before_reset=op.linear_before_reset,
+                clip=op.clip,
+                activation_kinds=op.activation_kinds,
+                activation_alphas=op.activation_alphas,
+                activation_betas=op.activation_betas,
+                dtype=op.dtype,
+                sequence_lens_dtype=op.sequence_lens_dtype,
+            )
         if isinstance(op, LstmOp):
             return LstmOp(
                 input_x=temp_map.get(op.input_x, op.input_x),
@@ -4239,6 +4758,35 @@ class CEmitter:
                 group=op.group,
                 dtype=op.dtype,
             )
+        if isinstance(op, ConvIntegerOp):
+            return ConvIntegerOp(
+                input0=temp_map.get(op.input0, op.input0),
+                weights=temp_map.get(op.weights, op.weights),
+                x_zero_point=temp_map.get(op.x_zero_point, op.x_zero_point)
+                if op.x_zero_point
+                else None,
+                w_zero_point=temp_map.get(op.w_zero_point, op.w_zero_point)
+                if op.w_zero_point
+                else None,
+                output=temp_map.get(op.output, op.output),
+                batch=op.batch,
+                in_channels=op.in_channels,
+                out_channels=op.out_channels,
+                spatial_rank=op.spatial_rank,
+                in_spatial=op.in_spatial,
+                out_spatial=op.out_spatial,
+                kernel_shape=op.kernel_shape,
+                strides=op.strides,
+                pads=op.pads,
+                dilations=op.dilations,
+                group=op.group,
+                input_dtype=op.input_dtype,
+                weight_dtype=op.weight_dtype,
+                dtype=op.dtype,
+                x_zero_point_shape=op.x_zero_point_shape,
+                w_zero_point_shape=op.w_zero_point_shape,
+                w_zero_point_per_channel=op.w_zero_point_per_channel,
+            )
         if isinstance(op, ConvTransposeOp):
             return ConvTransposeOp(
                 input0=temp_map.get(op.input0, op.input0),
@@ -4265,16 +4813,26 @@ class CEmitter:
                 output=temp_map.get(op.output, op.output),
                 batch=op.batch,
                 channels=op.channels,
+                spatial_rank=op.spatial_rank,
+                in_d=op.in_d,
                 in_h=op.in_h,
                 in_w=op.in_w,
+                out_d=op.out_d,
                 out_h=op.out_h,
                 out_w=op.out_w,
+                kernel_d=op.kernel_d,
                 kernel_h=op.kernel_h,
                 kernel_w=op.kernel_w,
+                dilation_d=op.dilation_d,
+                dilation_h=op.dilation_h,
+                dilation_w=op.dilation_w,
+                stride_d=op.stride_d,
                 stride_h=op.stride_h,
                 stride_w=op.stride_w,
+                pad_front=op.pad_front,
                 pad_top=op.pad_top,
                 pad_left=op.pad_left,
+                pad_back=op.pad_back,
                 pad_bottom=op.pad_bottom,
                 pad_right=op.pad_right,
                 count_include_pad=op.count_include_pad,
@@ -4292,6 +4850,8 @@ class CEmitter:
                 out_w=op.out_w,
                 kernel_h=op.kernel_h,
                 kernel_w=op.kernel_w,
+                dilation_h=op.dilation_h,
+                dilation_w=op.dilation_w,
                 stride_h=op.stride_h,
                 stride_w=op.stride_w,
                 pad_top=op.pad_top,
@@ -4420,34 +4980,19 @@ class CEmitter:
             return SoftmaxOp(
                 input0=temp_map.get(op.input0, op.input0),
                 output=temp_map.get(op.output, op.output),
-                outer=op.outer,
-                axis_size=op.axis_size,
-                inner=op.inner,
                 axis=op.axis,
-                shape=op.shape,
-                dtype=op.dtype,
             )
         if isinstance(op, LogSoftmaxOp):
             return LogSoftmaxOp(
                 input0=temp_map.get(op.input0, op.input0),
                 output=temp_map.get(op.output, op.output),
-                outer=op.outer,
-                axis_size=op.axis_size,
-                inner=op.inner,
                 axis=op.axis,
-                shape=op.shape,
-                dtype=op.dtype,
             )
         if isinstance(op, HardmaxOp):
             return HardmaxOp(
                 input0=temp_map.get(op.input0, op.input0),
                 output=temp_map.get(op.output, op.output),
-                outer=op.outer,
-                axis_size=op.axis_size,
-                inner=op.inner,
                 axis=op.axis,
-                shape=op.shape,
-                dtype=op.dtype,
             )
         if isinstance(op, NegativeLogLikelihoodLossOp):
             return NegativeLogLikelihoodLossOp(
@@ -4629,6 +5174,11 @@ class CEmitter:
                 dtype=op.dtype,
                 input_dtype=op.input_dtype,
             )
+        if isinstance(op, OptionalHasElementOp):
+            return OptionalHasElementOp(
+                input0=temp_map.get(op.input0, op.input0),
+                output=temp_map.get(op.output, op.output),
+            )
         if isinstance(op, NonZeroOp):
             return NonZeroOp(
                 input0=temp_map.get(op.input0, op.input0),
@@ -4695,6 +5245,15 @@ class CEmitter:
                 dtype=op.dtype,
                 input_dtype=op.input_dtype,
             )
+        if isinstance(op, HammingWindowOp):
+            return HammingWindowOp(
+                size=temp_map.get(op.size, op.size),
+                output=temp_map.get(op.output, op.output),
+                output_shape=op.output_shape,
+                periodic=op.periodic,
+                dtype=op.dtype,
+                input_dtype=op.input_dtype,
+            )
         if isinstance(op, OneHotOp):
             return OneHotOp(
                 indices=temp_map.get(op.indices, op.indices),
@@ -4710,6 +5269,23 @@ class CEmitter:
                 indices_dtype=op.indices_dtype,
                 depth_dtype=op.depth_dtype,
             )
+        if isinstance(op, TfIdfVectorizerOp):
+            return TfIdfVectorizerOp(
+                input0=temp_map.get(op.input0, op.input0),
+                output=temp_map.get(op.output, op.output),
+                input_shape=op.input_shape,
+                output_shape=op.output_shape,
+                input_dtype=op.input_dtype,
+                output_dtype=op.output_dtype,
+                min_gram_length=op.min_gram_length,
+                max_gram_length=op.max_gram_length,
+                max_skip_count=op.max_skip_count,
+                mode=op.mode,
+                ngram_counts=op.ngram_counts,
+                ngram_indexes=op.ngram_indexes,
+                pool_int64s=op.pool_int64s,
+                weights=op.weights,
+            )
         if isinstance(op, SplitOp):
             return SplitOp(
                 input0=temp_map.get(op.input0, op.input0),
@@ -4746,9 +5322,6 @@ class CEmitter:
             return IdentityOp(
                 input0=temp_map.get(op.input0, op.input0),
                 output=temp_map.get(op.output, op.output),
-                shape=op.shape,
-                dtype=op.dtype,
-                input_dtype=op.input_dtype,
             )
         if isinstance(op, EyeLikeOp):
             return EyeLikeOp(
@@ -4934,54 +5507,50 @@ class CEmitter:
             return ReduceOp(
                 input0=temp_map.get(op.input0, op.input0),
                 output=temp_map.get(op.output, op.output),
-                input_shape=op.input_shape,
-                output_shape=op.output_shape,
                 axes=op.axes,
                 axes_input=temp_map.get(op.axes_input, op.axes_input)
                 if op.axes_input
                 else None,
-                axes_input_shape=op.axes_input_shape,
-                axes_input_dtype=op.axes_input_dtype,
                 keepdims=op.keepdims,
                 noop_with_empty_axes=op.noop_with_empty_axes,
                 reduce_kind=op.reduce_kind,
                 reduce_count=op.reduce_count,
-                dtype=op.dtype,
             )
         if isinstance(op, ArgReduceOp):
             return ArgReduceOp(
                 input0=temp_map.get(op.input0, op.input0),
                 output=temp_map.get(op.output, op.output),
-                input_shape=op.input_shape,
-                output_shape=op.output_shape,
                 axis=op.axis,
                 keepdims=op.keepdims,
                 select_last_index=op.select_last_index,
                 reduce_kind=op.reduce_kind,
-                input_dtype=op.input_dtype,
-                output_dtype=op.output_dtype,
             )
         if isinstance(op, TopKOp):
             return TopKOp(
                 input0=temp_map.get(op.input0, op.input0),
+                k_input=temp_map.get(op.k_input, op.k_input),
                 output_values=temp_map.get(op.output_values, op.output_values),
                 output_indices=temp_map.get(op.output_indices, op.output_indices),
-                input_shape=op.input_shape,
-                output_shape=op.output_shape,
                 axis=op.axis,
                 k=op.k,
                 largest=op.largest,
                 sorted=op.sorted,
+            )
+        if isinstance(op, BernoulliOp):
+            return BernoulliOp(
+                input0=temp_map.get(op.input0, op.input0),
+                output=temp_map.get(op.output, op.output),
+                input_shape=op.input_shape,
+                output_shape=op.output_shape,
                 input_dtype=op.input_dtype,
-                output_values_dtype=op.output_values_dtype,
-                output_indices_dtype=op.output_indices_dtype,
+                dtype=op.dtype,
+                seed=op.seed,
             )
         return UnaryOp(
             input0=temp_map.get(op.input0, op.input0),
             output=temp_map.get(op.output, op.output),
             function=op.function,
-            shape=op.shape,
-            dtype=op.dtype,
+            params=op.params,
         )
 
     def render_op(self, op: OpBase, ctx: EmitContext) -> str:
@@ -5007,6 +5576,8 @@ class CEmitter:
             clip_template=templates["clip"],
             cast_template=templates["cast"],
             quantize_linear_template=templates["quantize_linear"],
+            dequantize_linear_template=templates["dequantize_linear"],
+            qlinear_mul_template=templates["qlinear_mul"],
             qlinear_matmul_template=templates["qlinear_matmul"],
             matmul_template=templates["matmul"],
             einsum_template=templates["einsum"],
@@ -5014,6 +5585,7 @@ class CEmitter:
             attention_template=templates["attention"],
             rotary_embedding_template=templates["rotary_embedding"],
             conv_template=templates["conv"],
+            conv_integer_template=templates["conv_integer"],
             conv_transpose_template=templates["conv_transpose"],
             avg_pool_template=templates["avg_pool"],
             lp_pool_template=templates["lp_pool"],
@@ -5025,6 +5597,7 @@ class CEmitter:
             mean_variance_norm_template=templates["mean_variance_norm"],
             rms_norm_template=templates["rms_norm"],
             lrn_template=templates["lrn"],
+            gru_template=templates["gru"],
             lstm_template=templates["lstm"],
             adagrad_template=templates["adagrad"],
             softmax_template=templates["softmax"],
@@ -5043,6 +5616,7 @@ class CEmitter:
             transpose_template=templates["transpose"],
             reshape_template=templates["reshape"],
             identity_template=templates["identity"],
+            bernoulli_template=templates["bernoulli"],
             eye_like_template=templates["eye_like"],
             trilu_template=templates["trilu"],
             tile_template=templates["tile"],
@@ -5060,12 +5634,15 @@ class CEmitter:
             constant_of_shape_template=templates["constant_of_shape"],
             shape_template=templates["shape"],
             size_template=templates["size"],
+            optional_has_element_template=templates["optional_has_element"],
             nonzero_template=templates["nonzero"],
             nonmax_suppression_template=templates["nonmax_suppression"],
             expand_template=templates["expand"],
             cumsum_template=templates["cumsum"],
             range_template=templates["range"],
+            hamming_window_template=templates["hamming_window"],
             one_hot_template=templates["one_hot"],
+            tfidf_vectorizer_template=templates["tfidf_vectorizer"],
             split_template=templates["split"],
             scalar_registry=state.scalar_registry,
             dim_args=state.dim_args,
@@ -5091,6 +5668,8 @@ class CEmitter:
         clip_template,
         cast_template,
         quantize_linear_template,
+        dequantize_linear_template,
+        qlinear_mul_template,
         qlinear_matmul_template,
         matmul_template,
         einsum_template,
@@ -5098,6 +5677,7 @@ class CEmitter:
         attention_template,
         rotary_embedding_template,
         conv_template,
+        conv_integer_template,
         conv_transpose_template,
         avg_pool_template,
         lp_pool_template,
@@ -5109,6 +5689,7 @@ class CEmitter:
         mean_variance_norm_template,
         rms_norm_template,
         lrn_template,
+        gru_template,
         lstm_template,
         adagrad_template,
         softmax_template,
@@ -5125,6 +5706,7 @@ class CEmitter:
         transpose_template,
         reshape_template,
         identity_template,
+        bernoulli_template,
         eye_like_template,
         trilu_template,
         tile_template,
@@ -5142,12 +5724,15 @@ class CEmitter:
         constant_of_shape_template,
         shape_template,
         size_template,
+        optional_has_element_template,
         nonzero_template,
         nonmax_suppression_template,
         expand_template,
         cumsum_template,
         range_template,
+        hamming_window_template,
         one_hot_template,
+        tfidf_vectorizer_template,
         split_template,
         scalar_registry: ScalarFunctionRegistry | None = None,
         dim_args: str = "",
@@ -5169,6 +5754,11 @@ class CEmitter:
             input1_shape = self._ctx_shape(op.input1)
             output_shape = self._ctx_shape(op.output)
             input_dtype = self._ctx_dtype(op.input0)
+            input1_dtype = (
+                self._ctx_dtype(op.input1)
+                if isinstance(op, PowOp)
+                else input_dtype
+            )
             output_dtype = self._ctx_dtype(op.output)
             params = self._shared_param_map(
                 [
@@ -5207,11 +5797,12 @@ class CEmitter:
                 input1_shape, _dim_names_for(op.input1)
             )
             input_c_type = input_dtype.c_type
+            input1_c_type = input1_dtype.c_type
             output_c_type = output_dtype.c_type
             param_decls = self._build_param_decls(
                 [
                     (params["input0"], input_c_type, input0_suffix, True),
-                    (params["input1"], input_c_type, input1_suffix, True),
+                    (params["input1"], input1_c_type, input1_suffix, True),
                     (params["output"], output_c_type, output_suffix, False),
                 ]
             )
@@ -5234,12 +5825,20 @@ class CEmitter:
                 output_shape,
                 loop_vars,
             )
-            right_expr = CEmitter._broadcast_index_expr(
-                params["input1"],
-                input1_shape,
-                output_shape,
-                loop_vars,
-            )
+            prelu_axis = None
+            if op.function == ScalarFunction.PRELU:
+                derived_axis = self._maybe_derived(op, "prelu_slope_axis")
+                if isinstance(derived_axis, int):
+                    prelu_axis = derived_axis
+            if prelu_axis is None:
+                right_expr = CEmitter._broadcast_index_expr(
+                    params["input1"],
+                    input1_shape,
+                    output_shape,
+                    loop_vars,
+                )
+            else:
+                right_expr = f"{params['input1']}[{loop_vars[prelu_axis]}]"
             operator_expr = None
             operator = op_spec.operator
             operator_kind = op.operator_kind
@@ -5263,7 +5862,7 @@ class CEmitter:
             ).rstrip()
             return with_node_comment(rendered)
         if isinstance(op, MultiInputBinaryOp):
-            output_shape = self._ctx_shape(op.output)
+            output_shape_raw = self._ctx_shape(op.output)
             input_dtype = self._ctx_dtype(op.inputs[0])
             output_dtype = self._ctx_dtype(op.output)
             params = self._shared_param_map(
@@ -5292,27 +5891,47 @@ class CEmitter:
                     f"{op.function.value}"
                 )
             output_dim_names = _dim_names_for(op.output)
-            shape = CEmitter._shape_dim_exprs(output_shape, output_dim_names)
-            loop_vars = CEmitter._loop_vars(output_shape)
-            array_suffix = self._param_array_suffix(
-                output_shape, output_dim_names
+            shape = CEmitter._shape_dim_exprs(
+                output_shape_raw, output_dim_names
+            )
+            loop_vars = CEmitter._loop_vars(output_shape_raw)
+            output_array_suffix = self._param_array_suffix(
+                output_shape_raw, output_dim_names
             )
             input_c_type = input_dtype.c_type
             output_c_type = output_dtype.c_type
             input_names = [
                 params[f"input{idx}"] for idx in range(len(op.inputs))
             ]
+            input_shapes = [self._ctx_shape(name) for name in op.inputs]
+            input_dim_names = [
+                _dim_names_for(name) for name in op.inputs
+            ]
+            input_array_suffixes = [
+                self._param_array_suffix(shape, dim_names)
+                for shape, dim_names in zip(input_shapes, input_dim_names)
+            ]
             param_decls = self._build_param_decls(
                 [
-                    *( (name, input_c_type, array_suffix, True) for name in input_names ),
-                    (params["output"], output_c_type, array_suffix, False),
+                    *(
+                        (name, input_c_type, array_suffix, True)
+                        for name, array_suffix in zip(
+                            input_names, input_array_suffixes
+                        )
+                    ),
+                    (
+                        params["output"],
+                        output_c_type,
+                        output_array_suffix,
+                        False,
+                    ),
                 ]
             )
             common = {
                 "model_name": model.name,
                 "op_name": op_name,
                 "element_count": CEmitter._element_count_expr(shape),
-                "array_suffix": array_suffix,
+                "array_suffix": output_array_suffix,
                 "shape": shape,
                 "loop_vars": loop_vars,
                 "input_c_type": input_c_type,
@@ -5322,8 +5941,10 @@ class CEmitter:
                 "params": param_decls,
             }
             input_exprs = [
-                f"{name}" + "".join(f"[{var}]" for var in loop_vars)
-                for name in input_names
+                CEmitter._broadcast_index_expr(
+                    name, shape, output_shape_raw, loop_vars
+                )
+                for name, shape in zip(input_names, input_shapes)
             ]
             output_expr = f"{params['output']}" + "".join(
                 f"[{var}]" for var in loop_vars
@@ -5452,37 +6073,51 @@ class CEmitter:
                     ("output", op.output),
                 ]
             )
-            output_shape = CEmitter._codegen_shape(op.output_shape)
+            output_shape = CEmitter._codegen_shape(self._ctx_shape(op.output))
             output_loop_vars = CEmitter._loop_vars(output_shape)
             output_index_expr = f"{params['output']}" + "".join(
                 f"[{var}]" for var in output_loop_vars
             )
-            batch_rank = len(op.batch_shape)
+            batch_shape = self._derived(op, "batch_shape")
+            batch_rank = len(batch_shape)
             batch_vars = output_loop_vars[:batch_rank]
-            if op.left_vector and op.right_vector:
+            left_vector = bool(self._derived(op, "left_vector"))
+            right_vector = bool(self._derived(op, "right_vector"))
+            if left_vector and right_vector:
                 row_var = None
                 col_var = None
-            elif op.left_vector:
+            elif left_vector:
                 row_var = None
                 col_var = output_loop_vars[-1]
-            elif op.right_vector:
+            elif right_vector:
                 row_var = output_loop_vars[-1]
                 col_var = None
             else:
                 row_var = output_loop_vars[-2]
                 col_var = output_loop_vars[-1]
+            input0_shape = self._ctx_shape(op.input0)
+            input1_shape = self._ctx_shape(op.input1)
+            input0_batch_shape = self._derived(op, "input0_batch_shape")
+            input1_batch_shape = self._derived(op, "input1_batch_shape")
             input0_index_expr, input1_index_expr = CEmitter._matmul_index_exprs(
-                op,
                 batch_vars,
                 row_var,
                 col_var,
                 batch_rank,
                 input0=params["input0"],
                 input1=params["input1"],
-            )
-            input0_suffix = self._param_array_suffix(op.input0_shape)
-            input1_suffix = self._param_array_suffix(op.input1_shape)
-            output_suffix = self._param_array_suffix(op.output_shape)
+                left_vector=left_vector,
+                right_vector=right_vector,
+                input0_shape=input0_shape,
+                input1_shape=input1_shape,
+                input0_batch_shape=input0_batch_shape,
+                input1_batch_shape=input1_batch_shape,
+            )
+            input0_suffix = self._param_array_suffix(input0_shape)
+            input1_suffix = self._param_array_suffix(input1_shape)
+            output_suffix = self._param_array_suffix(self._ctx_shape(op.output))
+            acc_dtype = self._accumulation_dtype(self._ctx_dtype(op.output))
+            acc_zero_literal = CEmitter._format_literal(acc_dtype, 0)
             param_decls = self._build_param_decls(
                 [
                     (params["input0"], c_type, input0_suffix, True),
@@ -5490,6 +6125,9 @@ class CEmitter:
                     (params["output"], c_type, output_suffix, False),
                 ]
             )
+            m = int(self._derived(op, "m"))
+            n = int(self._derived(op, "n"))
+            k = int(self._derived(op, "k"))
             rendered = matmul_template.render(
                 model_name=model.name,
                 op_name=op_name,
@@ -5498,8 +6136,8 @@ class CEmitter:
                 output=params["output"],
                 params=param_decls,
                 c_type=c_type,
-                acc_type=c_type,
-                zero_literal=zero_literal,
+                acc_type=acc_dtype.c_type,
+                zero_literal=acc_zero_literal,
                 input0_suffix=input0_suffix,
                 input1_suffix=input1_suffix,
                 output_suffix=output_suffix,
@@ -5508,9 +6146,9 @@ class CEmitter:
                 output_index_expr=output_index_expr,
                 input0_index_expr=input0_index_expr,
                 input1_index_expr=input1_index_expr,
-                m=op.m,
-                n=op.n,
-                k=op.k,
+                m=m,
+                n=n,
+                k=k,
             ).rstrip()
             return with_node_comment(rendered)
         if isinstance(op, EinsumOp):
@@ -5561,6 +6199,8 @@ class CEmitter:
                     ),
                 ]
             )
+            acc_dtype = self._accumulation_dtype(self._ctx_dtype(op.output))
+            acc_zero_literal = CEmitter._format_literal(acc_dtype, 0)
             input_loop_vars: tuple[str, ...] = ()
             input_loop_bounds: tuple[str | int, ...] = ()
             reduce_loop_var = "k"
@@ -5633,8 +6273,8 @@ class CEmitter:
                 output_loop_vars=output_loop_vars,
                 output_loop_bounds=output_shape,
                 output_expr=output_expr,
-                acc_type=op.dtype.c_type,
-                zero_literal=zero_literal,
+                acc_type=acc_dtype.c_type,
+                zero_literal=acc_zero_literal,
                 input_loop_vars=input_loop_vars,
                 input_loop_bounds=input_loop_bounds,
                 reduce_loop_var=reduce_loop_var,
@@ -5653,14 +6293,20 @@ class CEmitter:
                     ("output", op.output),
                 ]
             )
-            input_a_shape = (op.k, op.m) if op.trans_a else (op.m, op.k)
-            input_b_shape = (op.n, op.k) if op.trans_b else (op.k, op.n)
+            m = int(self._derived(op, "m"))
+            n = int(self._derived(op, "n"))
+            k = int(self._derived(op, "k"))
+            trans_a = bool(self._derived(op, "trans_a"))
+            trans_b = bool(self._derived(op, "trans_b"))
+            c_shape = self._derived(op, "c_shape")
+            input_a_shape = (k, m) if trans_a else (m, k)
+            input_b_shape = (n, k) if trans_b else (k, n)
             input_a_suffix = self._param_array_suffix(input_a_shape)
             input_b_suffix = self._param_array_suffix(input_b_shape)
-            output_suffix = self._param_array_suffix((op.m, op.n))
+            output_suffix = self._param_array_suffix((m, n))
             c_suffix = (
-                self._param_array_suffix(op.c_shape)
-                if op.c_shape is not None
+                self._param_array_suffix(c_shape)
+                if c_shape is not None
                 else ""
             )
             param_decls = self._build_param_decls(
@@ -5678,24 +6324,31 @@ class CEmitter:
                     (params["output"], c_type, output_suffix, False),
                 ]
             )
-            alpha_literal = CEmitter._format_literal(op.dtype, op.alpha)
-            beta_literal = CEmitter._format_literal(op.dtype, op.beta)
-            if op.c_shape is None:
+            dtype = self._ctx_dtype(op.output)
+            alpha_literal = CEmitter._format_literal(
+                dtype, self._derived(op, "alpha")
+            )
+            beta_literal = CEmitter._format_literal(
+                dtype, self._derived(op, "beta")
+            )
+            acc_dtype = self._accumulation_dtype(dtype)
+            acc_zero_literal = CEmitter._format_literal(acc_dtype, 0)
+            if c_shape is None:
                 c_rank = 0
                 c_dim0 = 0
                 c_dim1 = 0
-            elif len(op.c_shape) == 0:
+            elif len(c_shape) == 0:
                 c_rank = 0
                 c_dim0 = 0
                 c_dim1 = 0
-            elif len(op.c_shape) == 1:
+            elif len(c_shape) == 1:
                 c_rank = 1
                 c_dim0 = 1
-                c_dim1 = op.c_shape[0]
+                c_dim1 = c_shape[0]
             else:
                 c_rank = 2
-                c_dim0 = op.c_shape[0]
-                c_dim1 = op.c_shape[1]
+                c_dim0 = c_shape[0]
+                c_dim1 = c_shape[1]
             rendered = gemm_template.render(
                 model_name=model.name,
                 op_name=op_name,
@@ -5704,21 +6357,21 @@ class CEmitter:
                 input_c=params["input_c"],
                 output=params["output"],
                 params=param_decls,
-                c_type=c_type,
-                acc_type=c_type,
-                zero_literal=zero_literal,
+                c_type=dtype.c_type,
+                acc_type=acc_dtype.c_type,
+                zero_literal=acc_zero_literal,
                 alpha_literal=alpha_literal,
                 beta_literal=beta_literal,
-                trans_a=int(op.trans_a),
-                trans_b=int(op.trans_b),
-                m=op.m,
-                n=op.n,
-                k=op.k,
+                trans_a=int(trans_a),
+                trans_b=int(trans_b),
+                m=m,
+                n=n,
+                k=k,
                 input_a_suffix=input_a_suffix,
                 input_b_suffix=input_b_suffix,
                 output_suffix=output_suffix,
                 c_suffix=(
-                    c_suffix if op.c_shape is not None else None
+                    c_suffix if c_shape is not None else None
                 ),
                 c_rank=c_rank,
                 c_dim0=c_dim0,
@@ -6034,6 +6687,9 @@ class CEmitter:
                     ("output", op.output),
                 ]
             )
+            acc_dtype = self._accumulation_dtype(op.dtype)
+            acc_type = acc_dtype.c_type
+            acc_zero_literal = CEmitter._format_literal(acc_dtype, 0)
             input_shape = (op.batch, op.in_channels, *op.in_spatial)
             weight_shape = (
                 op.out_channels,
@@ -6077,6 +6733,8 @@ class CEmitter:
                 output=params["output"],
                 params=param_decls,
                 c_type=c_type,
+                acc_type=acc_type,
+                acc_zero_literal=acc_zero_literal,
                 zero_literal=zero_literal,
                 input_suffix=input_suffix,
                 weight_suffix=weight_suffix,
@@ -6100,6 +6758,129 @@ class CEmitter:
                 in_indices=in_indices,
             ).rstrip()
             return with_node_comment(rendered)
+        if isinstance(op, ConvIntegerOp):
+            params = self._shared_param_map(
+                [
+                    ("input0", op.input0),
+                    ("weights", op.weights),
+                    ("x_zero_point", op.x_zero_point),
+                    ("w_zero_point", op.w_zero_point),
+                    ("output", op.output),
+                ]
+            )
+            acc_dtype = op.dtype
+            acc_type = acc_dtype.c_type
+            acc_zero_literal = CEmitter._format_literal(acc_dtype, 0)
+            input_shape = (op.batch, op.in_channels, *op.in_spatial)
+            weight_shape = (
+                op.out_channels,
+                op.in_channels // op.group,
+                *op.kernel_shape,
+            )
+            output_shape = (op.batch, op.out_channels, *op.out_spatial)
+            out_indices = tuple(f"od{dim}" for dim in range(op.spatial_rank))
+            kernel_indices = tuple(
+                f"kd{dim}" for dim in range(op.spatial_rank)
+            )
+            in_indices = tuple(f"id{dim}" for dim in range(op.spatial_rank))
+            pad_begin = op.pads[: op.spatial_rank]
+            group_in_channels = op.in_channels // op.group
+            group_out_channels = op.out_channels // op.group
+            input_suffix = self._param_array_suffix(input_shape)
+            weight_suffix = self._param_array_suffix(weight_shape)
+            output_suffix = self._param_array_suffix(output_shape)
+            x_zero_suffix = (
+                self._param_array_suffix(op.x_zero_point_shape)
+                if op.x_zero_point_shape is not None
+                else ""
+            )
+            w_zero_suffix = (
+                self._param_array_suffix(op.w_zero_point_shape)
+                if op.w_zero_point_shape is not None
+                else ""
+            )
+            param_decls = self._build_param_decls(
+                [
+                    (
+                        params["input0"],
+                        op.input_dtype.c_type,
+                        input_suffix,
+                        True,
+                    ),
+                    (
+                        params["weights"],
+                        op.weight_dtype.c_type,
+                        weight_suffix,
+                        True,
+                    ),
+                    (
+                        params["x_zero_point"],
+                        op.input_dtype.c_type,
+                        x_zero_suffix,
+                        True,
+                    )
+                    if params["x_zero_point"]
+                    else (None, "", "", True),
+                    (
+                        params["w_zero_point"],
+                        op.weight_dtype.c_type,
+                        w_zero_suffix,
+                        True,
+                    )
+                    if params["w_zero_point"]
+                    else (None, "", "", True),
+                    (params["output"], c_type, output_suffix, False),
+                ]
+            )
+            x_zero_expr = (
+                f"{params['x_zero_point']}[0]"
+                if params["x_zero_point"]
+                else "0"
+            )
+            if params["w_zero_point"]:
+                if op.w_zero_point_per_channel:
+                    w_zero_expr = f"{params['w_zero_point']}[oc_global]"
+                else:
+                    w_zero_expr = f"{params['w_zero_point']}[0]"
+            else:
+                w_zero_expr = "0"
+            rendered = conv_integer_template.render(
+                model_name=model.name,
+                op_name=op_name,
+                input0=params["input0"],
+                weights=params["weights"],
+                x_zero_point=params["x_zero_point"],
+                w_zero_point=params["w_zero_point"],
+                output=params["output"],
+                params=param_decls,
+                c_type=c_type,
+                acc_type=acc_type,
+                acc_zero_literal=acc_zero_literal,
+                input_suffix=input_suffix,
+                weight_suffix=weight_suffix,
+                x_zero_suffix=x_zero_suffix,
+                w_zero_suffix=w_zero_suffix,
+                output_suffix=output_suffix,
+                batch=op.batch,
+                in_channels=op.in_channels,
+                out_channels=op.out_channels,
+                spatial_rank=op.spatial_rank,
+                in_spatial=op.in_spatial,
+                out_spatial=op.out_spatial,
+                kernel_shape=op.kernel_shape,
+                strides=op.strides,
+                pads_begin=pad_begin,
+                dilations=op.dilations,
+                group=op.group,
+                group_in_channels=group_in_channels,
+                group_out_channels=group_out_channels,
+                out_indices=out_indices,
+                kernel_indices=kernel_indices,
+                in_indices=in_indices,
+                x_zero_expr=x_zero_expr,
+                w_zero_expr=w_zero_expr,
+            ).rstrip()
+            return with_node_comment(rendered)
         if isinstance(op, ConvTransposeOp):
             params = self._shared_param_map(
                 [
@@ -6179,8 +6960,27 @@ class CEmitter:
             params = self._shared_param_map(
                 [("input0", op.input0), ("output", op.output)]
             )
-            input_shape = (op.batch, op.channels, op.in_h, op.in_w)
-            output_shape = (op.batch, op.channels, op.out_h, op.out_w)
+            if op.spatial_rank == 3:
+                input_shape = (
+                    op.batch,
+                    op.channels,
+                    op.in_d,
+                    op.in_h,
+                    op.in_w,
+                )
+                output_shape = (
+                    op.batch,
+                    op.channels,
+                    op.out_d,
+                    op.out_h,
+                    op.out_w,
+                )
+            elif op.spatial_rank == 1:
+                input_shape = (op.batch, op.channels, op.in_w)
+                output_shape = (op.batch, op.channels, op.out_w)
+            else:
+                input_shape = (op.batch, op.channels, op.in_h, op.in_w)
+                output_shape = (op.batch, op.channels, op.out_h, op.out_w)
             input_suffix = self._param_array_suffix(input_shape)
             output_suffix = self._param_array_suffix(output_shape)
             param_decls = self._build_param_decls(
@@ -6201,16 +7001,26 @@ class CEmitter:
                 output_suffix=output_suffix,
                 batch=op.batch,
                 channels=op.channels,
+                spatial_rank=op.spatial_rank,
+                in_d=op.in_d,
                 in_h=op.in_h,
                 in_w=op.in_w,
+                out_d=op.out_d,
                 out_h=op.out_h,
                 out_w=op.out_w,
+                kernel_d=op.kernel_d,
                 kernel_h=op.kernel_h,
                 kernel_w=op.kernel_w,
+                dilation_d=op.dilation_d,
+                dilation_h=op.dilation_h,
+                dilation_w=op.dilation_w,
+                stride_d=op.stride_d,
                 stride_h=op.stride_h,
                 stride_w=op.stride_w,
+                pad_front=op.pad_front,
                 pad_top=op.pad_top,
                 pad_left=op.pad_left,
+                pad_back=op.pad_back,
                 pad_bottom=op.pad_bottom,
                 pad_right=op.pad_right,
                 count_include_pad=int(op.count_include_pad),
@@ -6247,6 +7057,8 @@ class CEmitter:
                 out_w=op.out_w,
                 kernel_h=op.kernel_h,
                 kernel_w=op.kernel_w,
+                dilation_h=op.dilation_h,
+                dilation_w=op.dilation_w,
                 stride_h=op.stride_h,
                 stride_w=op.stride_w,
                 pad_top=op.pad_top,
@@ -6431,11 +7243,7 @@ class CEmitter:
             ).rstrip()
             return with_node_comment(rendered)
         if isinstance(op, LayerNormalizationOp):
-            acc_dtype = (
-                ScalarType.F32
-                if op.dtype in {ScalarType.F16, ScalarType.F32}
-                else op.dtype
-            )
+            acc_dtype = self._accumulation_dtype(op.dtype)
             acc_type = acc_dtype.c_type
             acc_zero_literal = CEmitter._format_literal(acc_dtype, 0)
             acc_one_literal = CEmitter._format_literal(acc_dtype, 1)
@@ -6443,7 +7251,7 @@ class CEmitter:
                 op.epsilon, acc_dtype
             )
             acc_sqrt_fn = CEmitter._math_fn(acc_dtype, "sqrtf", "sqrt")
-            use_kahan = op.dtype in {ScalarType.F16, ScalarType.F32}
+            use_kahan = False
             params = self._shared_param_map(
                 [
                     ("input0", op.input0),
@@ -6678,7 +7486,7 @@ class CEmitter:
                 pow_fn=CEmitter._math_fn(op.dtype, "powf", "pow"),
             ).rstrip()
             return with_node_comment(rendered)
-        if isinstance(op, LstmOp):
+        if isinstance(op, GruOp):
             params = self._shared_param_map(
                 [
                     ("input_x", op.input_x),
@@ -6687,11 +7495,8 @@ class CEmitter:
                     ("input_b", op.input_b),
                     ("input_sequence_lens", op.input_sequence_lens),
                     ("input_initial_h", op.input_initial_h),
-                    ("input_initial_c", op.input_initial_c),
-                    ("input_p", op.input_p),
                     ("output_y", op.output_y),
                     ("output_y_h", op.output_y_h),
-                    ("output_y_c", op.output_y_c),
                 ]
             )
             input_x_shape = (
@@ -6699,14 +7504,16 @@ class CEmitter:
                 if op.layout == 0
                 else (op.batch_size, op.seq_length, op.input_size)
             )
-            w_shape = (op.num_directions, 4 * op.hidden_size, op.input_size)
-            r_shape = (op.num_directions, 4 * op.hidden_size, op.hidden_size)
+            w_shape = (op.num_directions, 3 * op.hidden_size, op.input_size)
+            r_shape = (op.num_directions, 3 * op.hidden_size, op.hidden_size)
             b_shape = (
-                (op.num_directions, 8 * op.hidden_size)
+                (op.num_directions, 6 * op.hidden_size)
                 if op.input_b is not None
                 else None
             )
-            seq_shape = (op.batch_size,) if op.input_sequence_lens is not None else None
+            seq_shape = (
+                (op.batch_size,) if op.input_sequence_lens is not None else None
+            )
             state_shape = (
                 (op.num_directions, op.batch_size, op.hidden_size)
                 if op.layout == 0
@@ -6717,16 +7524,6 @@ class CEmitter:
                 if op.input_initial_h is not None or op.output_y_h is not None
                 else None
             )
-            c_shape = (
-                state_shape
-                if op.input_initial_c is not None or op.output_y_c is not None
-                else None
-            )
-            p_shape = (
-                (op.num_directions, 3 * op.hidden_size)
-                if op.input_p is not None
-                else None
-            )
             y_shape = (
                 (op.seq_length, op.num_directions, op.batch_size, op.hidden_size)
                 if op.layout == 0
@@ -6776,22 +7573,6 @@ class CEmitter:
                     )
                     if params["input_initial_h"]
                     else (None, "", "", True),
-                    (
-                        params["input_initial_c"],
-                        c_type,
-                        self._param_array_suffix(c_shape),
-                        True,
-                    )
-                    if params["input_initial_c"]
-                    else (None, "", "", True),
-                    (
-                        params["input_p"],
-                        c_type,
-                        self._param_array_suffix(p_shape),
-                        True,
-                    )
-                    if params["input_p"]
-                    else (None, "", "", True),
                     (
                         params["output_y"],
                         c_type,
@@ -6808,22 +7589,14 @@ class CEmitter:
                     )
                     if params["output_y_h"]
                     else (None, "", "", False),
-                    (
-                        params["output_y_c"],
-                        c_type,
-                        self._param_array_suffix(c_shape),
-                        False,
-                    )
-                    if params["output_y_c"]
-                    else (None, "", "", False),
                 ]
             )
             if scalar_registry is None:
                 raise CodegenError(
-                    "Scalar function registry is required for LSTM codegen."
+                    "Scalar function registry is required for GRU codegen."
                 )
             activation_functions = tuple(
-                self._lstm_activation_function_name(
+                self._rnn_activation_function_name(
                     kind,
                     alpha,
                     beta,
@@ -6836,7 +7609,7 @@ class CEmitter:
                     op.activation_betas,
                 )
             )
-            rendered = lstm_template.render(
+            rendered = gru_template.render(
                 model_name=model.name,
                 op_name=op_name,
                 input_x=params["input_x"],
@@ -6845,11 +7618,8 @@ class CEmitter:
                 input_b=params["input_b"],
                 input_sequence_lens=params["input_sequence_lens"],
                 input_initial_h=params["input_initial_h"],
-                input_initial_c=params["input_initial_c"],
-                input_p=params["input_p"],
                 output_y=params["output_y"],
                 output_y_h=params["output_y_h"],
-                output_y_c=params["output_y_c"],
                 params=param_decls,
                 c_type=c_type,
                 seq_c_type=(op.sequence_lens_dtype or ScalarType.I64).c_type,
@@ -6868,38 +7638,232 @@ class CEmitter:
                 num_directions=op.num_directions,
                 layout=op.layout,
                 direction=op.direction,
-                input_forget=op.input_forget,
+                linear_before_reset=op.linear_before_reset,
                 activation_functions=activation_functions,
             ).rstrip()
             return with_node_comment(rendered)
-        if isinstance(op, AdagradOp):
+        if isinstance(op, LstmOp):
             params = self._shared_param_map(
                 [
-                    ("rate", op.rate),
-                    ("timestep", op.timestep),
-                    *(
-                        (f"input{idx}", name)
-                        for idx, name in enumerate(op.inputs)
-                    ),
-                    *(
-                        (f"grad{idx}", name)
-                        for idx, name in enumerate(op.gradients)
-                    ),
-                    *(
-                        (f"acc{idx}", name)
-                        for idx, name in enumerate(op.accumulators)
-                    ),
-                    *(
-                        (f"output{idx}", name)
-                        for idx, name in enumerate(op.outputs)
-                    ),
-                    *(
-                        (f"acc_output{idx}", name)
-                        for idx, name in enumerate(op.accumulator_outputs)
-                    ),
-                ]
-            )
-            rate_suffix = self._param_array_suffix(
+                    ("input_x", op.input_x),
+                    ("input_w", op.input_w),
+                    ("input_r", op.input_r),
+                    ("input_b", op.input_b),
+                    ("input_sequence_lens", op.input_sequence_lens),
+                    ("input_initial_h", op.input_initial_h),
+                    ("input_initial_c", op.input_initial_c),
+                    ("input_p", op.input_p),
+                    ("output_y", op.output_y),
+                    ("output_y_h", op.output_y_h),
+                    ("output_y_c", op.output_y_c),
+                ]
+            )
+            input_x_shape = (
+                (op.seq_length, op.batch_size, op.input_size)
+                if op.layout == 0
+                else (op.batch_size, op.seq_length, op.input_size)
+            )
+            w_shape = (op.num_directions, 4 * op.hidden_size, op.input_size)
+            r_shape = (op.num_directions, 4 * op.hidden_size, op.hidden_size)
+            b_shape = (
+                (op.num_directions, 8 * op.hidden_size)
+                if op.input_b is not None
+                else None
+            )
+            seq_shape = (op.batch_size,) if op.input_sequence_lens is not None else None
+            state_shape = (
+                (op.num_directions, op.batch_size, op.hidden_size)
+                if op.layout == 0
+                else (op.batch_size, op.num_directions, op.hidden_size)
+            )
+            h_shape = (
+                state_shape
+                if op.input_initial_h is not None or op.output_y_h is not None
+                else None
+            )
+            c_shape = (
+                state_shape
+                if op.input_initial_c is not None or op.output_y_c is not None
+                else None
+            )
+            p_shape = (
+                (op.num_directions, 3 * op.hidden_size)
+                if op.input_p is not None
+                else None
+            )
+            y_shape = (
+                (op.seq_length, op.num_directions, op.batch_size, op.hidden_size)
+                if op.layout == 0
+                else (op.batch_size, op.seq_length, op.num_directions, op.hidden_size)
+            )
+            param_decls = self._build_param_decls(
+                [
+                    (
+                        params["input_x"],
+                        c_type,
+                        self._param_array_suffix(input_x_shape),
+                        True,
+                    ),
+                    (
+                        params["input_w"],
+                        c_type,
+                        self._param_array_suffix(w_shape),
+                        True,
+                    ),
+                    (
+                        params["input_r"],
+                        c_type,
+                        self._param_array_suffix(r_shape),
+                        True,
+                    ),
+                    (
+                        params["input_b"],
+                        c_type,
+                        self._param_array_suffix(b_shape),
+                        True,
+                    )
+                    if params["input_b"]
+                    else (None, "", "", True),
+                    (
+                        params["input_sequence_lens"],
+                        (op.sequence_lens_dtype or ScalarType.I64).c_type,
+                        self._param_array_suffix(seq_shape),
+                        True,
+                    )
+                    if params["input_sequence_lens"]
+                    else (None, "", "", True),
+                    (
+                        params["input_initial_h"],
+                        c_type,
+                        self._param_array_suffix(h_shape),
+                        True,
+                    )
+                    if params["input_initial_h"]
+                    else (None, "", "", True),
+                    (
+                        params["input_initial_c"],
+                        c_type,
+                        self._param_array_suffix(c_shape),
+                        True,
+                    )
+                    if params["input_initial_c"]
+                    else (None, "", "", True),
+                    (
+                        params["input_p"],
+                        c_type,
+                        self._param_array_suffix(p_shape),
+                        True,
+                    )
+                    if params["input_p"]
+                    else (None, "", "", True),
+                    (
+                        params["output_y"],
+                        c_type,
+                        self._param_array_suffix(y_shape),
+                        False,
+                    )
+                    if params["output_y"]
+                    else (None, "", "", False),
+                    (
+                        params["output_y_h"],
+                        c_type,
+                        self._param_array_suffix(h_shape),
+                        False,
+                    )
+                    if params["output_y_h"]
+                    else (None, "", "", False),
+                    (
+                        params["output_y_c"],
+                        c_type,
+                        self._param_array_suffix(c_shape),
+                        False,
+                    )
+                    if params["output_y_c"]
+                    else (None, "", "", False),
+                ]
+            )
+            if scalar_registry is None:
+                raise CodegenError(
+                    "Scalar function registry is required for LSTM codegen."
+                )
+            activation_functions = tuple(
+                self._rnn_activation_function_name(
+                    kind,
+                    alpha,
+                    beta,
+                    op.dtype,
+                    scalar_registry,
+                )
+                for kind, alpha, beta in zip(
+                    op.activation_kinds,
+                    op.activation_alphas,
+                    op.activation_betas,
+                )
+            )
+            rendered = lstm_template.render(
+                model_name=model.name,
+                op_name=op_name,
+                input_x=params["input_x"],
+                input_w=params["input_w"],
+                input_r=params["input_r"],
+                input_b=params["input_b"],
+                input_sequence_lens=params["input_sequence_lens"],
+                input_initial_h=params["input_initial_h"],
+                input_initial_c=params["input_initial_c"],
+                input_p=params["input_p"],
+                output_y=params["output_y"],
+                output_y_h=params["output_y_h"],
+                output_y_c=params["output_y_c"],
+                params=param_decls,
+                c_type=c_type,
+                seq_c_type=(op.sequence_lens_dtype or ScalarType.I64).c_type,
+                zero_literal=zero_literal,
+                one_literal=CEmitter._format_literal(op.dtype, 1),
+                clip_literal=(
+                    CEmitter._format_floating(op.clip, op.dtype)
+                    if op.clip is not None
+                    else CEmitter._format_literal(op.dtype, 0)
+                ),
+                use_clip=int(op.clip is not None and op.clip > 0),
+                seq_length=op.seq_length,
+                batch_size=op.batch_size,
+                input_size=op.input_size,
+                hidden_size=op.hidden_size,
+                num_directions=op.num_directions,
+                layout=op.layout,
+                direction=op.direction,
+                input_forget=op.input_forget,
+                activation_functions=activation_functions,
+            ).rstrip()
+            return with_node_comment(rendered)
+        if isinstance(op, AdagradOp):
+            params = self._shared_param_map(
+                [
+                    ("rate", op.rate),
+                    ("timestep", op.timestep),
+                    *(
+                        (f"input{idx}", name)
+                        for idx, name in enumerate(op.inputs)
+                    ),
+                    *(
+                        (f"grad{idx}", name)
+                        for idx, name in enumerate(op.gradients)
+                    ),
+                    *(
+                        (f"acc{idx}", name)
+                        for idx, name in enumerate(op.accumulators)
+                    ),
+                    *(
+                        (f"output{idx}", name)
+                        for idx, name in enumerate(op.outputs)
+                    ),
+                    *(
+                        (f"acc_output{idx}", name)
+                        for idx, name in enumerate(op.accumulator_outputs)
+                    ),
+                ]
+            )
+            rate_suffix = self._param_array_suffix(
                 op.rate_shape, _dim_names_for(op.rate)
             )
             timestep_suffix = self._param_array_suffix(
@@ -7112,11 +8076,7 @@ class CEmitter:
             ).rstrip()
             return with_node_comment(rendered)
         if isinstance(op, NegativeLogLikelihoodLossOp):
-            acc_dtype = (
-                ScalarType.F64
-                if op.dtype in {ScalarType.F16, ScalarType.F32}
-                else op.dtype
-            )
+            acc_dtype = self._accumulation_dtype(op.dtype)
             acc_type = acc_dtype.c_type
             acc_zero_literal = CEmitter._format_literal(acc_dtype, 0)
             acc_one_literal = CEmitter._format_literal(acc_dtype, 1)
@@ -7173,11 +8133,7 @@ class CEmitter:
             ).rstrip()
             return with_node_comment(rendered)
         if isinstance(op, SoftmaxCrossEntropyLossOp):
-            acc_dtype = (
-                ScalarType.F64
-                if op.dtype in {ScalarType.F16, ScalarType.F32}
-                else op.dtype
-            )
+            acc_dtype = self._accumulation_dtype(op.dtype)
             if scalar_registry is None:
                 raise CodegenError(
                     "Scalar function registry is required for SoftmaxCrossEntropyLoss."
@@ -7873,7 +8829,58 @@ class CEmitter:
                 loop_vars=loop_vars,
             ).rstrip()
             return with_node_comment(rendered)
+        if isinstance(op, BernoulliOp):
+            output_dim_names = _dim_names_for(op.output)
+            shape = CEmitter._shape_dim_exprs(op.output_shape, output_dim_names)
+            loop_vars = CEmitter._loop_vars(op.output_shape)
+            output_suffix = self._param_array_suffix(
+                op.output_shape, output_dim_names
+            )
+            input_suffix = self._param_array_suffix(
+                op.input_shape, _dim_names_for(op.input0)
+            )
+            params = self._shared_param_map(
+                [("input0", op.input0), ("output", op.output)]
+            )
+            output_dtype = op.dtype
+            param_decls = self._build_param_decls(
+                [
+                    (params["input0"], op.input_dtype.c_type, input_suffix, True),
+                    (params["output"], output_dtype.c_type, output_suffix, False),
+                ]
+            )
+            one_literal = (
+                "true"
+                if output_dtype == ScalarType.BOOL
+                else f"({output_dtype.c_type})1"
+            )
+            zero_literal = (
+                "false"
+                if output_dtype == ScalarType.BOOL
+                else output_dtype.zero_literal
+            )
+            rendered = bernoulli_template.render(
+                model_name=model.name,
+                op_name=op_name,
+                input0=params["input0"],
+                output=params["output"],
+                input_index_expr="".join(
+                    f"[{var}]" for var in loop_vars
+                ),
+                output_index_expr="".join(
+                    f"[{var}]" for var in loop_vars
+                ),
+                shape=shape,
+                loop_vars=loop_vars,
+                seed=op.seed if op.seed is not None else 0,
+                one_literal=one_literal,
+                zero_literal=zero_literal,
+                dim_args=dim_args,
+                params=param_decls,
+            ).rstrip()
+            return with_node_comment(rendered)
         if isinstance(op, EyeLikeOp):
+            input_c_type = op.input_dtype.c_type
             params = self._shared_param_map(
                 [("input0", op.input0), ("output", op.output)]
             )
@@ -7887,7 +8894,7 @@ class CEmitter:
             batch_size = CEmitter._element_count(batch_dims or (1,))
             param_decls = self._build_param_decls(
                 [
-                    (params["input0"], c_type, input_suffix, True),
+                    (params["input0"], input_c_type, input_suffix, True),
                     (params["output"], c_type, output_suffix, False),
                 ]
             )
@@ -8499,8 +9506,6 @@ class CEmitter:
             update_expr = None
             init_literal = None
             final_expr = "acc"
-            use_kahan = False
-            kahan_value_expr = None
             fabs_fn = CEmitter._math_fn(output_dtype, "fabsf", "fabs")
             exp_fn = CEmitter._math_fn(output_dtype, "expf", "exp")
             log_fn = CEmitter._math_fn(output_dtype, "logf", "log")
@@ -8546,24 +9551,6 @@ class CEmitter:
                 raise CodegenError(
                     f"Unsupported reduce kind {op.reduce_kind}"
                 )
-            if output_dtype in {ScalarType.F16, ScalarType.F32} and op.reduce_kind in {
-                "sum",
-                "mean",
-                "logsum",
-                "logsumexp",
-                "l1",
-                "l2",
-                "sumsquare",
-            }:
-                use_kahan = True
-                if op.reduce_kind == "logsumexp":
-                    kahan_value_expr = f"{exp_fn}({value_expr})"
-                elif op.reduce_kind == "l1":
-                    kahan_value_expr = f"{fabs_fn}({value_expr})"
-                elif op.reduce_kind in {"l2", "sumsquare"}:
-                    kahan_value_expr = f"{value_expr} * {value_expr}"
-                else:
-                    kahan_value_expr = value_expr
             input_suffix = self._param_array_suffix(input_shape)
             output_suffix = self._param_array_suffix(output_shape_raw)
             param_decls = self._build_param_decls(
@@ -8590,8 +9577,8 @@ class CEmitter:
                 zero_literal=zero_literal,
                 update_expr=update_expr,
                 final_expr=final_expr,
-                use_kahan=use_kahan,
-                kahan_value_expr=kahan_value_expr,
+                use_kahan=False,
+                kahan_value_expr=None,
             ).rstrip()
             return with_node_comment(rendered)
         if isinstance(op, ArgReduceOp):
@@ -8736,9 +9723,9 @@ class CEmitter:
                 output_values=params["output_values"],
                 output_indices=params["output_indices"],
                 params=param_decls,
-                input_c_type=op.input_dtype.c_type,
-                output_values_c_type=op.output_values_dtype.c_type,
-                output_indices_c_type=op.output_indices_dtype.c_type,
+                input_c_type=input_dtype.c_type,
+                output_values_c_type=output_values_dtype.c_type,
+                output_indices_c_type=output_indices_dtype.c_type,
                 input_suffix=input_suffix,
                 output_suffix=output_suffix,
                 output_shape=output_shape,
@@ -8746,7 +9733,7 @@ class CEmitter:
                 outer_loop_vars=outer_loop_vars,
                 reduce_var=reduce_var,
                 k_var=k_var,
-                axis_dim=op.input_shape[op.axis],
+                axis_dim=input_shape[op.axis],
                 k=op.k,
                 input_index_expr=input_index_expr,
                 output_index_expr=output_index_expr,
@@ -8762,11 +9749,15 @@ class CEmitter:
                     ("output", op.output),
                 ]
             )
-            output_shape = CEmitter._codegen_shape(op.output_shape)
+            input_shape_raw = self._ctx_shape(op.input0)
+            output_shape_raw = self._ctx_shape(op.output)
+            output_shape = CEmitter._codegen_shape(output_shape_raw)
             output_loop_vars = CEmitter._loop_vars(output_shape)
-            input_shape = CEmitter._codegen_shape(op.input_shape)
+            input_shape = CEmitter._codegen_shape(input_shape_raw)
             input_loop_vars = CEmitter._loop_vars(input_shape)
-            axes_shape = op.axes_input_shape or ()
+            axes_shape = (
+                self._ctx_shape(op.axes_input) if op.axes_input is not None else ()
+            )
             axes_count = 1
             for dim in axes_shape:
                 if dim == 0:
@@ -8774,8 +9765,8 @@ class CEmitter:
                     break
                 axes_count *= dim
             axes_c_type = (
-                op.axes_input_dtype.c_type
-                if op.axes_input_dtype
+                self._ctx_dtype(op.axes_input).c_type
+                if op.axes_input is not None
                 else ScalarType.I64.c_type
             )
             input_indices = "".join(f"[{var}]" for var in input_loop_vars)
@@ -8789,10 +9780,11 @@ class CEmitter:
             update_expr = None
             init_literal = None
             post_expr = None
-            fabs_fn = CEmitter._math_fn(op.dtype, "fabsf", "fabs")
-            exp_fn = CEmitter._math_fn(op.dtype, "expf", "exp")
-            log_fn = CEmitter._math_fn(op.dtype, "logf", "log")
-            sqrt_fn = CEmitter._math_fn(op.dtype, "sqrtf", "sqrt")
+            reduce_dtype = self._ctx_dtype(op.output)
+            fabs_fn = CEmitter._math_fn(reduce_dtype, "fabsf", "fabs")
+            exp_fn = CEmitter._math_fn(reduce_dtype, "expf", "exp")
+            log_fn = CEmitter._math_fn(reduce_dtype, "logf", "log")
+            sqrt_fn = CEmitter._math_fn(reduce_dtype, "sqrtf", "sqrt")
             if op.reduce_kind == "sum":
                 init_literal = zero_literal
                 update_expr = f"*out_ptr += {value_expr};"
@@ -8807,7 +9799,7 @@ class CEmitter:
                 init_literal = max_literal
                 update_expr = f"if ({value_expr} < *out_ptr) *out_ptr = {value_expr};"
             elif op.reduce_kind == "prod":
-                init_literal = CEmitter._format_literal(op.dtype, 1)
+                init_literal = CEmitter._format_literal(reduce_dtype, 1)
                 update_expr = f"*out_ptr *= {value_expr};"
             elif op.reduce_kind == "l1":
                 init_literal = zero_literal
@@ -8831,11 +9823,11 @@ class CEmitter:
                 raise CodegenError(
                     f"Unsupported reduce kind {op.reduce_kind}"
                 )
-            input_suffix = self._param_array_suffix(op.input_shape)
-            output_suffix = self._param_array_suffix(op.output_shape)
+            input_suffix = self._param_array_suffix(input_shape_raw)
+            output_suffix = self._param_array_suffix(output_shape_raw)
             axes_suffix = (
-                self._param_array_suffix(op.axes_input_shape)
-                if op.axes_input_shape
+                self._param_array_suffix(axes_shape)
+                if axes_shape
                 else ""
             )
             params = self._build_param_decls(
@@ -8963,6 +9955,44 @@ class CEmitter:
                 value=CEmitter._format_literal(op.dtype, op.value),
             ).rstrip()
             return with_node_comment(rendered)
+        if isinstance(op, OptionalHasElementOp):
+            params = self._shared_param_map(
+                [("input0", op.input0), ("output", op.output)]
+            )
+            input_shape = self._ctx_shape(op.input0)
+            output_shape = self._ctx_shape(op.output)
+            input_dim_names = _dim_names_for(op.input0)
+            output_dim_names = _dim_names_for(op.output)
+            input_suffix = self._param_array_suffix(input_shape, input_dim_names)
+            output_suffix = self._param_array_suffix(output_shape, output_dim_names)
+            input_dtype = self._ctx_dtype(op.input0)
+            output_dtype = self._ctx_dtype(op.output)
+            optional_flags = self._optional_input_flag_map(model)
+            input_flag = optional_flags.get(op.input0)
+            if input_flag is None:
+                raise CodegenError(
+                    "OptionalHasElement expects an optional input flag."
+                )
+            param_decls = self._build_param_decls(
+                [
+                    (params["input0"], input_dtype.c_type, input_suffix, True),
+                    (input_flag, "_Bool", "", True),
+                    (params["output"], output_dtype.c_type, output_suffix, False),
+                ]
+            )
+            rendered = optional_has_element_template.render(
+                model_name=model.name,
+                op_name=op_name,
+                input0=params["input0"],
+                input_present=input_flag,
+                output=params["output"],
+                params=param_decls,
+                input_c_type=input_dtype.c_type,
+                output_c_type=output_dtype.c_type,
+                input_suffix=input_suffix,
+                output_suffix=output_suffix,
+            ).rstrip()
+            return with_node_comment(rendered)
         if isinstance(op, NonZeroOp):
             params = self._shared_param_map(
                 [("input0", op.input0), ("output", op.output)]
@@ -9247,6 +10277,38 @@ class CEmitter:
                 length=op.length,
             ).rstrip()
             return with_node_comment(rendered)
+        if isinstance(op, HammingWindowOp):
+            params = self._shared_param_map(
+                [
+                    ("size", op.size),
+                    ("output", op.output),
+                ]
+            )
+            scalar_suffix = self._param_array_suffix(())
+            output_suffix = self._param_array_suffix(op.output_shape)
+            param_decls = self._build_param_decls(
+                [
+                    (
+                        params["size"],
+                        op.input_dtype.c_type,
+                        scalar_suffix,
+                        True,
+                    ),
+                    (params["output"], c_type, output_suffix, False),
+                ]
+            )
+            rendered = hamming_window_template.render(
+                model_name=model.name,
+                op_name=op_name,
+                size=params["size"],
+                output=params["output"],
+                params=param_decls,
+                c_type=c_type,
+                output_suffix=output_suffix,
+                length=op.output_shape[0],
+                periodic_literal="1" if op.periodic else "0",
+            ).rstrip()
+            return with_node_comment(rendered)
         if isinstance(op, OneHotOp):
             params = self._shared_param_map(
                 [
@@ -9315,6 +10377,85 @@ class CEmitter:
                 c_type=c_type,
             ).rstrip()
             return with_node_comment(rendered)
+        if isinstance(op, TfIdfVectorizerOp):
+            params = self._shared_param_map(
+                [("input0", op.input0), ("output", op.output)]
+            )
+            input_dim_names = _dim_names_for(op.input0)
+            output_dim_names = _dim_names_for(op.output)
+            input_suffix = self._param_array_suffix(
+                op.input_shape, input_dim_names
+            )
+            output_suffix = self._param_array_suffix(
+                op.output_shape, output_dim_names
+            )
+            param_decls = self._build_param_decls(
+                [
+                    (
+                        params["input0"],
+                        op.input_dtype.c_type,
+                        input_suffix,
+                        True,
+                    ),
+                    (
+                        params["output"],
+                        op.output_dtype.c_type,
+                        output_suffix,
+                        False,
+                    ),
+                ]
+            )
+            output_dim = op.output_shape[-1] if op.output_shape else 0
+            mode_id = {"TF": 0, "IDF": 1, "TFIDF": 2}[op.mode]
+            pool_values = [
+                CEmitter._format_literal(ScalarType.I64, value)
+                for value in op.pool_int64s
+            ]
+            ngram_counts_values = [
+                CEmitter._format_literal(ScalarType.I64, value)
+                for value in op.ngram_counts
+            ]
+            ngram_indexes_values = [
+                CEmitter._format_literal(ScalarType.I64, value)
+                for value in op.ngram_indexes
+            ]
+            weights_values = (
+                [
+                    CEmitter._format_literal(op.output_dtype, value)
+                    for value in op.weights
+                ]
+                if op.weights is not None
+                else None
+            )
+            rendered = tfidf_vectorizer_template.render(
+                model_name=model.name,
+                op_name=op_name,
+                input0=params["input0"],
+                output=params["output"],
+                params=param_decls,
+                input_suffix=input_suffix,
+                output_suffix=output_suffix,
+                input_shape=op.input_shape,
+                output_shape=op.output_shape,
+                input_rank=len(op.input_shape),
+                output_dim=output_dim,
+                min_gram_length=op.min_gram_length,
+                max_gram_length=op.max_gram_length,
+                max_skip_count=op.max_skip_count,
+                mode_id=mode_id,
+                ngram_counts_len=len(op.ngram_counts),
+                pool_size=len(op.pool_int64s),
+                ngram_index_len=len(op.ngram_indexes),
+                pool_values=pool_values,
+                ngram_counts_values=ngram_counts_values,
+                ngram_indexes_values=ngram_indexes_values,
+                weights_values=weights_values,
+                zero_literal=op.output_dtype.zero_literal,
+                one_literal=CEmitter._format_literal(op.output_dtype, 1.0),
+                c_type=op.output_dtype.c_type,
+                input_c_type=op.input_dtype.c_type,
+            ).rstrip()
+            return with_node_comment(rendered)
         if isinstance(op, SplitOp):
             output_params = [
                 (f"output_{index}", name)
@@ -9429,30 +10570,302 @@ class CEmitter:
             scale_suffix = self._param_array_suffix(
                 scale_shape, _dim_names_for(op.scale)
             )
-            zero_point_suffix = self._param_array_suffix(
-                scale_shape, _dim_names_for(op.zero_point or "")
+            zero_point_suffix = self._param_array_suffix(
+                scale_shape, _dim_names_for(op.zero_point or "")
+            )
+            param_decls = self._build_param_decls(
+                [
+                    (params["input0"], op.input_dtype.c_type, input_suffix, True),
+                    (params["scale"], op.scale_dtype.c_type, scale_suffix, True),
+                    (
+                        params["zero_point"],
+                        op.dtype.c_type,
+                        zero_point_suffix,
+                        True,
+                    )
+                    if params["zero_point"]
+                    else (None, "", "", True),
+                    (params["output"], op.dtype.c_type, input_suffix, False),
+                ]
+            )
+            compute_type = "double" if op.input_dtype == ScalarType.F64 else "float"
+            compute_dtype = (
+                ScalarType.F64
+                if compute_type == "double"
+                else ScalarType.F32
+            )
+            max_fn = self._scalar_function_name(
+                ScalarFunction.MAXIMUM, compute_dtype, scalar_registry
+            )
+            min_fn = self._scalar_function_name(
+                ScalarFunction.MINIMUM, compute_dtype, scalar_registry
+            )
+            if max_fn is None or min_fn is None:
+                raise CodegenError(
+                    "Failed to resolve scalar min/max functions for QuantizeLinear."
+                )
+            round_fn = CEmitter._math_fn(
+                op.input_dtype, "nearbyintf", "nearbyint"
+            )
+            scale_index = "0" if op.axis is None else loop_vars[op.axis]
+            input_expr = f"{params['input0']}" + "".join(
+                f"[{var}]" for var in loop_vars
+            )
+            output_expr = f"{params['output']}" + "".join(
+                f"[{var}]" for var in loop_vars
+            )
+            scale_expr = f"{params['scale']}[{scale_index}]"
+            if params["zero_point"]:
+                zero_expr = f"{params['zero_point']}[{scale_index}]"
+            else:
+                zero_expr = "0"
+            rendered = quantize_linear_template.render(
+                model_name=model.name,
+                op_name=op_name,
+                input0=params["input0"],
+                scale=params["scale"],
+                zero_point=params["zero_point"],
+                output=params["output"],
+                params=param_decls,
+                compute_type=compute_type,
+                input_c_type=op.input_dtype.c_type,
+                output_c_type=op.dtype.c_type,
+                shape=shape,
+                loop_vars=loop_vars,
+                input_expr=input_expr,
+                scale_expr=scale_expr,
+                zero_expr=zero_expr,
+                output_expr=output_expr,
+                round_fn=round_fn,
+                min_literal=op.dtype.min_literal,
+                max_literal=op.dtype.max_literal,
+                min_fn=min_fn,
+                max_fn=max_fn,
+                dim_args=dim_args,
+            ).rstrip()
+            return with_node_comment(rendered)
+        if isinstance(op, DequantizeLinearOp):
+            params = self._shared_param_map(
+                [
+                    ("input0", op.input0),
+                    ("scale", op.scale),
+                    ("zero_point", op.zero_point),
+                    ("output", op.output),
+                ]
+            )
+            output_dim_names = _dim_names_for(op.output)
+            shape = CEmitter._shape_dim_exprs(op.input_shape, output_dim_names)
+            loop_vars = CEmitter._loop_vars(op.input_shape)
+            input_suffix = self._param_array_suffix(
+                op.input_shape, _dim_names_for(op.input0)
+            )
+            if op.axis is None:
+                scale_shape = ()
+            elif op.block_size:
+                scale_shape_list = list(op.input_shape)
+                scale_shape_list[op.axis] = (
+                    op.input_shape[op.axis] // op.block_size
+                )
+                scale_shape = tuple(scale_shape_list)
+            else:
+                scale_shape = (op.input_shape[op.axis],)
+            scale_suffix = self._param_array_suffix(
+                scale_shape, _dim_names_for(op.scale)
+            )
+            zero_point_suffix = self._param_array_suffix(
+                scale_shape, _dim_names_for(op.zero_point or "")
+            )
+            param_decls = self._build_param_decls(
+                [
+                    (params["input0"], op.input_dtype.c_type, input_suffix, True),
+                    (params["scale"], op.scale_dtype.c_type, scale_suffix, True),
+                    (
+                        params["zero_point"],
+                        op.input_dtype.c_type,
+                        zero_point_suffix,
+                        True,
+                    )
+                    if params["zero_point"]
+                    else (None, "", "", True),
+                    (params["output"], op.dtype.c_type, input_suffix, False),
+                ]
+            )
+            compute_type = "double" if op.dtype == ScalarType.F64 else "float"
+            input_expr = f"{params['input0']}" + "".join(
+                f"[{var}]" for var in loop_vars
+            )
+            output_expr = f"{params['output']}" + "".join(
+                f"[{var}]" for var in loop_vars
+            )
+            if op.axis is None:
+                scale_expr = f"{params['scale']}[0]"
+            elif op.block_size:
+                scale_indices = list(loop_vars)
+                scale_indices[op.axis] = (
+                    f"({loop_vars[op.axis]}) / {op.block_size}"
+                )
+                scale_expr = f"{params['scale']}" + "".join(
+                    f"[{index}]" for index in scale_indices
+                )
+            else:
+                scale_index = loop_vars[op.axis]
+                scale_expr = f"{params['scale']}[{scale_index}]"
+            if params["zero_point"]:
+                if op.axis is None:
+                    zero_expr = f"{params['zero_point']}[0]"
+                elif op.block_size:
+                    scale_indices = list(loop_vars)
+                    scale_indices[op.axis] = (
+                        f"({loop_vars[op.axis]}) / {op.block_size}"
+                    )
+                    zero_expr = f"{params['zero_point']}" + "".join(
+                        f"[{index}]" for index in scale_indices
+                    )
+                else:
+                    zero_expr = f"{params['zero_point']}[{scale_index}]"
+            else:
+                zero_expr = "0"
+            rendered = dequantize_linear_template.render(
+                model_name=model.name,
+                op_name=op_name,
+                input0=params["input0"],
+                scale=params["scale"],
+                zero_point=params["zero_point"],
+                output=params["output"],
+                params=param_decls,
+                compute_type=compute_type,
+                input_c_type=op.input_dtype.c_type,
+                output_c_type=op.dtype.c_type,
+                shape=shape,
+                loop_vars=loop_vars,
+                input_expr=input_expr,
+                scale_expr=scale_expr,
+                zero_expr=zero_expr,
+                output_expr=output_expr,
+                dim_args=dim_args,
+            ).rstrip()
+            return with_node_comment(rendered)
+        if isinstance(op, QLinearMulOp):
+            if scalar_registry is None:
+                raise CodegenError(
+                    "Scalar function registry is required for QLinearMul."
+                )
+            params = self._shared_param_map(
+                [
+                    ("input0", op.input0),
+                    ("input0_scale", op.input0_scale),
+                    ("input0_zero_point", op.input0_zero_point),
+                    ("input1", op.input1),
+                    ("input1_scale", op.input1_scale),
+                    ("input1_zero_point", op.input1_zero_point),
+                    ("output_scale", op.output_scale),
+                    ("output_zero_point", op.output_zero_point),
+                    ("output", op.output),
+                ]
+            )
+            output_shape = CEmitter._codegen_shape(op.output_shape)
+            output_loop_vars = CEmitter._loop_vars(op.output_shape)
+            output_index_expr = f"{params['output']}" + "".join(
+                f"[{var}]" for var in output_loop_vars
+            )
+            input0_index_expr = CEmitter._broadcast_index_expr(
+                params["input0"],
+                op.input0_shape,
+                op.output_shape,
+                output_loop_vars,
+            )
+            input1_index_expr = CEmitter._broadcast_index_expr(
+                params["input1"],
+                op.input1_shape,
+                op.output_shape,
+                output_loop_vars,
+            )
+            input0_suffix = self._param_array_suffix(op.input0_shape)
+            input1_suffix = self._param_array_suffix(op.input1_shape)
+            input0_scale_suffix = self._param_array_suffix(
+                op.input0_scale_shape
+            )
+            input1_scale_suffix = self._param_array_suffix(
+                op.input1_scale_shape
             )
+            output_scale_suffix = self._param_array_suffix(
+                op.output_scale_shape
+            )
+            input0_zero_suffix = self._param_array_suffix(op.input0_zero_shape)
+            input1_zero_suffix = self._param_array_suffix(op.input1_zero_shape)
+            output_zero_suffix = self._param_array_suffix(op.output_zero_shape)
+            output_suffix = self._param_array_suffix(op.output_shape)
             param_decls = self._build_param_decls(
                 [
-                    (params["input0"], op.input_dtype.c_type, input_suffix, True),
-                    (params["scale"], op.scale_dtype.c_type, scale_suffix, True),
                     (
-                        params["zero_point"],
+                        params["input0"],
+                        op.input0_dtype.c_type,
+                        input0_suffix,
+                        True,
+                    ),
+                    (
+                        params["input0_scale"],
+                        op.input0_scale_dtype.c_type,
+                        input0_scale_suffix,
+                        True,
+                    ),
+                    (
+                        params["input0_zero_point"],
+                        op.input0_dtype.c_type,
+                        input0_zero_suffix,
+                        True,
+                    ),
+                    (
+                        params["input1"],
+                        op.input1_dtype.c_type,
+                        input1_suffix,
+                        True,
+                    ),
+                    (
+                        params["input1_scale"],
+                        op.input1_scale_dtype.c_type,
+                        input1_scale_suffix,
+                        True,
+                    ),
+                    (
+                        params["input1_zero_point"],
+                        op.input1_dtype.c_type,
+                        input1_zero_suffix,
+                        True,
+                    ),
+                    (
+                        params["output_scale"],
+                        op.output_scale_dtype.c_type,
+                        output_scale_suffix,
+                        True,
+                    ),
+                    (
+                        params["output_zero_point"],
                         op.dtype.c_type,
-                        zero_point_suffix,
+                        output_zero_suffix,
                         True,
-                    )
-                    if params["zero_point"]
-                    else (None, "", "", True),
-                    (params["output"], op.dtype.c_type, input_suffix, False),
+                    ),
+                    (
+                        params["output"],
+                        op.dtype.c_type,
+                        output_suffix,
+                        False,
+                    ),
                 ]
             )
-            compute_type = "double" if op.input_dtype == ScalarType.F64 else "float"
             compute_dtype = (
                 ScalarType.F64
-                if compute_type == "double"
+                if ScalarType.F64
+                in {
+                    op.input0_scale_dtype,
+                    op.input1_scale_dtype,
+                    op.output_scale_dtype,
+                }
                 else ScalarType.F32
             )
+            compute_type = (
+                "double" if compute_dtype == ScalarType.F64 else "float"
+            )
             max_fn = self._scalar_function_name(
                 ScalarFunction.MAXIMUM, compute_dtype, scalar_registry
             )
@@ -9461,40 +10874,38 @@ class CEmitter:
             )
             if max_fn is None or min_fn is None:
                 raise CodegenError(
-                    "Failed to resolve scalar min/max functions for QuantizeLinear."
+                    "Failed to resolve scalar min/max functions for QLinearMul."
                 )
             round_fn = CEmitter._math_fn(
-                op.input_dtype, "nearbyintf", "nearbyint"
-            )
-            scale_index = "0" if op.axis is None else loop_vars[op.axis]
-            input_expr = f"{params['input0']}" + "".join(
-                f"[{var}]" for var in loop_vars
-            )
-            output_expr = f"{params['output']}" + "".join(
-                f"[{var}]" for var in loop_vars
+                compute_dtype, "nearbyintf", "nearbyint"
             )
-            scale_expr = f"{params['scale']}[{scale_index}]"
-            if params["zero_point"]:
-                zero_expr = f"{params['zero_point']}[{scale_index}]"
-            else:
-                zero_expr = "0"
-            rendered = quantize_linear_template.render(
+            scale_index = "0"
+            rendered = qlinear_mul_template.render(
                 model_name=model.name,
                 op_name=op_name,
                 input0=params["input0"],
-                scale=params["scale"],
-                zero_point=params["zero_point"],
+                input1=params["input1"],
+                input0_scale=params["input0_scale"],
+                input0_zero_point=params["input0_zero_point"],
+                input1_scale=params["input1_scale"],
+                input1_zero_point=params["input1_zero_point"],
+                output_scale=params["output_scale"],
+                output_zero_point=params["output_zero_point"],
                 output=params["output"],
                 params=param_decls,
                 compute_type=compute_type,
-                input_c_type=op.input_dtype.c_type,
                 output_c_type=op.dtype.c_type,
-                shape=shape,
-                loop_vars=loop_vars,
-                input_expr=input_expr,
-                scale_expr=scale_expr,
-                zero_expr=zero_expr,
-                output_expr=output_expr,
+                input0_index_expr=input0_index_expr,
+                input1_index_expr=input1_index_expr,
+                input0_scale_expr=f"{params['input0_scale']}[{scale_index}]",
+                input1_scale_expr=f"{params['input1_scale']}[{scale_index}]",
+                output_scale_expr=f"{params['output_scale']}[{scale_index}]",
+                input0_zero_expr=f"{params['input0_zero_point']}[{scale_index}]",
+                input1_zero_expr=f"{params['input1_zero_point']}[{scale_index}]",
+                output_zero_expr=f"{params['output_zero_point']}[{scale_index}]",
+                output_loop_vars=output_loop_vars,
+                output_loop_bounds=output_shape,
+                output_index_expr=output_index_expr,
                 round_fn=round_fn,
                 min_literal=op.dtype.min_literal,
                 max_literal=op.dtype.max_literal,
@@ -9504,10 +10915,6 @@ class CEmitter:
             ).rstrip()
             return with_node_comment(rendered)
         if isinstance(op, QLinearMatMulOp):
-            if scalar_registry is None:
-                raise CodegenError(
-                    "Scalar function registry is required for QLinearMatMul."
-                )
             params = self._shared_param_map(
                 [
                     ("input0", op.input0),
@@ -9541,13 +10948,18 @@ class CEmitter:
                 row_var = output_loop_vars[-2]
                 col_var = output_loop_vars[-1]
             input0_index_expr, input1_index_expr = CEmitter._matmul_index_exprs(
-                op,
                 batch_vars,
                 row_var,
                 col_var,
                 batch_rank,
                 input0=params["input0"],
                 input1=params["input1"],
+                left_vector=op.left_vector,
+                right_vector=op.right_vector,
+                input0_shape=op.input0_shape,
+                input1_shape=op.input1_shape,
+                input0_batch_shape=op.input0_batch_shape,
+                input1_batch_shape=op.input1_batch_shape,
             )
             input0_suffix = self._param_array_suffix(op.input0_shape)
             input1_suffix = self._param_array_suffix(op.input1_shape)
@@ -9622,32 +11034,28 @@ class CEmitter:
                     ),
                 ]
             )
-            compute_dtype = (
-                ScalarType.F64
-                if ScalarType.F64
-                in {
-                    op.input0_scale_dtype,
-                    op.input1_scale_dtype,
-                    op.output_scale_dtype,
-                }
-                else ScalarType.F32
-            )
+            if ScalarType.F64 in {
+                op.input0_scale_dtype,
+                op.input1_scale_dtype,
+                op.output_scale_dtype,
+            }:
+                scale_dtype = ScalarType.F64
+            elif ScalarType.F32 in {
+                op.input0_scale_dtype,
+                op.input1_scale_dtype,
+                op.output_scale_dtype,
+            }:
+                scale_dtype = ScalarType.F32
+            else:
+                scale_dtype = ScalarType.F16
+            compute_dtype = ScalarType.F64
             compute_type = (
                 "double" if compute_dtype == ScalarType.F64 else "float"
             )
-            max_fn = self._scalar_function_name(
-                ScalarFunction.MAXIMUM, compute_dtype, scalar_registry
-            )
-            min_fn = self._scalar_function_name(
-                ScalarFunction.MINIMUM, compute_dtype, scalar_registry
-            )
-            if max_fn is None or min_fn is None:
-                raise CodegenError(
-                    "Failed to resolve scalar min/max functions for QLinearMatMul."
-                )
             round_fn = CEmitter._math_fn(
                 compute_dtype, "nearbyintf", "nearbyint"
             )
+            mod_fn = CEmitter._math_fn(compute_dtype, "fmodf", "fmod")
             scale_index = "0"
             rendered = qlinear_matmul_template.render(
                 model_name=model.name,
@@ -9662,6 +11070,8 @@ class CEmitter:
                 output_zero_point=params["output_zero_point"],
                 output=params["output"],
                 params=param_decls,
+                scale_type=scale_dtype.c_type,
+                scale_is_float16=scale_dtype == ScalarType.F16,
                 compute_type=compute_type,
                 output_c_type=op.dtype.c_type,
                 input0_index_expr=input0_index_expr,
@@ -9677,10 +11087,8 @@ class CEmitter:
                 output_index_expr=output_index_expr,
                 k=op.k,
                 round_fn=round_fn,
-                min_literal=op.dtype.min_literal,
-                max_literal=op.dtype.max_literal,
-                min_fn=min_fn,
-                max_fn=max_fn,
+                mod_fn=mod_fn,
+                output_is_signed=op.dtype.is_signed,
                 dim_args=dim_args,
             ).rstrip()
             return with_node_comment(rendered)
@@ -9740,7 +11148,11 @@ class CEmitter:
                     loop_vars,
                 )
                 if op.input_min is not None
-                else output_dtype.min_literal
+                else (
+                    CEmitter._format_literal(output_dtype, op.min_value)
+                    if op.min_value is not None
+                    else output_dtype.min_literal
+                )
             )
             max_expr = (
                 CEmitter._broadcast_index_expr(
@@ -9750,7 +11162,11 @@ class CEmitter:
                     loop_vars,
                 )
                 if op.input_max is not None
-                else output_dtype.max_literal
+                else (
+                    CEmitter._format_literal(output_dtype, op.max_value)
+                    if op.max_value is not None
+                    else output_dtype.max_literal
+                )
             )
             input_suffix = self._param_array_suffix(
                 input_shape, _dim_names_for(op.input0)
@@ -9896,11 +11312,14 @@ class CEmitter:
         | ClipOp
         | CastOp
         | QuantizeLinearOp
+        | QLinearMulOp
+        | QLinearMatMulOp
         | MatMulOp
         | EinsumOp
         | GemmOp
         | AttentionOp
         | ConvOp
+        | ConvIntegerOp
         | ConvTransposeOp
         | AveragePoolOp
         | LpPoolOp
@@ -9912,6 +11331,7 @@ class CEmitter:
         | MeanVarianceNormalizationOp
         | RMSNormalizationOp
         | LrnOp
+        | GruOp
         | LstmOp
         | SoftmaxOp
         | LogSoftmaxOp
@@ -9942,9 +11362,11 @@ class CEmitter:
         | ConstantOfShapeOp
         | ShapeOp
         | SizeOp
+        | OptionalHasElementOp
         | ExpandOp
         | CumSumOp
         | RangeOp
+        | HammingWindowOp
         | OneHotOp
         | SplitOp,
     ) -> str:
@@ -9963,11 +11385,13 @@ class CEmitter:
         | ClipOp
         | CastOp
         | QuantizeLinearOp
+        | DequantizeLinearOp
         | MatMulOp
         | EinsumOp
         | GemmOp
         | AttentionOp
         | ConvOp
+        | ConvIntegerOp
         | ConvTransposeOp
         | AveragePoolOp
         | LpPoolOp
@@ -9979,6 +11403,7 @@ class CEmitter:
         | MeanVarianceNormalizationOp
         | RMSNormalizationOp
         | LrnOp
+        | GruOp
         | LstmOp
         | SoftmaxOp
         | LogSoftmaxOp
@@ -10009,9 +11434,11 @@ class CEmitter:
         | ConstantOfShapeOp
         | ShapeOp
         | SizeOp
+        | OptionalHasElementOp
         | ExpandOp
         | CumSumOp
         | RangeOp
+        | HammingWindowOp
         | OneHotOp
         | SplitOp,
     ) -> tuple[tuple[str, tuple[int, ...]], ...]:
@@ -10069,6 +11496,8 @@ class CEmitter:
             return ((op.input0, self._ctx_shape(op.input0)),)
         if isinstance(op, NonZeroOp):
             return ((op.input0, op.input_shape),)
+        if isinstance(op, OptionalHasElementOp):
+            return ((op.input0, self._ctx_shape(op.input0)),)
         if isinstance(op, NonMaxSuppressionOp):
             inputs = [
                 (op.boxes, op.boxes_shape),
@@ -10104,6 +11533,20 @@ class CEmitter:
             if op.zero_point is not None:
                 inputs.append((op.zero_point, scale_shape))
             return tuple(inputs)
+        if isinstance(op, DequantizeLinearOp):
+            if op.axis is None:
+                scale_shape = ()
+            elif op.block_size:
+                input_shape = self._ctx_shape(op.input0)
+                scale_shape_list = list(input_shape)
+                scale_shape_list[op.axis] = input_shape[op.axis] // op.block_size
+                scale_shape = tuple(scale_shape_list)
+            else:
+                scale_shape = (self._ctx_shape(op.input0)[op.axis],)
+            inputs = [(op.input0, self._ctx_shape(op.input0)), (op.scale, scale_shape)]
+            if op.zero_point is not None:
+                inputs.append((op.zero_point, scale_shape))
+            return tuple(inputs)
         if isinstance(op, IdentityOp):
             return ((op.input0, self._ctx_shape(op.input0)),)
         if isinstance(op, EyeLikeOp):
@@ -10138,6 +11581,8 @@ class CEmitter:
             return ((op.input0, op.input_shape),)
         if isinstance(op, RangeOp):
             return ((op.start, ()), (op.limit, ()), (op.delta, ()))
+        if isinstance(op, HammingWindowOp):
+            return ((op.size, ()),)
         if isinstance(op, OneHotOp):
             return (
                 (op.indices, op.indices_shape),
@@ -10147,7 +11592,10 @@ class CEmitter:
         if isinstance(op, SplitOp):
             return ((op.input0, op.input_shape),)
         if isinstance(op, TopKOp):
-            return ((op.input0, self._ctx_shape(op.input0)),)
+            return (
+                (op.input0, self._ctx_shape(op.input0)),
+                (op.k_input, self._ctx_shape(op.k_input)),
+            )
         if isinstance(op, (TransposeOp, ReshapeOp, ReduceOp, ArgReduceOp)):
             return ((op.input0, self._ctx_shape(op.input0)),)
         return ()
@@ -10162,6 +11610,7 @@ class CEmitter:
             | ClipOp
             | CastOp
             | QuantizeLinearOp
+            | DequantizeLinearOp
             | MatMulOp
             | EinsumOp
             | GemmOp
@@ -10178,6 +11627,7 @@ class CEmitter:
             | MeanVarianceNormalizationOp
             | RMSNormalizationOp
             | LrnOp
+            | GruOp
             | LstmOp
             | SoftmaxOp
             | LogSoftmaxOp
@@ -10210,6 +11660,7 @@ class CEmitter:
             | NonMaxSuppressionOp
             | ExpandOp
             | RangeOp
+            | HammingWindowOp
             | OneHotOp
             | SplitOp
         ],
@@ -10234,11 +11685,13 @@ class CEmitter:
         | ClipOp
         | CastOp
         | QuantizeLinearOp
+        | DequantizeLinearOp
         | MatMulOp
         | EinsumOp
         | GemmOp
         | AttentionOp
         | ConvOp
+        | ConvIntegerOp
         | ConvTransposeOp
         | AveragePoolOp
         | LpPoolOp
@@ -10250,6 +11703,7 @@ class CEmitter:
         | MeanVarianceNormalizationOp
         | RMSNormalizationOp
         | LrnOp
+        | GruOp
         | LstmOp
         | SoftmaxOp
         | LogSoftmaxOp
@@ -10284,9 +11738,18 @@ class CEmitter:
         | NonMaxSuppressionOp
         | ExpandOp
         | RangeOp
+        | HammingWindowOp
         | OneHotOp
         | SplitOp,
     ) -> tuple[tuple[str, tuple[int, ...], ScalarType], ...]:
+        if isinstance(op, OptionalHasElementOp):
+            return (
+                (
+                    op.output,
+                    self._op_output_shape(op),
+                    self._op_output_dtype(op),
+                ),
+            )
         if isinstance(
             op,
             (
@@ -10341,6 +11804,39 @@ class CEmitter:
                     )
             )
             return tuple(outputs)
+        if isinstance(op, GruOp):
+            outputs: list[tuple[str, tuple[int, ...], ScalarType]] = []
+            if op.output_y is not None:
+                if op.layout == 0:
+                    y_shape = (
+                        op.seq_length,
+                        op.num_directions,
+                        op.batch_size,
+                        op.hidden_size,
+                    )
+                else:
+                    y_shape = (
+                        op.batch_size,
+                        op.seq_length,
+                        op.num_directions,
+                        op.hidden_size,
+                    )
+                outputs.append((op.output_y, y_shape, op.dtype))
+            if op.output_y_h is not None:
+                if op.layout == 0:
+                    state_shape = (
+                        op.num_directions,
+                        op.batch_size,
+                        op.hidden_size,
+                    )
+                else:
+                    state_shape = (
+                        op.batch_size,
+                        op.num_directions,
+                        op.hidden_size,
+                    )
+                outputs.append((op.output_y_h, state_shape, op.dtype))
+            return tuple(outputs)
         if isinstance(op, LstmOp):
             outputs: list[tuple[str, tuple[int, ...], ScalarType]] = []
             if op.output_y is not None:
@@ -10456,12 +11952,14 @@ class CEmitter:
         | ClipOp
         | CastOp
         | QuantizeLinearOp
+        | DequantizeLinearOp
         | QLinearMatMulOp
         | MatMulOp
         | EinsumOp
         | GemmOp
         | AttentionOp
         | ConvOp
+        | ConvIntegerOp
         | AveragePoolOp
         | BatchNormOp
         | LpNormalizationOp
@@ -10471,6 +11969,7 @@ class CEmitter:
         | MeanVarianceNormalizationOp
         | RMSNormalizationOp
         | LrnOp
+        | GruOp
         | LstmOp
         | SoftmaxOp
         | LogSoftmaxOp
@@ -10485,6 +11984,7 @@ class CEmitter:
         | TransposeOp
         | ReshapeOp
         | IdentityOp
+        | BernoulliOp
         | EyeLikeOp
         | TriluOp
         | TileOp
@@ -10502,7 +12002,10 @@ class CEmitter:
         | ExpandOp
         | CumSumOp
         | RangeOp
+        | HammingWindowOp
         | OneHotOp
+        | TfIdfVectorizerOp
+        | RotaryEmbeddingOp
         | SplitOp
         | PadOp,
     ) -> tuple[int, ...]:
@@ -10518,21 +12021,29 @@ class CEmitter:
             return self._ctx_shape(op.output)
         if isinstance(op, QuantizeLinearOp):
             return op.input_shape
+        if isinstance(op, DequantizeLinearOp):
+            return op.input_shape
         if isinstance(op, CastOp):
             return self._ctx_shape(op.output)
+        if isinstance(op, QLinearMulOp):
+            return op.output_shape
         if isinstance(op, QLinearMatMulOp):
             return op.output_shape
         if isinstance(op, MatMulOp):
-            return op.output_shape
+            return self._ctx_shape(op.output)
         if isinstance(op, EinsumOp):
             return op.output_shape
         if isinstance(op, GemmOp):
-            return (op.m, op.n)
+            return self._ctx_shape(op.output)
         if isinstance(op, ConvOp):
             return (op.batch, op.out_channels, *op.out_spatial)
+        if isinstance(op, ConvIntegerOp):
+            return (op.batch, op.out_channels, *op.out_spatial)
         if isinstance(op, ConvTransposeOp):
             return (op.batch, op.out_channels, *op.out_spatial)
         if isinstance(op, AveragePoolOp):
+            if op.spatial_rank == 3:
+                return (op.batch, op.channels, op.out_d, op.out_h, op.out_w)
             return (op.batch, op.channels, op.out_h, op.out_w)
         if isinstance(op, LpPoolOp):
             return (op.batch, op.channels, op.out_h, op.out_w)
@@ -10582,6 +12093,8 @@ class CEmitter:
             return self._ctx_shape(op.output)
         if isinstance(op, IdentityOp):
             return self._ctx_shape(op.output)
+        if isinstance(op, BernoulliOp):
+            return op.output_shape
         if isinstance(op, EyeLikeOp):
             return op.output_shape
         if isinstance(op, TriluOp):
@@ -10612,6 +12125,8 @@ class CEmitter:
             return op.output_shape
         if isinstance(op, SizeOp):
             return op.output_shape
+        if isinstance(op, OptionalHasElementOp):
+            return self._ctx_shape(op.output)
         if isinstance(op, NonZeroOp):
             return op.output_shape
         if isinstance(op, NonMaxSuppressionOp):
@@ -10622,8 +12137,14 @@ class CEmitter:
             return op.input_shape
         if isinstance(op, RangeOp):
             return op.output_shape
+        if isinstance(op, HammingWindowOp):
+            return op.output_shape
         if isinstance(op, OneHotOp):
             return op.output_shape
+        if isinstance(op, TfIdfVectorizerOp):
+            return op.output_shape
+        if isinstance(op, RotaryEmbeddingOp):
+            return op.input_shape
         if op.output_rank == 3:
             return (op.batch, op.q_seq, op.q_heads * op.v_head_size)
         return (op.batch, op.q_heads, op.q_seq, op.v_head_size)
@@ -10637,11 +12158,13 @@ class CEmitter:
         | ClipOp
         | CastOp
         | QuantizeLinearOp
+        | DequantizeLinearOp
         | MatMulOp
         | EinsumOp
         | GemmOp
         | AttentionOp
         | ConvOp
+        | ConvIntegerOp
         | ConvTransposeOp
         | AveragePoolOp
         | LpPoolOp
@@ -10666,6 +12189,7 @@ class CEmitter:
         | TransposeOp
         | ReshapeOp
         | IdentityOp
+        | BernoulliOp
         | EyeLikeOp
         | TriluOp
         | TileOp
@@ -10681,7 +12205,9 @@ class CEmitter:
         | ExpandOp
         | CumSumOp
         | RangeOp
+        | HammingWindowOp
         | OneHotOp
+        | TfIdfVectorizerOp
         | SplitOp
         | PadOp,
     ) -> ScalarType:
@@ -10689,8 +12215,12 @@ class CEmitter:
             return self._ctx_dtype(op.output)
         if isinstance(op, TopKOp):
             return self._ctx_dtype(op.output_values)
+        if isinstance(op, OptionalHasElementOp):
+            return self._ctx_dtype(op.output)
         if isinstance(op, NonMaxSuppressionOp):
             return op.output_dtype
+        if isinstance(op, TfIdfVectorizerOp):
+            return op.output_dtype
         if isinstance(
             op,
             (
@@ -10703,6 +12233,8 @@ class CEmitter:
                 SoftmaxOp,
                 LogSoftmaxOp,
                 HardmaxOp,
+                MatMulOp,
+                GemmOp,
                 GatherOp,
                 TransposeOp,
                 ReshapeOp,
@@ -10729,10 +12261,12 @@ class CEmitter:
         self,
         shape: tuple[int, ...],
         dim_names: Mapping[int, str] | None = None,
+        *,
+        use_restrict: bool = False,
     ) -> str:
         shape = CEmitter._codegen_shape(shape)
         dim_names = dim_names or {}
-        if not self._restrict_arrays:
+        if not (self._restrict_arrays and use_restrict):
             return "".join(
                 f"[{dim_names.get(index, dim)}]"
                 for index, dim in enumerate(shape)
@@ -10755,6 +12289,16 @@ class CEmitter:
             return ""
         return ", ".join(f"int {dim_name}" for dim_name in dim_order) + ", "
 
+    @staticmethod
+    def _optional_input_flag_map(model: LoweredModel) -> dict[str, str]:
+        return {
+            name: flag
+            for name, flag in zip(
+                model.input_names, model.input_optional_names
+            )
+            if flag is not None
+        }
+
     def _build_variable_dim_names(
         self,
         model: LoweredModel,
@@ -10772,6 +12316,12 @@ class CEmitter:
         dim_vars: dict[tuple[str, int, int], str] = {}
         dim_values: dict[str, int] = {}
         reserved_names = set(model.input_names) | set(model.output_names)
+        reserved_names.update(
+            name for name in model.input_optional_names if name is not None
+        )
+        reserved_names.update(
+            name for name in model.output_optional_names if name is not None
+        )
         used_names = set(reserved_names)
         dim_aliases: dict[str, str] = {}
 
@@ -10926,14 +12476,19 @@ class CEmitter:
 
     @staticmethod
     def _matmul_index_exprs(
-        op: MatMulOp,
         batch_vars: tuple[str, ...],
         row_var: str | None,
         col_var: str | None,
         batch_rank: int,
         *,
-        input0: str | None = None,
-        input1: str | None = None,
+        input0: str,
+        input1: str,
+        left_vector: bool,
+        right_vector: bool,
+        input0_shape: tuple[int, ...],
+        input1_shape: tuple[int, ...],
+        input0_batch_shape: tuple[int, ...],
+        input1_batch_shape: tuple[int, ...],
     ) -> tuple[str, str]:
         def batch_indices(
             batch_shape: tuple[int, ...], actual_rank: int
@@ -10948,28 +12503,28 @@ class CEmitter:
                 indices.append("0" if dim == 1 else var)
             return indices
 
-        if op.left_vector:
+        if left_vector:
             input0_indices = ["k"]
         else:
-            input0_batch_rank = len(op.input0_shape) - 2
+            input0_batch_rank = len(input0_shape) - 2
             input0_indices = batch_indices(
-                op.input0_batch_shape, input0_batch_rank
+                input0_batch_shape, input0_batch_rank
             )
             input0_indices.append(row_var if row_var is not None else "0")
             input0_indices.append("k")
-        if op.right_vector:
+        if right_vector:
             input1_indices = ["k"]
         else:
-            input1_batch_rank = len(op.input1_shape) - 2
+            input1_batch_rank = len(input1_shape) - 2
             input1_indices = batch_indices(
-                op.input1_batch_shape, input1_batch_rank
+                input1_batch_shape, input1_batch_rank
             )
             input1_indices.append("k")
             input1_indices.append(col_var if col_var is not None else "0")
-        input0_index_expr = f"{input0 or op.input0}" + "".join(
+        input0_index_expr = f"{input0}" + "".join(
             f"[{index}]" for index in input0_indices
         )
-        input1_index_expr = f"{input1 or op.input1}" + "".join(
+        input1_index_expr = f"{input1}" + "".join(
             f"[{index}]" for index in input1_indices
         )
         return input0_index_expr, input1_index_expr
@@ -10980,6 +12535,7 @@ class CEmitter:
         testbench_template,
         *,
         testbench_inputs: Mapping[str, tuple[float | int | bool, ...]] | None = None,
+        testbench_optional_inputs: Mapping[str, bool] | None = None,
         dim_order: Sequence[str],
         dim_values: Mapping[str, int],
         weight_data_filename: str,
@@ -10988,13 +12544,34 @@ class CEmitter:
             self._element_count(shape) for shape in model.input_shapes
         )
         testbench_inputs = testbench_inputs or {}
+        testbench_optional_inputs = testbench_optional_inputs or {}
+        rng_requires_u64 = False
+        rng_requires_float = False
+        rng_requires_double = False
+        rng_requires_i64 = False
         inputs = []
-        for name, shape, count, dtype in zip(
-            model.input_names, model.input_shapes, input_counts, model.input_dtypes
+        for name, shape, count, dtype, optional_flag in zip(
+            model.input_names,
+            model.input_shapes,
+            input_counts,
+            model.input_dtypes,
+            model.input_optional_names,
         ):
+            json_name = self._ctx_name(name)
             codegen_shape = self._codegen_shape(shape)
             loop_shape = (1,) if not shape else shape
             loop_vars = self._loop_vars(loop_shape)
+            constant_values = testbench_inputs.get(name)
+            if constant_values is None:
+                rng_requires_u64 = True
+                if dtype in {ScalarType.F16, ScalarType.F32}:
+                    rng_requires_float = True
+                elif dtype == ScalarType.F64:
+                    rng_requires_double = True
+                elif dtype == ScalarType.BOOL:
+                    pass
+                else:
+                    rng_requires_i64 = True
             if dtype in {ScalarType.F16, ScalarType.F32}:
                 random_expr = "rng_next_float()"
             elif dtype == ScalarType.F64:
@@ -11003,7 +12580,6 @@ class CEmitter:
                 random_expr = "((rng_next_u64() & 1ull) != 0)"
             else:
                 random_expr = f"({dtype.c_type})rng_next_i64()"
-            constant_values = testbench_inputs.get(name)
             constant_name = None
             constant_lines = None
             if constant_values is not None:
@@ -11015,6 +12591,11 @@ class CEmitter:
                     ]
                 else:
                     constant_lines = [self._format_value(0, dtype)]
+            optional_present = (
+                testbench_optional_inputs.get(name, True)
+                if optional_flag is not None
+                else None
+            )
             inputs.append(
                 {
                     "name": name,
@@ -11035,12 +12616,16 @@ class CEmitter:
                     "print_cast": self._print_cast(dtype),
                     "constant_name": constant_name,
                     "constant_lines": constant_lines,
+                    "json_name": json_name,
+                    "optional_flag_name": optional_flag,
+                    "optional_present": optional_present,
                 }
             )
         outputs = []
         for name, shape, dtype in zip(
             model.output_names, model.output_shapes, model.output_dtypes
         ):
+            json_name = self._ctx_name(name)
             codegen_shape = self._codegen_shape(shape)
             loop_shape = (1,) if not shape else shape
             output_loop_vars = self._loop_vars(loop_shape)
@@ -11061,10 +12646,15 @@ class CEmitter:
                     "c_type": dtype.c_type,
                     "print_format": self._print_format(dtype),
                     "print_cast": self._print_cast(dtype),
+                    "json_name": json_name,
                 }
             )
         rendered = testbench_template.render(
             model_name=model.name,
+            rng_requires_u64=rng_requires_u64,
+            rng_requires_float=rng_requires_float,
+            rng_requires_double=rng_requires_double,
+            rng_requires_i64=rng_requires_i64,
             dim_args=[
                 {"name": dim_name, "value": dim_values[dim_name]}
                 for dim_name in dim_order
@@ -11097,13 +12687,30 @@ class CEmitter:
     ) -> tuple[tuple[ConstTensor, ...], tuple[ConstTensor, ...]]:
         if self._large_weight_threshold <= 0:
             return constants, ()
+        sorted_constants = sorted(
+            enumerate(constants),
+            key=lambda item: (
+                self._element_count(item[1].shape)
+                * item[1].dtype.np_dtype.itemsize,
+                item[0],
+            ),
+        )
+        inline_set: set[ConstTensor] = set()
+        total_bytes = 0
+        for _, const in sorted_constants:
+            const_bytes = (
+                self._element_count(const.shape) * const.dtype.np_dtype.itemsize
+            )
+            if total_bytes + const_bytes <= self._large_weight_threshold:
+                inline_set.add(const)
+                total_bytes += const_bytes
         inline: list[ConstTensor] = []
         large: list[ConstTensor] = []
         for const in constants:
-            if self._element_count(const.shape) > self._large_weight_threshold:
-                large.append(const)
-            else:
+            if const in inline_set:
                 inline.append(const)
+            else:
+                large.append(const)
         return tuple(inline), tuple(large)
 
     @staticmethod
@@ -11113,12 +12720,16 @@ class CEmitter:
     def _emit_weight_loader(
         self, model: LoweredModel, large_constants: tuple[ConstTensor, ...]
     ) -> str:
-        lines = [f"_Bool {model.name}_load(const char *path) {{"]
+        lines = []
         if not large_constants:
+            lines.append(f"_Bool {model.name}_load(const char *path) {{")
             lines.append("    (void)path;")
             lines.append("    return 1;")
             lines.append("}")
             return _format_c_indentation("\n".join(lines))
+        lines.append(f"static _Bool {model.name}_load_file(FILE *file);")
+        lines.append("")
+        lines.append(f"_Bool {model.name}_load(const char *path) {{")
         lines.append("    FILE *file = fopen(path, \"rb\");")
         lines.append("    if (!file) {")
         lines.append("        return 0;")
@@ -11171,7 +12782,7 @@ class CEmitter:
                 for value in const.data
             ]
             lines.append(
-                f"{storage_prefix} {c_type} {const.name}{array_suffix} = {{"
+                f"{storage_prefix} EMX_UNUSED {c_type} {const.name}{array_suffix} = {{"
             )
             if values:
                 if (
@@ -11199,12 +12810,23 @@ class CEmitter:
             return ""
         lines = []
         for index, const in enumerate(constants, start=1):
-            lines.append(self._emit_constant_comment(const, index))
             c_type = const.dtype.c_type
             array_suffix = self._array_suffix(const.shape)
             lines.append(f"extern const {c_type} {const.name}{array_suffix};")
         return "\n".join(lines)
 
+    def _emit_constant_storage_declarations(
+        self, constants: tuple[ConstTensor, ...]
+    ) -> str:
+        if not constants:
+            return ""
+        lines = []
+        for index, const in enumerate(constants, start=1):
+            c_type = const.dtype.c_type
+            array_suffix = self._array_suffix(const.shape)
+            lines.append(f"extern {c_type} {const.name}{array_suffix};")
+        return "\n".join(lines)
+
     def _emit_constant_storage_definitions(
         self,
         constants: tuple[ConstTensor, ...],
@@ -11214,11 +12836,12 @@ class CEmitter:
         if not constants:
             return ""
         lines: list[str] = []
+        prefix = f"{storage_prefix} " if storage_prefix else ""
         for index, const in enumerate(constants, start=1):
             lines.append(self._emit_constant_comment(const, index))
             c_type = const.dtype.c_type
             array_suffix = self._array_suffix(const.shape)
-            lines.append(f"{storage_prefix} {c_type} {const.name}{array_suffix};")
+            lines.append(f"{prefix}{c_type} {const.name}{array_suffix};")
             lines.append("")
         if lines and not lines[-1]:
             lines.pop()