class="kw">package com.hypixel.hytale.server.worldgen.chunk.populator;

class="kw">import com.hypixel.hytale.common.map.IWeightedMap;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.math.util.FastRandom;
class="kw">import com.hypixel.hytale.math.util.HashUtil;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.procedurallib.condition.ConstantIntCondition;
class="kw">import com.hypixel.hytale.procedurallib.condition.DefaultCoordinateRndCondition;
class="kw">import com.hypixel.hytale.procedurallib.condition.IBlockFluidCondition;
class="kw">import com.hypixel.hytale.procedurallib.condition.ICoordinateRndCondition;
class="kw">import com.hypixel.hytale.server.core.prefab.PrefabRotation;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.buffer.impl.IPrefabBuffer;
class="kw">import com.hypixel.hytale.server.worldgen.biome.Biome;
class="kw">import com.hypixel.hytale.server.worldgen.biome.BiomePatternGenerator;
class="kw">import com.hypixel.hytale.server.worldgen.biome.CustomBiome;
class="kw">import com.hypixel.hytale.server.worldgen.biome.TileBiome;
class="kw">import com.hypixel.hytale.server.worldgen.cache.CoreDataCacheEntry;
class="kw">import com.hypixel.hytale.server.worldgen.chunk.ChunkGenerator;
class="kw">import com.hypixel.hytale.server.worldgen.chunk.ChunkGeneratorExecution;
class="kw">import com.hypixel.hytale.server.worldgen.chunk.ZoneBiomeResult;
class="kw">import com.hypixel.hytale.server.worldgen.container.CoverContainer;
class="kw">import com.hypixel.hytale.server.worldgen.container.PrefabContainer;
class="kw">import com.hypixel.hytale.server.worldgen.container.UniquePrefabContainer;
class="kw">import com.hypixel.hytale.server.worldgen.container.WaterContainer;
class="kw">import com.hypixel.hytale.server.worldgen.loader.WorldGenPrefabSupplier;
class="kw">import com.hypixel.hytale.server.worldgen.prefab.PrefabBaseCheck;
class="kw">import com.hypixel.hytale.server.worldgen.prefab.PrefabCategory;
class="kw">import com.hypixel.hytale.server.worldgen.prefab.PrefabPasteUtil;
class="kw">import com.hypixel.hytale.server.worldgen.prefab.PrefabPatternGenerator;
class="kw">import com.hypixel.hytale.server.worldgen.util.BlockFluidEntry;
class="kw">import com.hypixel.hytale.server.worldgen.util.LogUtil;
class="kw">import com.hypixel.hytale.server.worldgen.util.bounds.IChunkBounds;
class="kw">import com.hypixel.hytale.server.worldgen.util.condition.BlockMaskCondition;
class="kw">import com.hypixel.hytale.server.worldgen.zone.Zone;
class="kw">import com.hypixel.hytale.server.worldgen.zone.ZoneGeneratorResult;
class="kw">import com.hypixel.hytale.server.worldgen.zone.ZonePatternGenerator;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.util.BitSet;
class="kw">import java.util.Objects;
class="kw">import java.util.Random;
class="kw">import java.util.concurrent.TimeUnit;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3i;

class="kw">public class PrefabPopulator {
   class="kw">private class="kw">static class="kw">final UniquePrefabContainer.UniquePrefabEntry[] EMPTY_UNIQUE_PREFABS = new UniquePrefabContainer.UniquePrefabEntry[0];
   class="kw">private class="kw">static class="kw">final int BIOME_SAMPLE_STEP_SIZE = 8;
   class="kw">private class="kw">static class="kw">final int BASE_CHECK_MIN_RADIUS = 3;
   class="kw">private int worldSeed;
   class="kw">private long prefabSeed;
   class="kw">private int minPriority = Integer.MAX_VALUE;
   @Nullable
   class="kw">private Biome biome;
   @Nullable
   class="kw">private PrefabContainer.PrefabContainerEntry entry;
   @Nullable
   class="kw">private ChunkGeneratorExecution execution;
   @Nonnull
   class="kw">private UniquePrefabContainer.UniquePrefabEntry[] uniquePrefabs = EMPTY_UNIQUE_PREFABS;
   class="kw">private class="kw">final FastRandom random = new FastRandom(0L);
   class="kw">private class="kw">final ObjectArrayList<Biome> biomes = new ObjectArrayList();
   class="kw">private class="kw">final ObjectArrayList<PrefabPopulator.Candidate> prefabs = new ObjectArrayList();
   class="kw">private class="kw">final BitSet invalidated = new BitSet();

