if len == 0 {
		return nil
	}
	end := int(off) + len
	return r.b[int(off):end:end]
}

func (r *Reader) uint64At(off uint32) uint64 {
	b := r.BytesAt(off, 8)
	return binary.LittleEndian.Uint64(b)
}

func (r *Reader) int64At(off uint32) int64 {
	return int64(r.uint64At(off))
}

func (r *Reader) uint32At(off uint32) uint32 {
	b := r.BytesAt(off, 4)
	return binary.LittleEndian.Uint32(b)
}

limitations under the License.
*/

package sets

// Int64 is a set of int64s, implemented via map[int64]struct{} for minimal memory consumption.
//
// Deprecated: use generic Set instead.
// new ways:
// s1 := Set[int64]{}
// s2 := New[int64]()
type Int64 map[int64]Empty

// NewInt64 creates a Int64 from a list of values.
func NewInt64(items ...int64) Int64 {
	return Int64(New[int64](items...))
}

  void* ext;  // reserved for future use
  uint64_t (*nanoseconds)(SP_Timer timer);
} SP_TimerFns;

#define SP_TIMER_FNS_STRUCT_SIZE TF_OFFSET_OF_END(SP_TimerFns, nanoseconds)

typedef struct SP_AllocatorStats {
  size_t struct_size;
  int64_t num_allocs;
  int64_t bytes_in_use;
  int64_t peak_bytes_in_use;
  int64_t largest_alloc_size;

  int8_t has_bytes_limit;
  int64_t bytes_limit;

  int64_t bytes_reserved;

	typ := &b.Func.Config.Types
	// match: (Mul64 x y)
	// result: (Int64Make (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Int64Lo x) (Int64Hi y)) (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Int64Hi x) (Int64Lo y)) (Select0 <typ.UInt32> (Mul32uhilo (Int64Lo x) (Int64Lo y))))) (Select1 <typ.UInt32> (Mul32uhilo (Int64Lo x) (Int64Lo y))))
	for {
		x := v_0
		y := v_1
		v.reset(OpInt64Make)
		v0 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)

  se_.device_memory_usage = [](const SP_Device* const device,
                               int64_t* const free,
                               int64_t* const total) -> TF_Bool {
    *free = 45;
    *total = 7;
    return true;
  };

  StreamExecutor* executor = GetExecutor(0);
  int64_t free = 0;
  int64_t total = 0;
  executor->DeviceMemoryUsage(&free, &total);
  ASSERT_EQ(free, 45);
  ASSERT_EQ(total, 7);

  if (!result.ok()) return result;

  return fingerprint_proto;
}

std::string Singleprint(uint64_t graph_def_program_hash,
                        uint64_t signature_def_hash,
                        uint64_t saved_object_graph_hash,
                        uint64_t checkpoint_hash) {
  return std::to_string(graph_def_program_hash) + "/" +
         std::to_string(signature_def_hash) + "/" +

	int64(2986830195847294191), // Int64()
	int64(8204908297817606218), // Int64()
	int64(8134976985547166651), // Int64()
	int64(2240328155279531677), // Int64()
	int64(7311121042813227358), // Int64()
	int64(5231057920893523323), // Int64()
	int64(4257872588489500903), // Int64()
	int64(158397175702351138),  // Int64()
	int64(1350674201389090105), // Int64()
	int64(6093522341581845358), // Int64()

	int64(0),                   // Int64N(1)

		(AndB
			(Eq32 (Int64Hi x) (Int64Hi y))
			(Leq32U (Int64Lo x) (Int64Lo y))))

(Less64 x y) =>
	(OrB
		(Less32 (Int64Hi x) (Int64Hi y))
		(AndB
			(Eq32 (Int64Hi x) (Int64Hi y))
			(Less32U (Int64Lo x) (Int64Lo y))))

(Leq64 x y) =>
	(OrB
		(Less32 (Int64Hi x) (Int64Hi y))
		(AndB
			(Eq32 (Int64Hi x) (Int64Hi y))

  std::unordered_map<uint64_t, std::pair<int64_t, int64_t>> hashcode_to_pos;
  // Buffer data should be exported only once.
  assert(!buffer_data_exported_);

  auto it = buffer_data_map_.begin();
  while (it != buffer_data_map_.end()) {
    std::string buffer = it->second;
    int64_t index = it->first;
    int64_t offset = result.size();
    int64_t size = buffer.size();

      pass_to_dump_file_before_map_;
  llvm::DenseMap<mlir::Pass*, std::unique_ptr<llvm::raw_ostream>>
      pass_to_dump_file_after_map_;
  llvm::DenseMap<mlir::Pass*, int64_t> pass_to_number_map_;

  // Get the unique number for each pass.
  int64_t GetPassNumber(mlir::Pass* pass) {
    if (!pass_to_number_map_.contains(pass)) {
      pass_to_number_map_[pass] = mlir_pass_count_++;
    }
    return pass_to_number_map_[pass];