}
    }

    auto check_i64_attr =
        [&](const std::string& attr_name) -> mlir::LogicalResult {
      if (!backend_config.contains(attr_name)) {
        return op.emitOpError()
               << "Missing " << attr_name << " attribute in backend_config";
      }
      auto attr = backend_config.getAs<IntegerAttr>(attr_name);
      if (!attr || !attr.getType().isInteger(64)) {
        return op.emitOpError()

      auto sizes = mlir::DenseI32ArrayAttr::get(context, {1, 1, 1, 0});
      auto attr_name =
          StringAttr::get(context, mlir::OpTrait::AttrSizedOperandSegments<
                                       void>::getOperandSegmentSizeAttr());
      attrs.push_back(NamedAttribute(attr_name, sizes));
    }

    // Insert fused operation right before the BiasAdd operation to guarantee

    } else if (n->IsIfNode()) {
      for (const string& attr_name :
           std::vector<string>{"then_branch", "else_branch"}) {
        NameAttrList branch_func;
        TF_RETURN_IF_ERROR(GetNodeAttr(n->attrs(), attr_name, &branch_func));
        (*branch_func.mutable_attr())["_device_ordinal"] = device_ordinal_value;
        n->ClearAttr(attr_name);
        n->AddAttr(attr_name, branch_func);
      }
    } else if (n->IsWhileNode()) {

        all_attrs.insert(attr.getName().strref());
      }
      for (const auto& operand : llvm::enumerate(getArgumentTypes())) {
        if (auto attr_name = getArgAttrOfType<StringAttr>(
            operand.index(), kAttrArgumentNameAttr)) {
          all_attrs.insert(attr_name.getValue());
        }
      }
      return all_attrs;
    }
  }];

  let hasVerifier = 1;
  let hasCustomAssemblyFormat = 1;
}

                             llvm::StringRef attr_name) {
  return attr_name.compare(kOutputShapesAttrName) == 0 &&
         attr_value.value_case() == AttrValue::kList;
}

bool IsResourceOutputShapesAttribute(const AttrValue& attr_value,
                                     llvm::StringRef attr_name) {
  if (attr_name == "_handle_dtypes" || attr_name == "_handle_shapes")

                                                const char* attr_name,
                                                int64_t* dims, size_t num_dims,
                                                TF_Status* status) {
  ::tensorflow::TensorShape shape;
  auto* cc_ctx = reinterpret_cast<::tensorflow::OpKernelConstruction*>(ctx);
  ::tensorflow::Status s = cc_ctx->GetAttr(attr_name, &shape);
  ::tensorflow::Set_TF_Status_from_Status(status, s);

          kEmbeddingPipelining, "_xla_outside_compilation", "device"};
      for (const auto& attr_name : attr_names) {
        if (!global_iter_id_op->hasAttr(attr_name)) continue;
        offset->setAttr(attr_name, global_iter_id_op->getAttr(attr_name));
        new_global_iter_id->setAttr(attr_name,
                                    global_iter_id_op->getAttr(attr_name));
      }
      // Make the next function to get inlined use a different offset.

  return *func;
}

std::vector<int> VectorAttr(OpKernelConstruction* ctx,
                            absl::string_view attr_name) {
  std::vector<int> vec;
  OP_REQUIRES_OK_RETURN(ctx, std::vector<int>(), ctx->GetAttr(attr_name, &vec));
  return vec;
}

bool MustCompileAttr(OpKernelConstruction* ctx) {
  bool must_compile;
  OP_REQUIRES_OK_RETURN(ctx, false,

  return std::nullopt;
}

// Returns true iff the attribute `attr_name` is attached to either the node or
// to it's callee.
static bool GetNodeOrFuncAttr(Node* node, FunctionLibraryDefinition* flib_def,
                              const char* attr_name) {
  bool out = false;
  bool attr_value;
  if (TryGetNodeAttr(node->attrs(), attr_name, &attr_value)) {
    out |= attr_value;
  }

    # Convolution ouside the while op is quantized.
    self.assertTrue(
        self._contains_op(
            output_graphdef,
            op_name='XlaConvV2',
            attr_name='RhsT',
            attr_val=attr_value_pb2.AttrValue(type=types_pb2.DT_INT8),
        )
    )
    # TODO: b/294783597 - [Converter][TF-Quantizer] Support quantization for the