class="kw">package com.hypixel.hytale.server.core.prefab.selection.buffer.impl;

class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.math.vector.Vector3iUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.RotationTuple;
class="kw">import com.hypixel.hytale.server.core.modules.prefabspawner.PrefabSpawnerBlock;
class="kw">import com.hypixel.hytale.server.core.prefab.PrefabRotation;
class="kw">import com.hypixel.hytale.server.core.prefab.PrefabWeights;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.buffer.PrefabBufferCall;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.util.io.MemorySegmentUtil;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.ints.IntIterator;
class="kw">import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap.Entry;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import java.lang.foreign.MemorySegment;
class="kw">import java.lang.foreign.ValueLayout;
class="kw">import java.util.List;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3i;

class="kw">public class PrefabBuffer {
   class="kw">public class="kw">static class="kw">final float DEFAULT_CHANCE = 1.0F;
   @Nonnull
   class="kw">private class="kw">final Vector3i anchor;
   @Nonnull
   class="kw">private class="kw">final Vector3i min;
   @Nonnull
   class="kw">private class="kw">final Vector3i max;
   @Nonnull
   class="kw">private class="kw">final Int2ObjectMap<PrefabBufferColumn> columns;
   @Nonnull
   class="kw">private class="kw">final PrefabBuffer.ChildPrefab[] childPrefabs;

   class="kw">private PrefabBuffer(
      @Nonnull Vector3i var1,
      @Nonnull Vector3i var2,
      @Nonnull Vector3i var3,
      @Nonnull Int2ObjectMap<PrefabBufferColumn> var4,
      @Nonnull PrefabBuffer.ChildPrefab[] var5
   ) {
      this.anchor = var1;
      this.min = var2;
      this.max = var3;
      this.columns = var4;
      this.childPrefabs = var5;
   }

   @Nonnull
   class="kw">public class="kw">static PrefabBuffer.Builder newBuilder() {
      class="kw">return new PrefabBuffer.Builder();
   }

   class="kw">public int getAnchorX() {
      class="kw">return this.anchor.x();
   }

   class="kw">public int getAnchorY() {
      class="kw">return this.anchor.y();
   }

   class="kw">public int getAnchorZ() {
      class="kw">return this.anchor.z();
   }

   @Nonnull
   class="kw">public PrefabBuffer.PrefabBufferAccessor newAccess() {
      class="kw">return new PrefabBuffer.PrefabBufferAccessor(this);
   }

   class="kw">public class="kw">interface BlockMaskConstants {
      int ID_IS_BYTE = 1;
      int ID_IS_SHORT = 2;
      int ID_IS_INT = 3;
      int ID_MASK = 3;
      int HAS_CHANCE = 4;
      int OFFSET_IS_BYTE = 8;
      int OFFSET_IS_SHORT = 16;
      int OFFSET_IS_INT = 24;
      int OFFSET_MASK = 24;
      int HAS_COMPONENTS = 32;
      int FLUID_IS_BYTE = 64;
      int FLUID_IS_SHORT = 128;
      int FLUID_IS_INT = 192;
      int FLUID_MASK = 192;
      int SUPPORT_MASK = 3840;
      int SUPPORT_OFFSET = 8;
      int HAS_FILLER = 4096;
      int HAS_ROTATION = 8192;

      class="kw">static int getBlockMask(int var0, int var1, boolean var2, int var3, @Nullable Holder<ChunkStore> var4, byte var5, int var6, int var7) {
         int var8 = 0;

         var8 = class="kw">switch (var0) {
            case 0 -> {
            }
            case 1 -> 1;
            case 2 -> 2;
            class="kw">default -> throw new IllegalArgumentException("Unsupported amount of bytes for blocks (0, 1, 2, 4). Given: " + var0);
            case 4 -> 3;
         };
         if (var2) {
            var8 |= 4;
         }
         var8 = class="kw">switch (var3) {
            case 0 -> {
            }
            case 1 -> 8;
            case 2 -> 16;
            class="kw">default -> throw new IllegalArgumentException("Unsupported amount of bytes for offset (0, 1, 2, 4). Given: " + var3);
            case 4 -> 24;
         };
         if (var4 != null) {
            var8 |= 32;
         }
         var8 = class="kw">switch (var1) {
            case 0 -> {
            }
            case 1 -> 64;
            case 2 -> 128;
            class="kw">default -> throw new IllegalArgumentException("Unsupported amount of bytes for fluids (0, 1, 2, 4). Given: " + var1);
            case 4 -> 192;
         } | var5 << 8 & 3840;
         if (var7 != 0) {
            var8 |= 4096;
         }

         if (var6 != 0) {
            var8 |= 8192;
         }

         class="kw">return var8;
      }

      class="kw">static int getSkipBytes(int var0) {
         int var1 = 0;
         var1 += getBlockBytes(var0);
         var1 += getOffsetBytes(var0);
         if (hasChance(var0)) {
            var1 += 4;
         }

         var1 += getFluidBytes(var0);
         if (hasFiller(var0)) {
            var1 += 2;
         }

         if (hasRotation(var0)) {
            var1++;
         }

         class="kw">return var1;
      }

      class="kw">static boolean hasChance(int var0) {
         class="kw">return (var0 & 4) == 4;
      }

      class="kw">static boolean hasFiller(int var0) {
         class="kw">return (var0 & 4096) == 4096;
      }

      class="kw">static boolean hasRotation(int var0) {
         class="kw">return (var0 & 8192) == 8192;
      }

      class="kw">static int getBlockBytes(int var0) {
         class="kw">return class="kw">switch (var0 & 3) {
            case 1 -> 1;
            case 2 -> 2;
            case 3 -> 4;
            class="kw">default -> 0;
         };
      }

      class="kw">static int getOffsetBytes(int var0) {
         class="kw">return class="kw">switch (var0 & 24) {
            case 8 -> 1;
            case 16 -> 2;
            case 24 -> 4;
            class="kw">default -> 0;
         };
      }

      class="kw">static int getFluidBytes(int var0) {
         class="kw">return class="kw">switch (var0 & 192) {
            case 64 -> 2;
            case 128 -> 3;
            case 192 -> 5;
            class="kw">default -> 0;
         };
      }

