if (!llvm::equal(partition_dims, op_partition_dims)) {
      return partitioned_input->emitOpError()
             << "expects partition_dims = " << partition_dims << " but found "
             << op_partition_dims;
    } else if (partitioned_input.getIsPacked() !=
               first_partitioned_input.getIsPacked()) {
      return partitioned_input->emitOpError()
             << "packing should match across ops";

      return emitOpError("layerStats must have a floating point element type");
    }
    if (layerStatsType.getRank() != 1 || layerStatsType.getDimSize(0) != 2) {
      return emitOpError("layerStats must have shape [2]");
    }
  }
  // Verify axisStats (optional) attribute.
  if (getAxisStats()) {
    if (!getAxis()) return emitOpError("axis must be specified for axisStats");

      return emitOpError("layerStats must have a floating point element type");
    }
    if (layerStatsType.getRank() != 1 || layerStatsType.getDimSize(0) != 2) {
      return emitOpError("layerStats must have shape [2]");
    }
  }
  // Verify axisStats (optional) attribute.
  if (getAxisStats()) {
    if (!getAxis()) return emitOpError("axis must be specified for axisStats");

  }

  auto config = GetTfBackendConfig(op);
  if (config == nullptr) {
    op.emitOpError() << "does not have dictionary attribute '"
                     << kTfBackendConfigAttrName << "'";
    return failure();
  }

  auto f = config.get(kCalledFuncAttrName);
  if (f == nullptr) {
    op.emitOpError() << "does not have attribute '" << kCalledFuncAttrName
                     << "' in its dictionary attribute '"

  if (func != nullptr && func->hasAttr("tfrt_ifrt_serving.program_id")) {
    return emitOpError() << "cannot be nested inside an IFRT program";
  }

  for (mlir::Value arg : getArgs()) {
    if (mlir::isa<mlir::TF::ResourceType>(
            mlir::getElementTypeOrSelf(arg.getType()))) {
      return emitOpError()
             << "does not support passing '!tf.resource' values as arguments";
    }
  }

  if (!llvm::all_of(interface.GetLayoutDependentArgs(), valid_operand)) {
    return op->emitOpError("layout dependent argument index is out of bound");
  }

  auto valid_result = [&](int64_t idx) { return idx < op->getNumResults(); };
  if (!llvm::all_of(interface.GetLayoutDependentResults(), valid_result)) {
    return op->emitOpError("layout dependent result index is out of bound");
  }

  return success();
}

  if (!replicate_attr || !compile_attr)
    return op.emitOpError() << "is expected to have either both or none of '"
                            << kReplicationInfoAttr << "' and '"
                            << kCompileDeviceTypeAttr << "' attributes.";
  if (replicate_attr.getValue().empty())
    return op.emitOpError()
           << "has an empty '" << kReplicationInfoAttr << "' attribute.";

      // Invalid case since there are multiple loc:@ attributes.
      op->emitOpError()
          << "expects only one named location in '_class' attribute, but got "
          << classes_attr;
      return StringRef();
    }
    result = node_name.drop_front(kLocationPrefix.size());
  }
  if (result.empty()) {
    op->emitOpError() << "expects variable name in '_class' attribute, but got "

      /*target_tensor_names=*/{}, &resource_tensors);
  if (!status.ok()) {
    return module.emitOpError()
           << "failed to run the provided session: " << status.message();
  }

  const DeviceMgr* device_manager;
  if (!(session->LocalDeviceManager(&device_manager).ok())) {
    return module.emitOpError() << "failed to get local device manager";
  }

  // Read all underlying tensors of the variables from the session.

    if (!string_attr)
      return op->emitOpError(llvm::formatv(
          "bad '{0}' attribute at index {1}, not a string", kDevicesAttr, idx));

    if (DeviceNameUtils::ParseFullName(string_attr.getValue().str(), &device)) {
      devices->AddDevice(device);
    } else {
      return op->emitOpError(
          llvm::formatv("bad '{0}' attribute, '{1}', not a valid device",