status.ForEachPayload(
      [tf_status](absl::string_view key, const absl::Cord& value) {
        std::string key_str(key);
        std::string value_str(value);
        TF_SetPayload(tf_status, key_str.c_str(), value_str.c_str());
      });
}

absl::Status StatusFromTF_Status(const TF_Status* tf_status) {
  absl::Status status(StatusCodeFromTSLCode(TF_GetCode(tf_status)),

  // Caller is responsible to call `TF_DeleteBuffer` to release the buffer.
  TF_Buffer* result = TF_NewBuffer();
  const std::string& value_str = *value;
  void* data = malloc(value_str.length());
  value_str.copy(static_cast<char*>(data), value_str.length(), 0);
  result->data = data;
  result->length = value_str.length();
  result->data_deallocator = [](void* data, size_t length) { free(data); };
  return result;
}

  if constexpr (std::is_integral_v<T>) {
    DenseIntElementsAttr value_attr;
    if (!matchPattern(value, m_Constant(&value_attr)) ||
        !value_attr.isSplat()) {
      return false;
    }
    splat_value = value_attr.getSplatValue<T>();
    return true;
  }

  DenseFPElementsAttr value_attr;
  if (!matchPattern(value, m_Constant(&value_attr)) || !value_attr.isSplat()) {
    return false;
  }

      // Convert values.
      std::vector<Eigen::half> new_values;
      const DenseFPElementsAttr value_attr =
          mlir::cast<DenseFPElementsAttr>(op.getValue());
      new_values.reserve(value_attr.getNumElements());

      for (const float value : value_attr.getValues<float>()) {
        new_values.push_back(Eigen::half(
            std::min(std::max(value, kMinFloat16Value), kMaxFloat16Value)));

        cast<mlir::stablehlo::ConstantOp>(op.getOperand().getDefiningOp());

    const auto value_attr =
        mlir::cast<DenseFPElementsAttr>(const_op.getValue());
    const ArrayRef<int64_t> original_shape =
        value_attr.getShapedType().getShape();

    const SmallVector<float> original_values =
        llvm::to_vector(value_attr.getValues<float>());

    // Fold the constant value by transposing the values according to the

      // Cast values
      std::vector<Eigen::half> new_values;
      DenseFPElementsAttr value_attr =
          mlir::cast<DenseFPElementsAttr>(op.getValue());
      new_values.reserve(value_attr.getNumElements());

      constexpr float kMaxFloat16Value = 65504.f;
      constexpr float kMinFloat16Value = -65504.f;

      for (auto value : value_attr.template getValues<float>()) {
        new_values.push_back(Eigen::half(

    mlir::Builder b(expected_ty.getContext());
    Tensor tensor(dtype, TensorShape({static_cast<int64_t>(values.size())}));
    tensor.flat<T>().setValues(values);

    auto value_or = ConvertTensor(tensor, &b);
    TF_ASSERT_OK(value_or.status());
    auto attr = value_or.value();

    EXPECT_EQ(attr.getShapedType().getElementType(), expected_ty);

    Tensor out;
    TF_ASSERT_OK(ConvertToTensor(attr, &out));

      converted_attrs.push_back(attr);
    } else if (attr.getName() == op.getPaddingAttrName()) {
      auto value_or = ConvertPaddingAttr(op, dnums, rewriter);
      if (failed(value_or)) {
        return failure();
      }
      attr.setValue(*value_or);
      converted_attrs.push_back(attr);
    } else if (attr.getName() == op.getWindowStridesAttrName() ||

      quant_specs.default_ranges.second.has_value()) {
    pass_manager.addNestedPass<mlir::func::FuncOp>(
        mlir::TFL::CreateDefaultQuantParamsPass(
            quant_specs.default_ranges.first.value_or(0.0),
            quant_specs.default_ranges.second.value_or(0.0),
            quant_specs.IsSignedInferenceType()));
  }
  pass_manager.addNestedPass<mlir::func::FuncOp>(
      mlir::TFL::CreateQuantizePass(quant_specs));

    if (!const_op) return std::nullopt;

    auto value_attr = const_op.getValue().dyn_cast<DenseIntElementsAttr>();
    if (!value_attr || value_attr.getNumElements() != 1) return std::nullopt;

    auto value_ty = value_attr.getType();
    if (!value_ty.hasRank() || value_ty.getRank() != expected_rank)
      return std::nullopt;

    auto splat = value_attr.getSplatValue<IntegerAttr>();