      class="kw">static int getSupportValue(int var0) {
         class="kw">return (var0 & 3840) >> 8;
      }

      class="kw">static boolean hasComponents(int var0) {
         class="kw">return (var0 & 32) == 32;
      }
   }

   class="kw">public class="kw">static class Builder {
      @Nonnull
      class="kw">private class="kw">final Vector3i min = new Vector3i(Vector3iUtil.MAX);
      @Nonnull
      class="kw">private class="kw">final Vector3i max = new Vector3i(Vector3iUtil.MIN);
      @Nonnull
      class="kw">private class="kw">final Int2ObjectMap<PrefabBuffer.BuilderColumn> builderColumns = new Int2ObjectOpenHashMap();
      @Nonnull
      class="kw">private class="kw">final List<PrefabBuffer.ChildPrefab> childPrefabs = new ObjectArrayList(0);
      class="kw">private Vector3i anchor = new Vector3i();
      class="kw">private int requiredMemory;

      class="kw">private Builder() {
      }

      class="kw">public void setAnchor(@Nonnull Vector3i var1) {
         this.anchor = var1;
      }

      class="kw">public void addColumn(int var1, int var2, @Nonnull PrefabBufferBlockEntry[] var3, @Nullable Holder<EntityStore>[] var4) {
         if (var1 < -32768) {
            throw new IllegalArgumentException("x is smaller than -32768. Given: " + var1);
         }

         if (var1 > 32767) {
            throw new IllegalArgumentException("x is larger than 32767. Given: " + var1);
         }

         if (var2 < -32768) {
            throw new IllegalArgumentException("z is smaller than -32768. Given: " + var2);
         }

         if (var2 > 32767) {
            throw new IllegalArgumentException("z is larger than 32767. Given: " + var2);
         }

         if (var3.length != 0 || var4 != null && var4.length != 0) {
            int var5 = MathUtil.packInt(var1, var2);
            if (this.builderColumns.put(var5, new PrefabBuffer.BuilderColumn(var1, var2, var3, var4)) != null) {
               throw new IllegalArgumentException("Duplicate column");
            }

            int var6 = 4;
            int var7 = Integer.MIN_VALUE;

            for (int var8 = 0; var8 < var3.length; var8++) {
               PrefabBufferBlockEntry var9 = var3[var8];
               int var10 = var9.y;
               int var11 = var9.blockId;
               float var12 = var9.chance;
               Holder var13 = var9.state;
               int var14 = var9.fluidId;
               if (var10 <= var7) {
                  throw new IllegalArgumentException("Y Values are not sequential. " + var7 + " -> " + var10);
               }

               int var15 = var8 == 0 ? 0 : var10 - var7;
               if (var15 > 65535) {
                  throw new IllegalArgumentException("Offset is larger than 65535. Given: " + var15);
               }

               boolean var16 = var12 < 1.0F;
               int var17 = MathUtil.byteCount(var11);
               int var18 = var15 == 1 ? 0 : MathUtil.byteCount(var15);
               int var19 = MathUtil.byteCount(var14);
               int var20 = PrefabBuffer.BlockMaskConstants.getBlockMask(var17, var19, var16, var18, var13, var9.supportValue, var9.rotation, var9.filler);
               var6 += 2 + PrefabBuffer.BlockMaskConstants.getSkipBytes(var20);
               var7 = var10;
            }

            this.requiredMemory += var6;
         }
      }

      class="kw">private void handleBlockComponents(int var1, int var2, int var3, int var4, @Nonnull Holder<ChunkStore> var5) {
         ComponentType var6 = PrefabSpawnerBlock.getComponentType();
         PrefabSpawnerBlock var7 = var5.getComponent(var6);
         if (var7 != null) {
            String var8 = var7.getPrefabPath();
            if (var8 == null) {
               HytaleLogger.getLogger().at(Level.WARNING).log("Prefab spawner at %d, %d, %d is missing prefab path!", var2, var3, var4);
            } else {
               PrefabWeights var9 = var7.getPrefabWeights();
               PrefabRotation var10 = PrefabRotation.fromRotation(RotationTuple.get(var1).yaw());
               this.addChildPrefab(var2, var3, var4, var8, var7.isFitHeightmap(), var7.isInheritSeed(), var7.isInheritHeightCondition(), var9, var10);
            }
         }
      }

      class="kw">public void addChildPrefab(
         int var1,
         int var2,
         int var3,
         @Nonnull String var4,
         boolean var5,
         boolean var6,
         boolean var7,
         @Nullable PrefabWeights var8,
         @Nonnull PrefabRotation var9
      ) {
         this.childPrefabs.add(new PrefabBuffer.ChildPrefab(var1, var2, var3, var4, var5, var6, var7, var8, var9));
      }

      @Nonnull
      class="kw">public PrefabBufferBlockEntry newBlockEntry(int var1) {
         class="kw">return new PrefabBufferBlockEntry(var1);
      }

