}

type Image struct {
	min, max Rect
}

//go:noinline
func NewImage() Image {
	return Image{}
}

func AddrOfTemp() {
	_ = NewImage().min
}

type TypeID int

func (t *TypeID) encodeType(x int) (tt TypeID, err error) {
	switch x {
	case 0:
		return t.encodeType(x * x)
	}
	return 0, nil
}

type stack []int

func (s *stack) push(x int) {
	*s = append(*s, x)
}

    TypeRegistryAdapter(TypeRegistry typeRegistry) {
        this.typeRegistry = requireNonNull(typeRegistry, "typeRegistry");
    }

    @Override
    public ArtifactType get(String typeId) {
        Type type = typeRegistry.require(typeId);
        if (type instanceof ArtifactType) {
            return (ArtifactType) type;
        }
        if (type != null) {
            return new DefaultType(
                    type.id(),

    "such as a random number generator.";

// TODO(b/282188914) remove the operations to skip once tests are fixed.
static const DenseSet<mlir::TypeID>* operations_to_skip =
    new DenseSet<mlir::TypeID>{mlir::TypeID::get<mhlo::EinsumOp>()};

class VerifyTFXLALegalization
    : public impl::VerifyTFXLALegalizationBase<VerifyTFXLALegalization> {
 public:

#include "tensorflow/compiler/mlir/tensorflow/ir/tpu_embedding_ops_registry.h"

#include <vector>

namespace mlir {
namespace TF {

const llvm::SmallDenseSet<mlir::TypeID>&
TPUEmbeddingOpsRegistry::GetOpsTypeIds() {
  return ops_type_ids_;
}

// static
TPUEmbeddingOpsRegistry& TPUEmbeddingOpsRegistry::Global() {
  static TPUEmbeddingOpsRegistry* registry = new TPUEmbeddingOpsRegistry;

           kCrossHardwareTransferFixedCost;
  }

  mlir::RewritePatternSet GetTransformations(
      MLIRContext* context) const override {
    return {context};
  }

  mlir::TypeID GetTypeId() const override {
    return mlir::TypeID::get<CpuHardware>();
  }

  bool IsOpSupported(mlir::Operation* op) const override {
    // All ops in TFL dialect are supported on CPU.
    if (op->getDialect() == nullptr) return false;

// TfrtDelegate Dialect
//===----------------------------------------------------------------------===//

RuntimeFallbackDialect::RuntimeFallbackDialect(MLIRContext *context)
    : Dialect(/*name=*/"tfd", context, TypeID::get<RuntimeFallbackDialect>()) {
  allowUnknownTypes();

  allowUnknownOperations();

  addOperations<
#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tfrt/runtime_fallback_ops.cc.inc"
      >();
}

#include "tensorflow/compiler/mlir/tfrt/ir/tfrt_fallback.h"

namespace tfrt {
namespace gpu {

GpuRuntimeDialect::GpuRuntimeDialect(MLIRContext *context)
    : Dialect(/*name=*/"gpurt", context, TypeID::get<GpuRuntimeDialect>()) {
  addOperations<
#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tfrt/ir/gpu_ops.cpp.inc"
      >();
}

}  // namespace gpu
}  // namespace tfrt

#include <utility>

#include "mlir/IR/MLIRContext.h"  // from @llvm-project
#include "mlir/IR/PatternMatch.h"  // from @llvm-project
#include "mlir/Support/LogicalResult.h"  // from @llvm-project
#include "mlir/Support/TypeID.h"  // from @llvm-project
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/quantization/stablehlo/passes/passes.h"
#include "xla/mlir_hlo/mhlo/transforms/rewriters.h"

namespace tensorflow {
namespace tf_mlrt_tpu {

TensorflowMlrtTpuDialect::TensorflowMlrtTpuDialect(mlir::MLIRContext *context)
    : mlir::Dialect(/*name=*/"tf_mlrt_tpu", context,
                    mlir::TypeID::get<TensorflowMlrtTpuDialect>()) {
  addOperations<
#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tfrt/ir/mlrt/tf_mlrt_tpu_ops.cpp.inc"
      >();
}

}  // namespace tf_mlrt_tpu

#include <utility>

#include "mlir/IR/PatternMatch.h"  // from @llvm-project
#include "mlir/Support/LogicalResult.h"  // from @llvm-project
#include "mlir/Support/TypeID.h"  // from @llvm-project
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"  // from @llvm-project
#include "stablehlo/dialect/StablehloOps.h"  // from @stablehlo  // IWYU pragma: keep