auto elem_type = filter_type.getElementType();
    auto bias_dim = static_cast<const ConcreteType *>(this)->getBiasDim(
        filter_type.getShape());
    auto bias_type =
        tensorflow::GetTypeFromTFTensorShape({bias_dim}, elem_type);
    auto bias_attr = rewriter.getZeroAttr(bias_type);
    auto bias =

  Output arg1 = ops::_Arg(s.WithOpName("arg1"), DT_BOOL, 1);
  NameAttrList f;
  f.set_name("f1");
  auto if_op = ops::If(s.WithOpName("if"), arg1,
                       std::initializer_list<Input>{arg0, arg1},
                       {DT_BOOL, DT_RESOURCE}, f, f);
  auto ret0 = ops::_Retval(s.WithOpName("ret0"), if_op.output[0], 0);
  auto ret1 = ops::_Retval(s.WithOpName("ret1"), if_op.output[1], 1);
  NameAttrList cond_fn, body_fn;

  Type ref_qtype = nullptr;
  for (auto *var_handle_user : var_handle_op.getResult().getUsers()) {
    auto read_variable_op = dyn_cast_or_null<ReadVariableOp>(var_handle_user);
    if (!read_variable_op) continue;
    for (auto *read_variable_user : read_variable_op.getResult().getUsers()) {
      auto q_op = dyn_cast_or_null<QuantizeOp>(read_variable_user);
      if (!q_op || ref_qtype) continue;

    return false;

  if (auto arith_const_op = dyn_cast_or_null<arith::ConstantOp>(op)) {
    // arith ConstOp path.
    auto type =
        mlir::cast<ShapedType>(arith_const_op.getType()).getElementType();
    if (!type.isInteger(32) && !type.isInteger(64)) return false;
  } else if (auto const_op = dyn_cast_or_null<TFL::ConstOp>(op)) {
    // ConstOp path.

      TF_ShapeHandle* result, TF_Status* status) {                         \
    auto* cc_ctx = reinterpret_cast<InferenceContext*>(ctx);               \
    auto* cc_handle = reinterpret_cast<ShapeHandle*>(handle);              \
    auto* cc_result = reinterpret_cast<ShapeHandle*>(result);              \
    Status s = cc_ctx->func_name(*cc_handle, rank, cc_result);             \

}

TEST(NumericalUtils, ActivationRange) {
  // zero point = 0
  auto a =
      CalculateQuantizedRange(1e-6, 0, std::nullopt, std::nullopt, -128, 127);
  ASSERT_EQ(a.first, -128);
  ASSERT_EQ(a.second, 127);

  auto b = CalculateQuantizedRange(1e-6, 0, 0.0, std::nullopt, -128, 127);
  ASSERT_EQ(b.first, 0);
  ASSERT_EQ(b.second, 127);

  auto c = CalculateQuantizedRange(1e-6, 0, -1.0, 1.0, -128, 127);

  if (!devices.has_value()) {
    return op->emitOpError()
           << "devices attribute is not present in 'tf.device.replicate' op";
  }
  auto logical_core_name =
      tensorflow::GetDeviceAliasForLogicalCore(logical_core);
  auto tpu_replica = devices.value().get(logical_core_name);
  if (!tpu_replica) {
    return op->emitOpError()
           << "requires device ordinal from device " << logical_core_name

                               llvm::BitVector& erase_indices) {
  auto terminator = func.front().getTerminator();
  int num_operands = terminator->getNumOperands();
  erase_indices.resize(num_operands);
  for (auto arg_index : arguments_to_erase) {
    auto argument = func.getArgument(arg_index);
    for (auto& use : argument.getUses()) {
      if (llvm::isa<func::ReturnOp, TF::YieldOp>(use.getOwner())) {

  std::vector<ResultType> res;
  res.reserve(num_results);

  auto lhs_start = lhs_vals.begin();
  auto rhs_start = rhs_vals.begin();

  for (int i = 0; i < num_results; ++i) {
    auto lhs_val = lhs_splat ? *lhs_start : *(lhs_start++);
    auto rhs_val = rhs_splat ? *rhs_start : *(rhs_start++);
    auto signed_lhs_val = AddSign(lhs_val);
    auto signed_rhs_val = AddSign(rhs_val);
    if (signed_rhs_val.isZero()) {

TEST(CAPI, MonitoringCellReader0) {
  auto counter_name = "test/counter0";
  auto* counter = CreateCounter0(counter_name);
  auto* reader = TFE_MonitoringNewCounterReader(counter_name);
  IncrementCounter0(counter);

  int64_t actual = TFE_MonitoringReadCounter0(reader);

  CHECK_EQ(actual, 1);
}

TEST(CAPI, MonitoringCellReader1) {
  auto counter_name = "test/counter1";
  auto label_name = "test/label";