      class="kw">private int buildColumn(Int2ObjectMap<PrefabBufferColumn> var1, PrefabBuffer.BuilderColumn var2, MemorySegment var3, int var4) {
         PrefabBufferBlockEntry[] var5 = var2.entries;
         int var6 = var5.length;
         Int2ObjectOpenHashMap var7 = new Int2ObjectOpenHashMap();
         if (var6 != 0 || var2.entityHolders != null && var2.entityHolders.length != 0) {
            int var26 = var4;
            if (var6 > 0) {
               int var9 = var5[0].y;
               if (var9 < this.min.y) {
                  this.min.y = var9;
               }

               var3.set(ValueLayout.JAVA_INT_UNALIGNED, var26, var9 - 1);
               var26 += 4;
               var9 = Integer.MIN_VALUE;

               for (int var10 = 0; var10 < var6; var10++) {
                  PrefabBufferBlockEntry var11 = var5[var10];
                  int var12 = var11.y;
                  int var13 = var11.blockId;
                  float var14 = var11.chance;
                  Holder var15 = var11.state;
                  int var16 = var11.fluidId;
                  byte var17 = var11.fluidLevel;
                  int var18 = var10 == 0 ? 0 : var12 - var9;
                  boolean var19 = var14 < 1.0F;
                  int var20 = MathUtil.byteCount(var13);
                  int var21 = var18 == 1 ? 0 : MathUtil.byteCount(var18);
                  int var22 = MathUtil.byteCount(var16);
                  int var23 = PrefabBuffer.BlockMaskConstants.getBlockMask(var20, var22, var19, var21, var15, var11.supportValue, var11.rotation, var11.filler);
                  var3.set(ValueLayout.JAVA_SHORT_UNALIGNED, var26, (short)var23);
                  var26 += 2;
                  MemorySegmentUtil.writeNumber(var3, var26, var20, var13);
                  var26 += var20;
                  MemorySegmentUtil.writeNumber(var3, var26, var21, var18);
                  var26 += var21;
                  if (var19) {
                     var3.set(ValueLayout.JAVA_FLOAT_UNALIGNED, var26, var14);
                     var26 += 4;
                  }

                  if (var11.rotation != 0) {
                     var3.set(ValueLayout.JAVA_BYTE, var26, (byte)var11.rotation);
                     var26++;
                  }

                  if (var11.filler != 0) {
                     var3.set(ValueLayout.JAVA_SHORT_UNALIGNED, var26, (short)var11.filler);
                     var26 += 2;
                  }

                  if (var16 != 0) {
                     MemorySegmentUtil.writeNumber(var3, var26, var22, var16);
                     var26 += var22;
                     var3.set(ValueLayout.JAVA_BYTE, var26, var17);
                     var26++;
                  }

                  if (var15 != null) {
                     var7.put(var12, var15);
                     this.handleBlockComponents(var11.rotation, var2.x, var12, var2.z, var15);
                  }

                  var9 = var12;
               }

               if (var9 > this.max.y) {
                  this.max.y = var9;
               }
            }

            if (var2.x < this.min.x) {
               this.min.x = var2.x;
            }

            if (var2.x > this.max.x) {
               this.max.x = var2.x;
            }

            if (var2.z < this.min.z) {
               this.min.z = var2.z;
            }

            if (var2.z > this.max.z) {
               this.max.z = var2.z;
            }

            if (var7.isEmpty()) {
               var7 = null;
            }

            int var28 = var26 - var4;
            PrefabBufferColumn var29 = new PrefabBufferColumn(var6, var3.asSlice(var4, var28), var2.entityHolders, var7);
            var1.put(MathUtil.packInt(var2.x, var2.z), var29);
            class="kw">return var28;
         } else {
            class="kw">return 0;
         }
      }

      @Nonnull
      class="kw">public PrefabBuffer build() {
         Int2ObjectOpenHashMap var1 = new Int2ObjectOpenHashMap();
         MemorySegment var2 = MemorySegment.ofArray(new byte[this.requiredMemory]);
         int var3 = 0;
         ObjectIterator var4 = this.builderColumns.values().iterator();

         while (var4.hasNext()) {
            PrefabBuffer.BuilderColumn var5 = (PrefabBuffer.BuilderColumn)var4.next();
            var3 += this.buildColumn(var1, var5, var2, var3);
         }

         PrefabBuffer.ChildPrefab[] var6 = this.childPrefabs.toArray(PrefabBuffer.ChildPrefab[]::new);
         if (this.builderColumns.isEmpty()) {
            this.min.zero();
            this.max.zero();
         }

         class="kw">return new PrefabBuffer(this.anchor, this.min, this.max, var1, var6);
      }
   }

   class="kw">private record BuilderColumn(int x, int z, @Nonnull PrefabBufferBlockEntry[] entries, @Nullable Holder<EntityStore>[] entityHolders) {
      class="kw">private BuilderColumn {
      }
   }

   class="kw">public class="kw">static class ChildPrefab {
      class="kw">private class="kw">final int x;
      class="kw">private class="kw">final int y;
      class="kw">private class="kw">final int z;
      @Nonnull
      class="kw">private class="kw">final String path;
      class="kw">private class="kw">final boolean fitHeightmap;
      class="kw">private class="kw">final boolean inheritSeed;
      class="kw">private class="kw">final boolean inheritHeightCondition;
      @Nonnull
      class="kw">private class="kw">final PrefabWeights weights;
      @Nonnull
      class="kw">private class="kw">final PrefabRotation rotation;

      class="kw">private ChildPrefab(
         int var1,
         int var2,
         int var3,
         @Nonnull String var4,
         boolean var5,
         boolean var6,
         boolean var7,
         @Nonnull PrefabWeights var8,
         @Nonnull PrefabRotation var9
      ) {
         this.x = var1;
         this.y = var2;
         this.z = var3;
         this.path = var4;
         this.fitHeightmap = var5;
         this.inheritSeed = var6;
         this.inheritHeightCondition = var7;
         this.weights = var8;
         this.rotation = var9;
      }

      class="kw">public int getX() {
         class="kw">return this.x;
      }

      class="kw">public int getY() {
         class="kw">return this.y;
      }

      class="kw">public int getZ() {
         class="kw">return this.z;
      }

      @Nonnull
      class="kw">public String getPath() {
         class="kw">return this.path;
      }

      class="kw">public boolean isFitHeightmap() {
         class="kw">return this.fitHeightmap;
      }

      class="kw">public boolean isInheritSeed() {
         class="kw">return this.inheritSeed;
      }

      class="kw">public boolean isInheritHeightCondition() {
         class="kw">return this.inheritHeightCondition;
      }

      @Nonnull
      class="kw">public PrefabWeights getWeights() {
         class="kw">return this.weights;
      }

      @Nonnull
      class="kw">public PrefabRotation getRotation() {
         class="kw">return this.rotation;
      }
   }

   class="kw">public class="kw">static class PrefabBufferAccessor class="kw">implements IPrefabBuffer {
      @Nonnull
      class="kw">private class="kw">final PrefabBuffer prefabBuffer;

      class="kw">private PrefabBufferAccessor(@Nonnull PrefabBuffer var1) {
         this.prefabBuffer = var1;
      }

      @Override
      class="kw">public int getAnchorX() {
         class="kw">return this.prefabBuffer.getAnchorX();
      }

