HasASIMD    bool // Advanced SIMD (always available)
	HasEVTSTRM  bool // Event stream support
	HasAES      bool // AES hardware implementation
	HasPMULL    bool // Polynomial multiplication instruction set
	HasSHA1     bool // SHA1 hardware implementation
	HasSHA2     bool // SHA2 hardware implementation
	HasCRC32    bool // CRC32 hardware implementation
	HasATOMICS  bool // Atomic memory operation instruction set

  absl::Status RunTacPasses(mlir::ModuleOp* module, bool debug_mode = false);

  // Create instances of all registered hardwares.
  std::vector<std::unique_ptr<tac::TargetHardware>> InstantiateBackends();

  std::unique_ptr<TacImporter> importer_;
  std::unique_ptr<TacExporter> exporter_;
  // Owned list of all target hardware backends.
  std::vector<std::unique_ptr<tac::TargetHardware>> backends_;

        !IsSupported(op, device_inference_type.hardware)) {
      found_unsupported = true;
    }
  });
  return !found_unsupported;
}

void AlternativeSubgraphPass::Optimize(func::FuncOp func,
                                       const std::string& hardware) {
  auto* ctx = &getContext();
  RewritePatternSet patterns = GetHardwareRewritePatterns(ctx, hardware);

	// reflect the CPU capabilities. Assume that every Android arm device
	// has the necessary floating point hardware available.
	if GOOS == "android" {
		return
	}
	if cpu.HWCap&_HWCAP_VFP == 0 && goarmsoftfp == 0 {
		print("runtime: this CPU has no floating point hardware, so it cannot run\n")
		print("a binary compiled for hard floating point. Recompile adding ,softfloat\n")
		print("to GOARM.\n")
		exit(1)

func checkS390xCPU() {
	// Check if the present z-system has the hardware capability to carryout
	// floating point operations. Check if hwcap reflects CPU capability for the
	// necessary floating point hardware (HasVX) availability.
	// Starting with Go1.19, z13 is the minimum machine level for running Go on LoZ
	if cpu.HWCap&_HWCAP_VX == 0 {
		print("runtime: This CPU has no floating point hardware, so this program cannot be run. \n")
		exit(1)
	}

//  2) Pick subgraphs
//    2.1) Populate the "dp table" for (subgraph, hardware).
//    2.2) Make decisions based on the populated dp table.
//    2.3) Rewire the whole graph based on the desicions.
//
namespace mlir {
namespace TFL {
namespace tac {
namespace {

// GrapView is used to hold the aggregated cost for the given hardware
// view.
struct GraphView {
  float total_cost;

  // large functions (and maybe other metadata as well).
}

const tac::TargetHardware* TacModule::GetTargetHardware(
    const std::string& hardware_name) const {
  for (auto& hardware : backends_) {
    if (GetHardwareName(hardware.get()) == hardware_name) return hardware.get();
  }
  return nullptr;
}

absl::Status TacModule::RunTacPasses(mlir::ModuleOp* module, bool debug_mode) {
  mlir::PassManager pm((*module)->getName(),

                                             const std::string& hardware) {
  auto* devce_hardware = GetTargetHardware(hardware);
  if (devce_hardware == nullptr) return {context};
  return devce_hardware->GetTransformations(context);
}

bool IsSupported(Operation* op, const std::string& hardware) {
  auto* devce_hardware = GetTargetHardware(hardware);
  if (devce_hardware == nullptr) return {};

import okhttp3.internal.SuppressSignatureCheck
import okhttp3.internal.platform.Platform

/**
 * Example of using a hardware key to perform client auth.
 * Prefer recent JDK builds, and results are temperamental to slight environment changes.
 * Different instructions and configuration may be required for other hardware devices.
 *
 * Using a yubikey device as a SSL key store.
 * https://lauri.võsandi.com/2017/03/yubikey-for-ssh-auth.html
 *

		print("runtime: this CPU has no floating point hardware, so it cannot run\n")
		print("a binary compiled for hard floating point. Recompile adding ,softfloat\n")
		print("to GOARM.\n")
		exit(1)
	}
	if goarm > 6 && cpu.HWCap&_HWCAP_VFPv3 == 0 && goarmsoftfp == 0 {
		print("runtime: this CPU has no VFPv3 floating point hardware, so it cannot run\n")