}];

  let arguments = (ins
    Arg<TF_Int32Tensor, [{int32 `Tensor`.}]>:$arr,
    Arg<TF_Int32Tensor, [{non-negative int32 scalar `Tensor`.}]>:$size,
    Arg<TensorOf<[TF_Float32, TF_Float64, TF_Int32, TF_Int64]>, [{is an int32, int64, float32, or float64 `Tensor` with the same
shape as `arr`, or a length-0 `Tensor`, in which case it acts as all weights
equal to 1.}]>:$weights
  );

          (TF_SubOp $max_range, $min_range),
          (TF_ConstOp (GetF32Scalar<255>)))),
      $min_range),
    /*truncate=*/ConstBoolAttrFalse),
  [(TensorOf<[TF_Qint8, TF_Quint8]> $input),
   (TF_Float32Tensor $min_range),
   (TF_Float32Tensor $max_range),
   (TensorOf<[TF_Float32, TF_Bfloat16]> $result)]>;

//===----------------------------------------------------------------------===//
// Difference op patterns.

          Type qtype = attr.getValue();
          auto tensor_or = BuildTensorFromType(
              qtype, name_mapper_.GetUniqueName(intermediate).str());
          if (!tensor_or.has_value()) {
            continue;
          } else {
            intermediates.push_back(tensors.size());
            tensors.push_back(tensor_or.value());
          }
        }
      }
    }

        ) from ex


def _convert_values_to_tf_tensors(
    sample: rd.RepresentativeSample,
) -> Mapping[str, core.Tensor]:
  """Converts TensorLike values of `sample` to Tensors.

  Creates a copy of `sample`, where each value is converted to Tensors
  unless it is already a Tensor.
  The values are not converted in-place (i.e. `sample` is not mutated).

  Args:

  // There should be 3 tensors: input, output, and BroadcastTo/shape.
  EXPECT_THAT(subgraph->tensors, SizeIs(3));

  // Input Tensor
  EXPECT_THAT(subgraph->tensors[0]->type, Eq(tensor_type_));
  EXPECT_THAT(subgraph->tensors[0]->name, Eq("input_1"));
  EXPECT_THAT(subgraph->tensors[0]->quantization->scale, SizeIs(1));
  EXPECT_THAT(subgraph->tensors[0]->quantization->zero_point, SizeIs(1));

  let summary = "Loads a restored variable tensor as a tensor future";

  let description = [{
    This op loads a restored variable tensor as a tensor future. It is a
    replacement of `tf.ReadVariableOp`.

    This op returns a scalar string tensor containing the restored variable name, which 
    is composed from `container_name` and `shared_name` from a `var_handle` and can be

func.func @uniform_dequantize_op(%arg: tensor<2x2x!quant.uniform<i8:f32, 1.000000e+0:8>>) -> tensor<2x2xf32> {
  %0 = stablehlo.uniform_dequantize %arg : (tensor<2x2x!quant.uniform<i8:f32, 1.000000e+0:8>>) -> tensor<2x2xf32>
  return %0 : tensor<2x2xf32>
}
// CHECK-LABEL: uniform_dequantize_op
// CHECK: %[[DEQUANT:.+]] = "tfl.dequantize"({{.*}}) : (tensor<2x2x!quant.uniform<i8:f32, 1.000000e+00:8>>) -> tensor<2x2xf32>
// CHECK: return %[[DEQUANT]]

    $quant_input,
    $bias, $padding, $stride_h, $stride_w, $faf),
  (TFL_TransposeConvOp $output_shape, $quant_weights,
    $quant_input, $bias, $padding, $stride_h, $stride_w, $faf), 

// as tensor names may have changed via MLIR constant folding process.
bool ExpectEqualTensor(const Tensor* tensor, const Tensor* expected_tensor) {
  return (tensor->is_variable() == expected_tensor->is_variable()) &&
         (GetAsVector(tensor->shape()) ==
          GetAsVector(expected_tensor->shape()));
}

// Finds the match of the quantized tensor from the possible tensors. Each

  }
  return tpu_shape.AsCpp<xla::Shape>();
}

// Given a tensor, returns the shape of its representation on device,
// fully padded. Contents of `shape` are undefined on error.
Status TpuPaddedShapeFn(const Tensor& tensor, xla::Shape* shape) {
  const tensorflow::XlaTensor* xla_tensor =
      tensorflow::XlaTensor::FromTensor(&tensor);
  if (xla_tensor == nullptr) {
    return errors::InvalidArgument(