      @Override
      class="kw">public int getAnchorY() {
         class="kw">return this.prefabBuffer.getAnchorY();
      }

      @Override
      class="kw">public int getAnchorZ() {
         class="kw">return this.prefabBuffer.getAnchorZ();
      }

      @Override
      class="kw">public int getMinX(@Nonnull PrefabRotation var1) {
         class="kw">return Math.min(var1.getX(this.prefabBuffer.min.x(), this.prefabBuffer.min.z()), var1.getX(this.prefabBuffer.max.x(), this.prefabBuffer.max.z()));
      }

      @Override
      class="kw">public int getMinY() {
         class="kw">return this.prefabBuffer.min.y();
      }

      @Override
      class="kw">public int getMinZ(@Nonnull PrefabRotation var1) {
         class="kw">return Math.min(var1.getZ(this.prefabBuffer.min.x(), this.prefabBuffer.min.z()), var1.getZ(this.prefabBuffer.max.x(), this.prefabBuffer.max.z()));
      }

      @Override
      class="kw">public int getMaxX(@Nonnull PrefabRotation var1) {
         class="kw">return Math.max(var1.getX(this.prefabBuffer.min.x(), this.prefabBuffer.min.z()), var1.getX(this.prefabBuffer.max.x(), this.prefabBuffer.max.z()));
      }

      @Override
      class="kw">public int getMaxY() {
         class="kw">return this.prefabBuffer.max.y();
      }

      @Override
      class="kw">public int getMaxZ(@Nonnull PrefabRotation var1) {
         class="kw">return Math.max(var1.getZ(this.prefabBuffer.min.x(), this.prefabBuffer.min.z()), var1.getZ(this.prefabBuffer.max.x(), this.prefabBuffer.max.z()));
      }

      @Override
      class="kw">public int getColumnCount() {
         class="kw">return this.prefabBuffer.columns.size();
      }

      @Nonnull
      @Override
      class="kw">public PrefabBuffer.ChildPrefab[] getChildPrefabs() {
         class="kw">return this.prefabBuffer.childPrefabs;
      }

      @Override
      class="kw">public int getMinYAt(@Nonnull PrefabRotation var1, int var2, int var3) {
         int var4 = var1.getX(var2, var3);
         int var5 = var1.getZ(var2, var3);
         int var6 = MathUtil.packInt(var4, var5);
         PrefabBufferColumn var7 = (PrefabBufferColumn)this.prefabBuffer.columns.get(var6);
         class="kw">return var7 != null && var7.getBlockCount() > 0 ? var7.getMemorySegment().get(ValueLayout.JAVA_INT_UNALIGNED, 0L) + 1 : -1;
      }

      @Override
      class="kw">public int getMaxYAt(@Nonnull PrefabRotation var1, int var2, int var3) {
         int var4 = var1.getX(var2, var3);
         int var5 = var1.getZ(var2, var3);
         int var6 = MathUtil.packInt(var4, var5);
         PrefabBufferColumn var7 = (PrefabBufferColumn)this.prefabBuffer.columns.get(var6);
         if (var7 == null) {
            class="kw">return -1;
         }

         if (var7.getBlockCount() > 0) {
            int var8 = 0;
            MemorySegment var9 = var7.getMemorySegment();
            int var10 = var9.get(ValueLayout.JAVA_INT_UNALIGNED, var8);
            var8 += 4;

            for (int var11 = 0; var11 < var7.getBlockCount(); var11++) {
               int var12 = Short.toUnsignedInt(var9.get(ValueLayout.JAVA_SHORT_UNALIGNED, var8));
               var8 += 2;
               if (PrefabBuffer.BlockMaskConstants.getOffsetBytes(var12) > 0) {
                  var8 += PrefabBuffer.BlockMaskConstants.getBlockBytes(var12);
                  int var13 = PrefabBuffer.BlockMaskConstants.getOffsetBytes(var12);
                  var10 += MemorySegmentUtil.readNumber(var9, var8, var13);
                  var8 += var13;
                  if (PrefabBuffer.BlockMaskConstants.hasChance(var12)) {
                     var8 += 4;
                  }

                  if (PrefabBuffer.BlockMaskConstants.hasRotation(var12)) {
                     var8++;
                  }

                  if (PrefabBuffer.BlockMaskConstants.hasFiller(var12)) {
                     var8 += 2;
                  }

                  var8 += PrefabBuffer.BlockMaskConstants.getFluidBytes(var12);
               } else {
                  var8 += PrefabBuffer.BlockMaskConstants.getSkipBytes(var12);
                  var10++;
               }
            }

            class="kw">return var10;
         } else {
            class="kw">return -1;
         }
      }

