}

func Set[T any](t TypeMap, v T) {
	interfaceType := reflect.TypeOf((*T)(nil)).Elem()
	t.inner[interfaceType] = v
}

func Get[T any](t TypeMap) *T {
	v, f := t.inner[reflect.TypeFor[T]()]
	if f {
		return ptr.Of(v.(T))
	}
	return nil

           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"
      >();
}

    patterns.add<LowerPackIntoConcatReshape, UnrollSplit, UnrollSplitV,
                  PadSlice>(context);
    return patterns;
  }

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

  // We can specify what ops are not supported here.
  bool IsNotSupportedOp(mlir::Operation* op) const override { return false; }

#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

	return valueTypeDecoder
}

func (p *ValueType) encode(b *buffer) {
	encodeInt64Opt(b, 1, p.typeX)
	encodeInt64Opt(b, 2, p.unitX)
}

var valueTypeDecoder = []decoder{
	nil, // 0
	// optional int64 type = 1
	func(b *buffer, m message) error { return decodeInt64(b, &m.(*ValueType).typeX) },
	// optional int64 unit = 2
	func(b *buffer, m message) error { return decodeInt64(b, &m.(*ValueType).unitX) },
}

	return
}

var (
	bitStringType        = reflect.TypeFor[BitString]()
	objectIdentifierType = reflect.TypeFor[ObjectIdentifier]()
	enumeratedType       = reflect.TypeFor[Enumerated]()
	flagType             = reflect.TypeFor[Flag]()
	timeType             = reflect.TypeFor[time.Time]()
	rawValueType         = reflect.TypeFor[RawValue]()
	rawContentsType      = reflect.TypeFor[RawContent]()
	bigIntType           = reflect.TypeFor[*big.Int]()

#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

#include "mlir/Support/LLVM.h"  // from @llvm-project

namespace tfrt {
namespace fallback {

FallbackDialect::FallbackDialect(MLIRContext *context)
    : Dialect(/*name=*/"tfrt_fallback", context,
              TypeID::get<FallbackDialect>()) {
  addTypes<TFTensorType, TFAllocatorType>();

  addOperations<
#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tfrt/ir/tfrt_fallback.cpp.inc"
      >();
}

namespace tfrt {
namespace fallback_sync {

FallbackSyncDialect::FallbackSyncDialect(MLIRContext *context)
    : Dialect(/*name=*/"tfrt_fallback_sync", context,
              TypeID::get<FallbackSyncDialect>()) {
  context->getOrLoadDialect<tfrt::fallback::FallbackDialect>();
  context->getOrLoadDialect<compiler::TFRTDialect>();
  context->getOrLoadDialect<corert::CoreRTDialect>();