   class="kw">public PrefabPopulator() {
   }

   class="kw">public class="kw">static void populate(int var0, @Nonnull ChunkGeneratorExecution var1) {
      ChunkGenerator.getResource().prefabPopulator.run(var0, var1);
   }

   class="kw">public void run(int var1, @Nonnull ChunkGeneratorExecution var2) {
      this.worldSeed = var1;
      this.minPriority = Integer.MAX_VALUE;
      this.uniquePrefabs = Objects.requireNonNullElse(var2.getChunkGenerator().getUniquePrefabs(var1), EMPTY_UNIQUE_PREFABS);
      this.collectBiomes(var1, var2);
      this.collectPrefabs(var1, var2);
      this.invalidatePrefabs();
      this.generatePrefabs(var1, var2);
      this.generateUniquePrefabs(var1, var2);
      this.biome = null;
      this.entry = null;
      this.execution = null;
      this.uniquePrefabs = EMPTY_UNIQUE_PREFABS;
      this.biomes.clear();
      this.prefabs.clear();
      this.invalidated.clear();
   }

   class="kw">private void collectBiomes(int var1, ChunkGeneratorExecution var2) {
      for (CoreDataCacheEntry var6 : var2.getCoreDataEntries()) {
         Biome var7 = var6.zoneBiomeResult.getBiome();
         if (var7.getPrefabContainer() != null) {
            this.collectBiome(var7);
         }
      }

      int var29 = var2.getX();
      int var30 = var2.getZ();
      int var31 = ChunkUtil.minBlock(var29) - 5;
      int var32 = ChunkUtil.minBlock(var30) - 5;
      int var33 = ChunkUtil.maxBlock(var29) + 5;
      int var8 = ChunkUtil.maxBlock(var30) + 5;
      int var9 = var2.getChunkGenerator().getZonePatternProvider().getMaxExtent();
      int var10 = var31 - var9;
      int var11 = var32 - var9;
      int var12 = var33 + var9;
      int var13 = var8 + var9;
      ZoneGeneratorResult var14 = ChunkGenerator.getResource().zoneBiomeResult.zoneResult;
      ZonePatternGenerator var15 = var2.getChunkGenerator().getZonePatternGenerator(var1);

      for (int var16 = var11; var16 <= var13; var16 += 8) {
         for (int var17 = var10; var17 <= var12; var17 += 8) {
            if (var17 < var31 || var16 < var32 || var17 > var33 || var16 > var8) {
               Zone var18 = var15.generate(var1, var17, var16, var14).getZone();
               BiomePatternGenerator var19 = var18.biomePatternGenerator();
               int var20 = var31 - var19.getExtents();
               int var21 = var32 - var19.getExtents();
               int var22 = var33 + var19.getExtents();
               int var23 = var8 + var19.getExtents();
               if (var17 >= var20 && var16 >= var21 && var17 <= var22 && var16 <= var23) {
                  TileBiome var24 = var19.getBiome(var1, var17, var16);
                  if (var24 != null) {
                     if (var24.getPrefabContainer() != null) {
                        this.collectBiome(var24);
                     }

                     for (CustomBiome var28 : var19.getCustomBiomes()) {
                        if (var28.getPrefabContainer() != null && var28.getCustomBiomeGenerator().isValidParentBiome(var24.getId())) {
                           this.collectBiome(var28);
                        }
                     }
                  }
               }
            }
         }
      }
   }

   class="kw">private void collectPrefabs(int var1, ChunkGeneratorExecution var2) {
      for (int var3 = 0; var3 < this.biomes.size(); var3++) {
         Biome var4 = (Biome)this.biomes.get(var3);
         PrefabContainer var5 = var4.getPrefabContainer();
         if (var5 != null) {
            int var6 = 0;

            for (PrefabContainer.PrefabContainerEntry var10 : var5.getEntries()) {
               this.biome = var4;
               this.entry = var10;
               this.execution = var2;
               this.prefabSeed = HashUtil.hash(var1, var4.getId(), ++var6);
               var10.getPrefabPatternGenerator()
                  .getGridGenerator()
                  .collect(
                     var1,
                     ChunkUtil.minBlock(var2.getX()) - var10.getExtents(),
                     ChunkUtil.minBlock(var2.getZ()) - var10.getExtents(),
                     ChunkUtil.maxBlock(var2.getX()) + var10.getExtents(),
                     ChunkUtil.maxBlock(var2.getZ()) + var10.getExtents(),
                     this::collectPrefab
                  );
            }
         }
      }
   }