      @Override
      class="kw">public <T class="kw">extends PrefabBufferCall> void forEach(
         @Nonnull IPrefabBuffer.ColumnPredicate<T> var1,
         @Nonnull IPrefabBuffer.BlockConsumer<T> var2,
         @Nullable IPrefabBuffer.EntityConsumer<T> var3,
         @Nullable IPrefabBuffer.ChildConsumer<T> var4,
         @Nonnull T var5
      ) {
         this.prefabBuffer.columns.int2ObjectEntrySet().forEach(var4x -> {
            int var5 = var4x.getIntKey();
            int var6 = MathUtil.unpackLeft(var5);
            int var7 = MathUtil.unpackRight(var5);
            int var8 = var5.rotation.getX(var6, var7);
            int var9 = var5.rotation.getZ(var6, var7);
            PrefabBufferColumn var10 = (PrefabBufferColumn)var4x.getValue();
            MemorySegment var11 = var10.getMemorySegment();
            int var12 = var10.getBlockCount();
            if (var1.test(var8, var9, var12, var5)) {
               if (var12 > 0) {
                  int var13 = 0;
                  int var14 = var11.get(ValueLayout.JAVA_INT_UNALIGNED, var13);
                  var13 += 4;

                  for (int var15 = 0; var15 < var12; var15++) {
                     int var16 = Short.toUnsignedInt(var11.get(ValueLayout.JAVA_SHORT_UNALIGNED, var13));
                     var13 += 2;
                     int var17 = PrefabBuffer.BlockMaskConstants.getBlockBytes(var16);
                     int var18 = MemorySegmentUtil.readNumber(var11, var13, var17);
                     var13 += var17;
                     int var19 = PrefabBuffer.BlockMaskConstants.getOffsetBytes(var16);
                     var14 += var19 == 0 ? 1 : MemorySegmentUtil.readNumber(var11, var13, var19);
                     var13 += var19;
                     if (PrefabBuffer.BlockMaskConstants.hasChance(var16)) {
                        float var20 = var11.get(ValueLayout.JAVA_FLOAT_UNALIGNED, var13);
                        var13 += 4;
                        if (var20 < var5.random.nextFloat()) {
                           var13 += 2;
                           var13 += PrefabBuffer.BlockMaskConstants.getFluidBytes(var16);
                           class="kw">continue;
                        }
                     }

                     Holder var33 = PrefabBuffer.BlockMaskConstants.hasComponents(var16) ? (Holder)var10.getBlockComponents().get(var14) : null;
                     int var21 = PrefabBuffer.BlockMaskConstants.getSupportValue(var16);
                     int var22 = 0;
                     if (PrefabBuffer.BlockMaskConstants.hasRotation(var16)) {
                        var22 = Byte.toUnsignedInt(var11.get(ValueLayout.JAVA_BYTE, var13));
                        var13++;
                     }

                     var22 = var5.rotation.getRotation(var22);
                     int var23 = 0;
                     if (PrefabBuffer.BlockMaskConstants.hasFiller(var16)) {
                        var23 = var5.rotation.getFiller(Short.toUnsignedInt(var11.get(ValueLayout.JAVA_SHORT_UNALIGNED, var13)));
                        var13 += 2;
                     }

                     int var24 = PrefabBuffer.BlockMaskConstants.getFluidBytes(var16);
                     int var25 = 0;
                     int var26 = 0;
                     if (var24 != 0) {
                        var25 = MemorySegmentUtil.readNumber(var11, var13, var24 - 1);
                        var13 += var24 - 1;
                        var26 = var11.get(ValueLayout.JAVA_BYTE, var13);
                        var13++;
                     }

                     var2.accept(var8, var14, var9, var18, var33, var21, var22, var23, var5, var25, var26);
                  }
               }

               Holder[] var32 = var10.getEntityHolders();
               if (var32 != null && var3 != null) {
                  var3.accept(var8, var9, var32, var5);
               }
            }
         });
         if (this.prefabBuffer.childPrefabs != null && var4 != null) {
            for (PrefabBuffer.ChildPrefab var9 : this.prefabBuffer.childPrefabs) {
               int var10 = var5.rotation.getX(var9.x, var9.z);
               int var11 = var5.rotation.getZ(var9.x, var9.z);
               var4.accept(var10, var9.y, var11, var9.path, var9.fitHeightmap, var9.inheritSeed, var9.inheritHeightCondition, var9.weights, var9.rotation, var5);
            }
         }
      }

      @Override
      class="kw">public <T> void forEachEntity(@Nonnull IPrefabBuffer.EntityConsumer<T> var1, @Nullable T var2) {
         this.prefabBuffer.columns.int2ObjectEntrySet().forEach(var2x -> {
            int var3 = var2x.getIntKey();
            int var4 = MathUtil.unpackLeft(var3);
            int var5 = MathUtil.unpackRight(var3);
            PrefabBufferColumn var6 = (PrefabBufferColumn)var2x.getValue();
            Holder[] var7 = var6.getEntityHolders();
            if (var1 != null) {
               var1.accept(var4, var5, var7, var2);
            }
         });
      }

      @Override
      class="kw">public <T> void forEachRaw(
         @Nonnull IPrefabBuffer.ColumnPredicate<T> var1,
         @Nonnull IPrefabBuffer.RawBlockConsumer<T> var2,
         @Nonnull IPrefabBuffer.FluidConsumer<T> var3,
         @Nullable IPrefabBuffer.EntityConsumer<T> var4,
         @Nullable T var5
      ) {
         this.prefabBuffer.columns.int2ObjectEntrySet().forEach(var5x -> {
            int var6 = var5x.getIntKey();
            int var7 = MathUtil.unpackLeft(var6);
            int var8 = MathUtil.unpackRight(var6);
            PrefabBufferColumn var9 = (PrefabBufferColumn)var5x.getValue();
            MemorySegment var10 = var9.getMemorySegment();
            int var11 = var9.getBlockCount();
            if (var1.test(var7, var8, var11, var5)) {
               if (var11 > 0) {
                  int var12 = 0;
                  int var13 = var10.get(ValueLayout.JAVA_INT_UNALIGNED, var12);
                  var12 += 4;

                  for (int var14 = 0; var14 < var11; var14++) {
                     int var15 = Short.toUnsignedInt(var10.get(ValueLayout.JAVA_SHORT_UNALIGNED, var12));
                     var12 += 2;
                     int var16 = PrefabBuffer.BlockMaskConstants.getBlockBytes(var15);
                     int var17 = MemorySegmentUtil.readNumber(var10, var12, var16);
                     var12 += var16;
                     int var18 = PrefabBuffer.BlockMaskConstants.getOffsetBytes(var15);
                     var13 += var18 == 0 ? 1 : MemorySegmentUtil.readNumber(var10, var12, var18);
                     var12 += var18;
                     float var19 = 1.0F;
                     if (PrefabBuffer.BlockMaskConstants.hasChance(var15)) {
                        var19 = var10.get(ValueLayout.JAVA_FLOAT_UNALIGNED, var12);
                        var12 += 4;
                     }

                     Holder var20 = PrefabBuffer.BlockMaskConstants.hasComponents(var15) ? (Holder)var9.getBlockComponents().get(var13) : null;
                     int var21 = PrefabBuffer.BlockMaskConstants.getSupportValue(var15);
                     int var22 = 0;
                     if (PrefabBuffer.BlockMaskConstants.hasRotation(var15)) {
                        var22 = Byte.toUnsignedInt(var10.get(ValueLayout.JAVA_BYTE, var12));
                        var12++;
                     }

                     int var23 = 0;
                     if (PrefabBuffer.BlockMaskConstants.hasFiller(var15)) {
                        var23 = Short.toUnsignedInt(var10.get(ValueLayout.JAVA_SHORT_UNALIGNED, var12));
                        var12 += 2;
                     }

                     var2.accept(var7, var13, var8, var15, var17, var19, var20, var21, var22, var23, var5);
                     int var24 = PrefabBuffer.BlockMaskConstants.getFluidBytes(var15);
                     if (var24 != 0) {
                        int var25 = MemorySegmentUtil.readNumber(var10, var12, var24 - 1);
                        var12 += var24 - 1;
                        byte var26 = var10.get(ValueLayout.JAVA_BYTE, var12);
                        var12++;
                        var3.accept(var7, var13, var8, var25, var26, var5);
                     }
                  }
               }

               Holder[] var31 = var9.getEntityHolders();
               if (var4 != null) {
                  var4.accept(var7, var8, var31, var5);
               }
            }
         });
      }

