text: #include <stdlib.h>
  #include <stdbool.h>
  #include <string.h>
  #include "map.h"
  
  #ifdef __clang__
  __attribute__((no_sanitize("undefined")))
  #endif
  int hash_int(int key) {
      key = ~key + (key << 15);
      key = key ^ (key >> 12);
      key = key + (key << 2);
      key = key ^ (key >> 4);
      key = key * 2057;
      key = key ^ (key >> 16);
      return key;
  }
  
  int hash(int x, int y, int z) {
      x = hash_int(x);
      y = hash_int(y);
      z = hash_int(z);
      return x ^ y ^ z;
  }
  
  void map_alloc(Map *map, int dx, int dy, int dz, int mask) {
      map->dx = dx;
      map->dy = dy;
      map->dz = dz;
      map->mask = mask;
      map->size = 0;
      map->data = (MapEntry *)calloc(map->mask + 1, sizeof(MapEntry));
  }
  
  void map_free(Map *map) {
      free(map->data);
  }
  
  void map_copy(Map *dst, Map *src) {
      dst->dx = src->dx;
      dst->dy = src->dy;
      dst->dz = src->dz;
      dst->mask = src->mask;
      dst->size = src->size;
      dst->data = (MapEntry *)calloc(dst->mask + 1, sizeof(MapEntry));
      memcpy(dst->data, src->data, (dst->mask + 1) * sizeof(MapEntry));
  }
  
  bool map_set(Map *map, int x, int y, int z, int w) {
      unsigned int index = hash(x, y, z) & map->mask;
      x -= map->dx;
      y -= map->dy;
      z -= map->dz;
      MapEntry *entry = map->data + index;
      int overwrite = 0;
      while (!EMPTY_ENTRY(entry)) {
          if (entry->e.x == x && entry->e.y == y && entry->e.z == z) {
              overwrite = 1;
              break;
          }
          index = (index + 1) & map->mask;
          entry = map->data + index;
      }
      if (overwrite) {
          if (entry->e.w != w) {
              entry->e.w = w;
              return true;
          }
      }
      else if (w) {
          entry->e.x = x;
          entry->e.y = y;
          entry->e.z = z;
          entry->e.w = w;
          map->size++;
          if (map->size * 2 > map->mask) {
              map_grow(map);
          }
          return true;
      }
      return false;
  }
  
  int map_get(Map *map, int x, int y, int z) {
      unsigned int index = hash(x, y, z) & map->mask;
      x -= map->dx;
      y -= map->dy;
      z -= map->dz;
      if (x < 0 || x > 255) return 0;
      if (y < 0 || y > 255) return 0;
      if (z < 0 || z > 255) return 0;
      MapEntry *entry = map->data + index;
      while (!EMPTY_ENTRY(entry)) {
          if (entry->e.x == x && entry->e.y == y && entry->e.z == z) {
              return entry->e.w;
          }
          index = (index + 1) & map->mask;
          entry = map->data + index;
      }
      return 0;
  }
  
  void map_grow(Map *map) {
      Map new_map;
      new_map.dx = map->dx;
      new_map.dy = map->dy;
      new_map.dz = map->dz;
      new_map.mask = (map->mask << 1) | 1;
      new_map.size = 0;
      new_map.data = (MapEntry *)calloc(new_map.mask + 1, sizeof(MapEntry));
      MAP_FOR_EACH(map, ex, ey, ez, ew) {
          map_set(&new_map, ex, ey, ez, ew);
      } END_MAP_FOR_EACH;
      free(map->data);
      map->mask = new_map.mask;
      map->size = new_map.size;
      map->data = new_map.data;
  }
  