   class="kw">private void generatePrefabs(int var1, @Nonnull ChunkGeneratorExecution var2) {
      for (int var3 = 0; var3 < this.prefabs.size(); var3++) {
         if (!this.invalidated.get(var3)) {
            PrefabPopulator.Candidate var4 = (PrefabPopulator.Candidate)this.prefabs.get(var3);
            int var5 = var4.x;
            int var6 = var4.y;
            int var7 = var4.z;
            PrefabRotation var8 = var4.rotation;
            WorldGenPrefabSupplier var9 = var4.supplier;
            if (isMatchingChunkBounds(var5, var7, var2, var8, var9.getBounds(var4.buffer))) {
               BlockMaskCondition var10 = var4.generator.getPrefabPlacementConfiguration();
               ICoordinateRndCondition var11 = var4.generator.getHeightCondition();
               int var12 = var4.entry.getEnvironmentId();
               boolean var13 = var4.generator.isFitHeightmap();
               boolean var14 = var4.generator.isSubmerge();
               generatePrefabAt(var1, var5, var7, var6, var2, var9, var10, var8, var11, var12, var13, var14);
            }
         }
      }
   }

   class="kw">private void generateUniquePrefabs(int var1, @Nonnull ChunkGeneratorExecution var2) {
      for (UniquePrefabContainer.UniquePrefabEntry var6 : this.uniquePrefabs) {
         if (isMatchingChunkBounds(var2, var6.getLowBoundX(), var6.getLowBoundZ(), var6.getHighBoundX(), var6.getHighBoundZ())) {
            Vector3i var7 = var6.getPosition();
            generatePrefabAt(
               var1,
               var7.x(),
               var7.z(),
               var7.y(),
               var2,
               var6.getPrefabSupplier(),
               var6.getConfiguration(),
               var6.getRotation(),
               DefaultCoordinateRndCondition.DEFAULT_TRUE,
               var6.getEnvironmentId(),
               var6.isFitHeightmap(),
               var6.isSubmerge()
            );
         }
      }
   }

   class="kw">private void collectBiome(@Nonnull Biome var1) {
      Biome var2 = var1;

      for (int var3 = 0; var3 < this.biomes.size(); var3++) {
         int var4 = ((Biome)this.biomes.get(var3)).getId();
         if (var2.getId() == var4) {
            class="kw">return;
         }

         if (var2.getId() < var4) {
            var2 = (Biome)this.biomes.set(var3, var2);
         }
      }

      this.biomes.add(var2);
   }

   class="kw">private void collectPrefab(double var1, double var3) {
      Objects.requireNonNull(this.biome);
      Objects.requireNonNull(this.entry);
      Objects.requireNonNull(this.execution);
      int var5 = (int)MathUtil.fastFloor(var1);
      int var6 = (int)MathUtil.fastFloor(var3);
      this.random.setSeed(HashUtil.hash(this.prefabSeed, var5, var6) * 1609272495L);
      PrefabPatternGenerator var7 = this.entry.getPrefabPatternGenerator();
      if (isMatchingNoiseDensity(this.worldSeed, var5, var6, var7)) {
         if (!isWithinUniquePrefabExclusionRange(var5, var6, var7, this.uniquePrefabs)) {
            ZoneBiomeResult var8 = this.execution.getChunkGenerator().getZoneBiomeResultAt(this.worldSeed, var5, var6);
            if (isMatchingBiome(this.biome, var8)) {
               IWeightedMap var9 = this.entry.getPrefabs();
               WorldGenPrefabSupplier var10 = var9.get(this.random);
               if (var10 != null) {
                  IPrefabBuffer var11 = var10.get();
                  if (var11 != null) {
                     PrefabRotation var12 = generateRotation(var5, var6, this.random, var7);
                     int var13 = getHeight(this.worldSeed, var5, var6, this.execution, var8.getBiome(), var7, this.random);
                     if (isMatchingHeight(this.worldSeed, var5, var6, var13, this.random, var7)) {
                        if (isMatchingParentBlock(this.worldSeed, var5, var6, var13, this.random, var8, this.entry)) {
                           if (!isBaseValid(this.worldSeed, var5, var6, var13, var12, var11, var7, this.execution)) {
                              ((HytaleLogger.Api)((HytaleLogger.Api)LogUtil.getLogger().atFine()).atMostEvery(1, TimeUnit.SECONDS))
                                 .log("Prefab failed base-check at: /tp %d %d %d [%s]", var5, var13, var6, var10.getPrefabName());
                           } else {
                              PrefabCategory var14 = var7.getCategory();
                              this.prefabs.add(new PrefabPopulator.Candidate(var5, var13, var6, var14.priority(), var12, var11, var10, this.entry, var7));
                              this.minPriority = Math.min(this.minPriority, var14.priority());
                           }
                        }
                     }
                  }
               }
            }
         }
      }
   }