      @Override
      class="kw">public <T> boolean forEachRaw(
         @Nonnull IPrefabBuffer.ColumnPredicate<T> var1,
         @Nonnull IPrefabBuffer.RawBlockPredicate<T> var2,
         @Nonnull IPrefabBuffer.FluidPredicate<T> var3,
         @Nullable IPrefabBuffer.EntityPredicate<T> var4,
         @Nullable T var5
      ) {
         ObjectIterator var6 = this.prefabBuffer.columns.int2ObjectEntrySet().iterator();

         while (var6.hasNext()) {
            Entry var7 = (Entry<PrefabBufferColumn>)var6.next();
            int var8 = var7.getIntKey();
            int var9 = MathUtil.unpackLeft(var8);
            int var10 = MathUtil.unpackRight(var8);
            PrefabBufferColumn var11 = (PrefabBufferColumn)var7.getValue();
            MemorySegment var12 = var11.getMemorySegment();
            int var13 = var11.getBlockCount();
            if (!var1.test(var9, var10, var13, var5)) {
               class="kw">return false;
            }

            if (var13 > 0) {
               int var14 = 0;
               int var15 = var12.get(ValueLayout.JAVA_INT_UNALIGNED, var14);
               var14 += 4;

               for (int var16 = 0; var16 < var13; var16++) {
                  int var17 = Short.toUnsignedInt(var12.get(ValueLayout.JAVA_SHORT_UNALIGNED, var14));
                  var14 += 2;
                  int var18 = PrefabBuffer.BlockMaskConstants.getBlockBytes(var17);
                  int var19 = MemorySegmentUtil.readNumber(var12, var14, var18);
                  var14 += var18;
                  int var20 = PrefabBuffer.BlockMaskConstants.getOffsetBytes(var17);
                  var15 += var20 == 0 ? 1 : MemorySegmentUtil.readNumber(var12, var14, var20);
                  var14 += var20;
                  float var21 = 1.0F;
                  if (PrefabBuffer.BlockMaskConstants.hasChance(var17)) {
                     var21 = var12.get(ValueLayout.JAVA_FLOAT_UNALIGNED, var14);
                     var14 += 4;
                  }

                  Holder var22 = PrefabBuffer.BlockMaskConstants.hasComponents(var17) ? (Holder)var11.getBlockComponents().get(var15) : null;
                  int var23 = 0;
                  if (PrefabBuffer.BlockMaskConstants.hasRotation(var17)) {
                     var23 = Byte.toUnsignedInt(var12.get(ValueLayout.JAVA_BYTE, var14));
                     var14++;
                  }

                  int var24 = 0;
                  if (PrefabBuffer.BlockMaskConstants.hasFiller(var17)) {
                     var24 = Short.toUnsignedInt(var12.get(ValueLayout.JAVA_SHORT_UNALIGNED, var14));
                     var14 += 2;
                  }

                  int var25 = PrefabBuffer.BlockMaskConstants.getSupportValue(var17);
                  if (!var2.test(var9, var15, var10, var19, var21, var22, var25, var23, var24, var5)) {
                     class="kw">return false;
                  }

                  int var26 = PrefabBuffer.BlockMaskConstants.getFluidBytes(var17);
                  if (var26 != 0) {
                     int var27 = MemorySegmentUtil.readNumber(var12, var14, var26 - 1);
                     var14 += var26 - 1;
                     byte var28 = var12.get(ValueLayout.JAVA_BYTE, var14);
                     var14++;
                     if (!var3.test(var9, var15, var10, var27, var28, var5)) {
                        class="kw">return false;
                     }
                  }
               }
            }

            Holder[] var33 = var11.getEntityHolders();
            if (var4 != null && !var4.test(var9, var10, var33, var5)) {
               class="kw">return false;
            }
         }

         class="kw">return true;
      }

