if (!num_cores_per_replica_attr)
    return cluster.emitOpError(
        CreateMissingAttributeMsg(tensorflow::kNumCoresPerReplicaAttr));
  int num_cores_per_replica = num_cores_per_replica_attr.getInt();

  auto topology_attr = cluster->getAttrOfType<StringAttr>("topology");
  if (!topology_attr)
    return cluster.emitOpError(
        CreateMissingAttributeMsg(tensorflow::kTopologyAttr));

        base_dilations_vec, window_dilations_vec);
    if (!window) {
      op->emitOpError("failed to create window");
    }
    auto output_shape = InferWindowOutputShape(
        input_ty, window.value(),
        mlir::cast<ShapedType>(op.getInitValue().getType()).getElementType());

    if (!output_shape) {
      op->emitOpError("failed to infer output shape");
    }

  if (failed(tensorflow::GetDevicesFromOp(moduleOp, &devices)))
    return moduleOp.emitOpError() << "No available devices.";
  llvm::ArrayRef<tensorflow::DeviceNameUtils::ParsedName> device_names =
      devices.device_names();
  auto status_or_system_devices = GetTPUSystemDevices(device_names);
  if (!status_or_system_devices.ok())
    return moduleOp.emitOpError()
           << "error in fetching TPU_SYSTEM devices: "

        if (inst->getNumOperands() != inst->getNumResults()) {
          inst->emitOpError(
              "number of operands and results don't match, only canonical "
              "TFL While supported");
          return std::nullopt;
        }
        return BuildWhileOperator(whileOp, operands, results);
      }

      inst->emitOpError("is not a supported TFLite op");
      return std::nullopt;
    }

          "transformation pass";
      return allow_tensorlist_pass_through_
                 ? rewriter.notifyMatchFailure(op, error_info)
                 : op.emitOpError(error_info);
    }

    Value element_shape = adaptor.getOperands()[0];
    Type shape_dtype = getElementTypeOrSelf(element_shape.getType());
    // If the `element_shape` is a scalar, we try to acquire its shape by

        algorithm.getType().getRank()) {
      return op.emitOpError() << "algorithm must be a constant scalar";
    }
    auto alg = static_cast<tensorflow::Algorithm>(
        algorithm.getValues<IntegerAttr>()[0].getInt());
    auto xla_alg = TensorFlowRngAlgToXla(alg);
    if (!xla_alg) {
      return op.emitOpError() << "unknown algorithm";
    }