   class="kw">private void invalidatePrefabs() {
      for (int var1 = 0; var1 < this.prefabs.size(); var1++) {
         PrefabPopulator.Candidate var2 = (PrefabPopulator.Candidate)this.prefabs.get(var1);
         if (var2.priority > this.minPriority && !this.invalidated.get(var1)) {
            int var3 = var2.y + var2.buffer.getMinY();
            int var4 = var2.y + var2.buffer.getMaxY();
            int var5 = var2.x + var2.buffer.getMinX(var2.rotation);
            int var6 = var2.z + var2.buffer.getMinZ(var2.rotation);
            int var7 = var2.x + var2.buffer.getMaxX(var2.rotation);
            int var8 = var2.z + var2.buffer.getMaxZ(var2.rotation);

            for (int var9 = 0; var9 < this.prefabs.size(); var9++) {
               PrefabPopulator.Candidate var10 = (PrefabPopulator.Candidate)this.prefabs.get(var9);
               if (var2.priority > var10.priority
                  && intersects(
                     var5,
                     var3,
                     var6,
                     var7,
                     var4,
                     var8,
                     var10.x + var10.buffer.getMinX(var10.rotation),
                     var10.y + var10.buffer.getMinY(),
                     var10.z + var10.buffer.getMinZ(var10.rotation),
                     var10.x + var10.buffer.getMaxX(var10.rotation),
                     var10.y + var10.buffer.getMaxY(),
                     var10.z + var10.buffer.getMaxZ(var10.rotation)
                  )) {
                  this.invalidated.set(var9);
               }
            }
         }
      }
   }

   class="kw">private class="kw">static boolean isBaseValid(
      int var0,
      int var1,
      int var2,
      int var3,
      @Nonnull PrefabRotation var4,
      @Nonnull IPrefabBuffer var5,
      @Nonnull PrefabPatternGenerator var6,
      @Nonnull ChunkGeneratorExecution var7
   ) {
      if (var6.getBaseChecks().length == 0) {
         class="kw">return true;
      }

      int var8 = var1 + var5.getMinX(var4);
      int var9 = var2 + var5.getMinZ(var4);
      int var10 = var1 + var5.getMaxX(var4);
      int var11 = var2 + var5.getMaxZ(var4);
      int var12 = var10 - var8;
      int var13 = var11 - var9;
      int var14 = Math.max(var12, var13);

      for (PrefabBaseCheck var18 : var6.getBaseChecks()) {
         if (var14 >= var18.getPrefabSize()) {
            int var19 = var8 + var10 >> 1;
            int var20 = var9 + var11 >> 1;
            int var21 = var3 + var5.getMinY();
            int var22 = var21 - var18.getHeightTolerance();
            int var23 = MathUtil.fastFloor((var12 >> 1) * var18.getBaseScale());
            int var24 = MathUtil.fastFloor((var13 >> 1) * var18.getBaseScale());
            class="kw">return (var23 <= 3 || var7.getHeight(var0, var19 - var23, var20) >= var22)
               && (var23 <= 3 || var7.getHeight(var0, var19 + var23, var20) >= var22)
               && (var24 <= 3 || var7.getHeight(var0, var19, var20 - var24) >= var22)
               && (var24 <= 3 || var7.getHeight(var0, var19, var20 + var24) >= var22);
         }
      }

      class="kw">return true;
   }