      @Override
      class="kw">public <T class="kw">extends PrefabBufferCall> boolean compare(
         @Nonnull IPrefabBuffer.BlockComparingPrefabPredicate<T> var1, @Nonnull T var2, @Nonnull IPrefabBuffer var3
      ) {
         if (!(var3 class="kw">instanceof PrefabBuffer.PrefabBufferAccessor var4)) {
            class="kw">return IPrefabBuffer.super.compare(var1, var2, var3);
         } else {
            Int2ObjectMap var5 = var4.prefabBuffer.columns;
            IntOpenHashSet var6 = new IntOpenHashSet(this.prefabBuffer.columns.size() + var5.size());
            var6.addAll(this.prefabBuffer.columns.keySet());
            var6.addAll(var5.keySet());
            IntIterator var7 = var6.iterator();

            while (var7.hasNext()) {
               int var8 = var7.nextInt();
               int var9 = MathUtil.unpackLeft(var8);
               int var10 = MathUtil.unpackRight(var8);
               int var11 = var2.rotation.getX(var9, var10);
               int var12 = var2.rotation.getZ(var9, var10);
               PrefabBufferColumn var13 = (PrefabBufferColumn)this.prefabBuffer.columns.get(var8);
               PrefabBufferColumn var14 = (PrefabBufferColumn)var5.get(var8);
               MemorySegment var15 = var13 != null ? var13.getMemorySegment() : null;
               MemorySegment var16 = var14 != null ? var14.getMemorySegment() : null;
               int var17 = var13 != null ? var13.getBlockCount() : 0;
               int var18 = var14 != null ? var14.getBlockCount() : 0;
               if (var17 != 0 || var18 != 0) {
                  int var19 = 0;
                  int var20;
                  if (var17 > 0) {
                     var20 = var15.get(ValueLayout.JAVA_INT_UNALIGNED, var19);
                     var19 += 4;
                  } else {
                     var20 = Integer.MAX_VALUE;
                  }

                  int var21 = 0;
                  int var22;
                  if (var18 > 0) {
                     var22 = var16.get(ValueLayout.JAVA_INT_UNALIGNED, var21);
                     var21 += 4;
                  } else {
                     var22 = Integer.MAX_VALUE;
                  }

                  int var23 = Integer.MIN_VALUE;
                  float var24 = 1.0F;
                  int var25 = 0;
                  int var26 = 0;
                  Holder var27 = null;
                  int var28 = Integer.MIN_VALUE;
                  float var29 = 1.0F;
                  int var30 = 0;
                  int var31 = 0;
                  Holder var32 = null;
                  int var33 = 0;
                  int var34 = 0;

                  while (var33 < var17 || var34 < var18) {
                     int var35 = var20;
                     int var36 = var22;
                     int var37 = var19;
                     int var38 = var21;
                     if (var33 < var17) {
                        int var39 = Short.toUnsignedInt(var15.get(ValueLayout.JAVA_SHORT_UNALIGNED, var19));
                        var19 += 2;
                        int var40 = PrefabBuffer.BlockMaskConstants.getBlockBytes(var39);
                        var23 = MemorySegmentUtil.readNumber(var15, var19, var40);
                        var19 += var40;
                        int var41 = PrefabBuffer.BlockMaskConstants.getOffsetBytes(var39);
                        var20 += var41 == 0 ? 1 : MemorySegmentUtil.readNumber(var15, var19, var41);
                        var19 += var41;
                        if (PrefabBuffer.BlockMaskConstants.hasChance(var39)) {
                           var24 = var15.get(ValueLayout.JAVA_FLOAT_UNALIGNED, var19);
                           var19 += 4;
                        } else {
                           var24 = 1.0F;
                        }

                        if (PrefabBuffer.BlockMaskConstants.hasRotation(var39)) {
                           var25 = var2.rotation.getRotation(Byte.toUnsignedInt(var15.get(ValueLayout.JAVA_BYTE, var19)));
                           var19++;
                        } else {
                           var25 = var2.rotation.getRotation(0);
                        }

                        if (PrefabBuffer.BlockMaskConstants.hasFiller(var39)) {
                           var26 = var2.rotation.getFiller(Short.toUnsignedInt(var15.get(ValueLayout.JAVA_SHORT_UNALIGNED, var19)));
                           var19 += 2;
                        } else {
                           var26 = 0;
                        }

                        var27 = PrefabBuffer.BlockMaskConstants.hasComponents(var39) ? (Holder)var13.getBlockComponents().get(var20) : null;
                        var19 += PrefabBuffer.BlockMaskConstants.getFluidBytes(var39);
                     }

                     if (var34 < var18) {
                        int var48 = Short.toUnsignedInt(var16.get(ValueLayout.JAVA_SHORT_UNALIGNED, var21));
                        var21 += 2;
                        int var52 = PrefabBuffer.BlockMaskConstants.getBlockBytes(var48);
                        var28 = MemorySegmentUtil.readNumber(var16, var21, var52);
                        var21 += var52;
                        int var53 = PrefabBuffer.BlockMaskConstants.getOffsetBytes(var48);
                        var22 += var53 == 0 ? 1 : MemorySegmentUtil.readNumber(var16, var21, var53);
                        var21 += var53;
                        if (PrefabBuffer.BlockMaskConstants.hasChance(var48)) {
                           var29 = var16.get(ValueLayout.JAVA_FLOAT_UNALIGNED, var21);
                           var21 += 4;
                        } else {
                           var29 = 1.0F;
                        }

                        if (PrefabBuffer.BlockMaskConstants.hasRotation(var48)) {
                           var30 = var2.rotation.getRotation(Byte.toUnsignedInt(var16.get(ValueLayout.JAVA_BYTE, var21)));
                           var21++;
                        } else {
                           var30 = var2.rotation.getRotation(0);
                        }

                        if (PrefabBuffer.BlockMaskConstants.hasFiller(var48)) {
                           var31 = var2.rotation.getFiller(Short.toUnsignedInt(var16.get(ValueLayout.JAVA_SHORT_UNALIGNED, var21)));
                           var21 += 2;
                        } else {
                           var31 = 0;
                        }

                        var32 = PrefabBuffer.BlockMaskConstants.hasComponents(var48) ? (Holder)var14.getBlockComponents().get(var22) : null;
                        var21 += PrefabBuffer.BlockMaskConstants.getFluidBytes(var48);
                     }

                     if (var20 == var22) {
                        var33++;
                        var34++;
                        boolean var51 = var1.test(var11, var20, var12, var23, var27, var24, var25, var26, var28, var32, var29, var30, var31, var2);
                        if (!var51) {
                           class="kw">return false;
                        }
                     } else if ((var20 >= var22 || var33 >= var17) && var34 < var18) {
                        var34++;
                        var20 = var35;
                        var19 = var37;
                        boolean var50 = var1.test(var11, var22, var12, Integer.MIN_VALUE, null, 1.0F, 0, 0, var28, var32, var29, var30, var31, var2);
                        if (!var50) {
                           class="kw">return false;
                        }
                     } else {
                        var33++;
                        var22 = var36;
                        var21 = var38;
                        boolean var49 = var1.test(var11, var20, var12, var23, var27, var24, var25, var26, Integer.MIN_VALUE, null, 1.0F, 0, 0, var2);
                        if (!var49) {
                           class="kw">return false;
                        }
                     }
                  }
               }
            }

            class="kw">return true;
         }
      }