   class="kw">private class="kw">static boolean intersects(int var0, int var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8, int var9, int var10, int var11) {
      class="kw">return var3 >= var6 && var0 <= var9 && var4 >= var7 && var1 <= var10 && var5 >= var8 && var2 <= var11;
   }

   class="kw">private class="kw">static boolean isWithinUniquePrefabExclusionRange(
      int var0, int var1, @Nonnull PrefabPatternGenerator var2, @Nonnull UniquePrefabContainer.UniquePrefabEntry[] var3
   ) {
      long var4 = var2.getExclusionRadius();
      if (var4 <= 0L) {
         class="kw">return false;
      }

      long var6 = var4 * var4;
      int var8 = var2.getCategory().priority();

      for (UniquePrefabContainer.UniquePrefabEntry var12 : var3) {
         if (var8 < var12.getCategory().priority()) {
            long var13 = (long)var0 - var12.getPosition().x();
            long var15 = (long)var1 - var12.getPosition().z();
            if (var13 * var13 + var15 * var15 <= var6) {
               class="kw">return true;
            }
         }
      }

      class="kw">return false;
   }

   class="kw">private class="kw">static int getHeight(
      int var0, int var1, int var2, @Nonnull ChunkGeneratorExecution var3, @Nonnull Biome var4, @Nonnull PrefabPatternGenerator var5, Random var6
   ) {
      int var7;
      if (var5.isOnWater() && var5.isDeepSearch()) {
         var7 = Integer.MIN_VALUE;

         for (WaterContainer.Entry var11 : var4.getWaterContainer().getEntries()) {
            int var12 = var11.getMax(var0, var1, var2);
            if (var12 != Integer.MIN_VALUE && var5.getHeightCondition().eval(var0, var1, var2, var12, var6)) {
               var7 = var12;
               break;
            }
         }
      } else if (var5.isOnWater()) {
         var7 = var4.getWaterContainer().getMaxHeight(var0, var1, var2);
      } else if (var5.isDeepSearch()) {
         var7 = var3.getChunkGenerator().generateHeightBetween(var0, var1, var2, var5.getHeightThresholdInterpreter());
      } else {
         var7 = var3.getChunkGenerator().getHeight(var0, var1, var2);
      }

      class="kw">return var7 + var5.getDisplacement(var0, var1, var2);
   }

   class="kw">private class="kw">static PrefabRotation generateRotation(int var0, int var1, @Nonnull Random var2, @Nonnull PrefabPatternGenerator var3) {
      PrefabRotation[] var4 = var3.getRotations();
      if (var4 == null) {
         var4 = PrefabRotation.VALUES;
      }

      class="kw">return var4[var2.nextInt(var4.length)];
   }

   class="kw">private class="kw">static void generatePrefabAt(
      int var0,
      int var1,
      int var2,
      int var3,
      @Nonnull ChunkGeneratorExecution var4,
      @Nonnull WorldGenPrefabSupplier var5,
      BlockMaskCondition var6,
      PrefabRotation var7,
      ICoordinateRndCondition var8,
      int var9,
      boolean var10,
      boolean var11
   ) {
      int var12 = var1 - ChunkUtil.minBlock(var4.getX());
      int var13 = var2 - ChunkUtil.minBlock(var4.getZ());
      long var14 = HashUtil.hash(var1, var2) * -1058827062L;
      PrefabPasteUtil.PrefabPasteBuffer var16 = ChunkGenerator.getResource().prefabBuffer;
      var16.setSeed(var0, var14);
      var16.execution = var4;
      var16.blockMask = var6;
      var16.environmentId = var9;
      var16.fitHeightmap = var10;
      var16.priority = (byte)(var11 ? 41 : 9);
      var16.spawnCondition = var8;
      if (var4.getChunkGenerator().getBenchmark().isEnabled() && ChunkUtil.isInsideChunkRelative(var12, var13)) {
         ZoneBiomeResult var17 = var4.zoneBiomeResult(var12, var13);
         String var18 = var17.zoneResult.getZone().name();
         String var19 = var17.biome.getName();
         var4.getChunkGenerator().getBenchmark().registerPrefab(var18 + "\t" + var19 + "\t" + var5.getName());
      }

      PrefabPasteUtil.generate(var16, var7, var5, var1, var3, var2, var12, var13);
   }

   class="kw">private class="kw">static boolean isMatchingBiome(Biome var0, @Nonnull ZoneBiomeResult var1) {
      class="kw">return var1.getBiome() == var0;
   }

   class="kw">private class="kw">static boolean isMatchingChunkBounds(
      int var0, int var1, @Nonnull ChunkGeneratorExecution var2, @Nonnull PrefabRotation var3, @Nonnull IChunkBounds var4
   ) {
      int var5 = var0 + var4.getLowBoundX(var3);
      int var6 = var1 + var4.getLowBoundZ(var3);
      int var7 = var0 + var4.getHighBoundX(var3);
      int var8 = var1 + var4.getHighBoundZ(var3);
      class="kw">return isMatchingChunkBounds(var2, var5, var6, var7, var8);
   }

   class="kw">private class="kw">static boolean isMatchingChunkBounds(@Nonnull ChunkGeneratorExecution var0, int var1, int var2, int var3, int var4) {
      class="kw">return ChunkUtil.maxBlock(var0.getX()) >= var1
         && ChunkUtil.minBlock(var0.getX()) <= var3
         && ChunkUtil.maxBlock(var0.getZ()) >= var2
         && ChunkUtil.minBlock(var0.getZ()) <= var4;
   }

   class="kw">private class="kw">static boolean isMatchingHeight(int var0, int var1, int var2, int var3, Random var4, @Nonnull PrefabPatternGenerator var5) {
      class="kw">return var5.getHeightCondition().eval(var0, var1, var2, var3, var4);
   }

   class="kw">private class="kw">static boolean isMatchingNoiseDensity(int var0, int var1, int var2, @Nonnull PrefabPatternGenerator var3) {
      class="kw">return var3.getMapCondition().eval(var0, var1, var2);
   }

   class="kw">private class="kw">static boolean isMatchingParentBlock(
      int var0, int var1, int var2, int var3, @Nonnull Random var4, @Nonnull ZoneBiomeResult var5, @Nonnull PrefabContainer.PrefabContainerEntry var6
   ) {
      IBlockFluidCondition var7 = var6.getPrefabPatternGenerator().getParentCondition();
      if (var7 == ConstantIntCondition.DEFAULT_TRUE) {
         class="kw">return true;
      }

      if (var7 == ConstantIntCondition.DEFAULT_FALSE) {
         class="kw">return false;
      }

      BlockFluidEntry var8 = getCoverInGroundAt(var0, var1, var2, var3, var4, var5.getBiome());
      if (!var8.equals(BlockFluidEntry.EMPTY) && !var7.eval(var8.blockId(), var8.fluidId())) {
         class="kw">return false;
      }

      BlockFluidEntry var9 = var5.getBiome().getLayerContainer().getTopBlockAt(var0, var1, var2);
      class="kw">return var7.eval(var9.blockId(), var9.fluidId());
   }

   class="kw">private class="kw">static BlockFluidEntry getCoverInGroundAt(int var0, int var1, int var2, int var3, @Nonnull Random var4, @Nonnull Biome var5) {
      for (CoverContainer.CoverContainerEntry var9 : var5.getCoverContainer().getEntries()) {
         if (var3 < 320 && isMatchingCover(var0, var1, var2, var3, var4, var9)) {
            CoverContainer.CoverContainerEntry.CoverContainerEntryPart var10 = var9.get(var4);
            if (var10 != null && var10.getOffset() == -1) {
               class="kw">return var10.getEntry();
            }
         }
      }

      class="kw">return BlockFluidEntry.EMPTY;
   }

   class="kw">private class="kw">static boolean isMatchingCover(int var0, int var1, int var2, int var3, @Nonnull Random var4, @Nonnull CoverContainer.CoverContainerEntry var5) {
      class="kw">return var4.nextDouble() < var5.getCoverDensity()
         && var5.getMapCondition().eval(var0, var1, var2)
         && var5.getHeightCondition().eval(var0, var1, var2, var3, var4);
   }

   class="kw">private record Candidate(
      int x,
      int y,
      int z,
      int priority,
      PrefabRotation rotation,
      IPrefabBuffer buffer,
      WorldGenPrefabSupplier supplier,
      PrefabContainer.PrefabContainerEntry entry,
      PrefabPatternGenerator generator
   ) {
      class="kw">private Candidate {
      }
   }
}