      @Override
      class="kw">public int getBlockId(int var1, int var2, int var3) {
         PrefabBufferColumn var4 = (PrefabBufferColumn)this.prefabBuffer.columns.get(MathUtil.packInt(var1, var3));
         if (var4 == null) {
            class="kw">return 0;
         }

         int var5 = var4.getBlockCount();
         if (var5 <= 0) {
            class="kw">return 0;
         }

         MemorySegment var6 = var4.getMemorySegment();
         int var7 = 0;
         int var8 = var6.get(ValueLayout.JAVA_INT_UNALIGNED, var7);
         var7 += 4;

         for (int var9 = 0; var9 < var5; var9++) {
            int var10 = Short.toUnsignedInt(var6.get(ValueLayout.JAVA_SHORT_UNALIGNED, var7));
            var7 += 2;
            int var11 = PrefabBuffer.BlockMaskConstants.getBlockBytes(var10);
            int var12 = MemorySegmentUtil.readNumber(var6, var7, var11);
            var7 += var11;
            int var13 = PrefabBuffer.BlockMaskConstants.getOffsetBytes(var10);
            var8 += var13 == 0 ? 1 : MemorySegmentUtil.readNumber(var6, var7, var13);
            var7 += var13;
            if (var8 > var2) {
               class="kw">return 0;
            }

            if (PrefabBuffer.BlockMaskConstants.hasChance(var10)) {
               var7 += 4;
            }

            if (PrefabBuffer.BlockMaskConstants.hasRotation(var10)) {
               var7++;
            }

            if (PrefabBuffer.BlockMaskConstants.hasFiller(var10)) {
               var7 += 2;
            }

            var7 += PrefabBuffer.BlockMaskConstants.getFluidBytes(var10);
            if (var8 == var2) {
               if (PrefabBuffer.BlockMaskConstants.hasChance(var10)) {
                  throw new UnsupportedOperationException("Unable to access block with chance!");
               }

               class="kw">return var12;
            }
         }

         class="kw">return 0;
      }

      @Override
      class="kw">public int getFiller(int var1, int var2, int var3) {
         PrefabBufferColumn var4 = (PrefabBufferColumn)this.prefabBuffer.columns.get(MathUtil.packInt(var1, var3));
         if (var4 == null) {
            class="kw">return 0;
         }

         int var5 = var4.getBlockCount();
         if (var5 <= 0) {
            class="kw">return 0;
         }

         MemorySegment var6 = var4.getMemorySegment();
         int var7 = 0;
         int var8 = var6.get(ValueLayout.JAVA_INT_UNALIGNED, var7);
         var7 += 4;

         for (int var9 = 0; var9 < var5; var9++) {
            int var10 = Short.toUnsignedInt(var6.get(ValueLayout.JAVA_SHORT_UNALIGNED, var7));
            var7 += 2;
            int var11 = PrefabBuffer.BlockMaskConstants.getBlockBytes(var10);
            MemorySegmentUtil.readNumber(var6, var7, var11);
            var7 += var11;
            int var12 = PrefabBuffer.BlockMaskConstants.getOffsetBytes(var10);
            var8 += var12 == 0 ? 1 : MemorySegmentUtil.readNumber(var6, var7, var12);
            var7 += var12;
            if (var8 > var2) {
               class="kw">return 0;
            }

            if (PrefabBuffer.BlockMaskConstants.hasChance(var10)) {
               var7 += 4;
            }

            if (PrefabBuffer.BlockMaskConstants.hasRotation(var10)) {
               var7++;
            }

            int var13 = 0;
            if (PrefabBuffer.BlockMaskConstants.hasFiller(var10)) {
               var13 = Short.toUnsignedInt(var6.get(ValueLayout.JAVA_SHORT_UNALIGNED, var7));
               var7 += 2;
            }

            var7 += PrefabBuffer.BlockMaskConstants.getFluidBytes(var10);
            if (var8 == var2) {
               if (PrefabBuffer.BlockMaskConstants.hasChance(var10)) {
                  throw new UnsupportedOperationException("Unable to access block with chance!");
               }

               class="kw">return var13;
            }
         }

         class="kw">return 0;
      }

      @Override
      class="kw">public int getRotationIndex(int var1, int var2, int var3) {
         PrefabBufferColumn var4 = (PrefabBufferColumn)this.prefabBuffer.columns.get(MathUtil.packInt(var1, var3));
         if (var4 == null) {
            class="kw">return 0;
         }

         int var5 = var4.getBlockCount();
         if (var5 <= 0) {
            class="kw">return 0;
         }

         MemorySegment var6 = var4.getMemorySegment();
         int var7 = 0;
         int var8 = var6.get(ValueLayout.JAVA_INT_UNALIGNED, var7);
         var7 += 4;

         for (int var9 = 0; var9 < var5; var9++) {
            int var10 = Short.toUnsignedInt(var6.get(ValueLayout.JAVA_SHORT_UNALIGNED, var7));
            var7 += 2;
            int var11 = PrefabBuffer.BlockMaskConstants.getBlockBytes(var10);
            MemorySegmentUtil.readNumber(var6, var7, var11);
            var7 += var11;
            int var12 = PrefabBuffer.BlockMaskConstants.getOffsetBytes(var10);
            var8 += var12 == 0 ? 1 : MemorySegmentUtil.readNumber(var6, var7, var12);
            var7 += var12;
            if (var8 > var2) {
               class="kw">return 0;
            }

            if (PrefabBuffer.BlockMaskConstants.hasChance(var10)) {
               var7 += 4;
            }

            int var13 = 0;
            if (PrefabBuffer.BlockMaskConstants.hasRotation(var10)) {
               var13 = Byte.toUnsignedInt(var6.get(ValueLayout.JAVA_BYTE, var7));
               var7++;
            }

            if (PrefabBuffer.BlockMaskConstants.hasFiller(var10)) {
               var7 += 2;
            }

            var7 += PrefabBuffer.BlockMaskConstants.getFluidBytes(var10);
            if (var8 == var2) {
               if (PrefabBuffer.BlockMaskConstants.hasChance(var10)) {
                  throw new UnsupportedOperationException("Unable to access block with chance!");
               }

               class="kw">return var13;
            }
         }

         class="kw">return 0;
      }
   }
}