class="kw">package com.hypixel.hytale.server.core.util;

class="kw">import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
class="kw">import com.hypixel.hytale.common.util.CompletableFutureUtil;
class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.Rotation;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.RotationTuple;
class="kw">import com.hypixel.hytale.server.core.blocktype.component.BlockPhysics;
class="kw">import com.hypixel.hytale.server.core.modules.block.BlockEntity;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.FromPrefab;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.prefab.PrefabCopyableComponent;
class="kw">import com.hypixel.hytale.server.core.prefab.PrefabRotation;
class="kw">import com.hypixel.hytale.server.core.prefab.event.PrefabPasteEvent;
class="kw">import com.hypixel.hytale.server.core.prefab.event.PrefabPlaceEntityEvent;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.buffer.PrefabBufferCall;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.buffer.impl.IPrefabBuffer;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.AbstractCachedAccessor;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.BlockOperations;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.CachedAccessor;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockComponentSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.EntitySection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.FluidSection;
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.sneakythrow.SneakyThrow;
class="kw">import it.unimi.dsi.fastutil.ints.IntSet;
class="kw">import java.util.Random;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.concurrent.atomic.AtomicBoolean;
class="kw">import java.util.concurrent.atomic.AtomicInteger;
class="kw">import java.util.function.Consumer;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3i;
class="kw">import org.joml.Vector3ic;

class="kw">public class PrefabUtil {
   class="kw">public class="kw">static class="kw">final Consumer<Holder<ChunkStore>> NOOP_BLOCK_ENTITY_CONSUMER = var0 -> {};
   class="kw">public class="kw">static class="kw">final Consumer<Holder<EntityStore>> NOOP_ENTITY_CONSUMER = var0 -> {};
   class="kw">private class="kw">static class="kw">final AbstractCachedAccessor.Registry ACCESSOR_REGISTRY = new AbstractCachedAccessor.Registry();
   class="kw">private class="kw">static class="kw">final AbstractCachedAccessor.Key<BlockSection> BLOCK_SECTION = ACCESSOR_REGISTRY.forSection(BlockSection::getComponentType);
   class="kw">private class="kw">static class="kw">final AbstractCachedAccessor.Key<BlockComponentSection> BLOCK_COMPONENT_SECTION = ACCESSOR_REGISTRY.forSection(
      BlockComponentSection::getComponentType
   );
   class="kw">private class="kw">static class="kw">final AbstractCachedAccessor.InitFunction ACCESSOR = ACCESSOR_REGISTRY.oneShot();
   class="kw">protected class="kw">static class="kw">final String EDITOR_BLOCK = "Editor_Block";
   class="kw">protected class="kw">static class="kw">final String EDITOR_BLOCK_PREFAB_AIR = "Editor_Empty";
   class="kw">protected class="kw">static class="kw">final String EDITOR_BLOCK_PREFAB_ANCHOR = "Editor_Anchor";
   class="kw">private class="kw">static class="kw">final AtomicInteger PREFAB_ID_SOURCE = new AtomicInteger(0);

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

   class="kw">public class="kw">static boolean prefabMatchesAtPosition(@Nonnull IPrefabBuffer var0, World var1, @Nonnull Vector3i var2, @Nonnull Rotation var3, Random var4) {
      int var5 = var0.getMaxX() - var0.getMinX();
      int var6 = var0.getMaxY() - var0.getMinY();
      int var7 = var0.getMaxZ() - var0.getMinZ();
      CachedAccessor var8 = ACCESSOR.getAtBlock(var1.getChunkStore().getStore(), var2.x(), var2.y(), var2.z(), var5, var6, var7);
      class="kw">return var0.compare((var2x, var3x, var4x, var5x, var6x, var7x, var8x) -> {
         int var9 = var2.x + var2x;
         int var10 = var2.y + var3x;
         int var11 = var2.z + var4x;
         BlockSection var12 = var8.getComponentSectionAtBlock(var9, var10, var11, BLOCK_SECTION);
         class="kw">return var12 == null ? false : var12.get(var9, var10, var11) == var5x;
      }, new PrefabBufferCall(var4, PrefabRotation.fromRotation(var3)));
   }

   class="kw">public class="kw">static boolean canPlacePrefab(
      @Nonnull IPrefabBuffer var0, World var1, @Nonnull Vector3ic var2, @Nonnull Rotation var3, @Nullable IntSet var4, Random var5, boolean var6
   ) {
      int var7 = var0.getMaxX() - var0.getMinX();
      int var8 = var0.getMaxY() - var0.getMinY();
      int var9 = var0.getMaxZ() - var0.getMinZ();
      Store var10 = var1.getChunkStore().getStore();
      CachedAccessor var11 = ACCESSOR.getAtBlock(var10, var2.x(), var2.y(), var2.z(), var7, var8, var9);
      class="kw">return var0.compare(
         (var5x, var6x, var7x, var8x, var9x, var10x, var11x) -> {
            if (var6 && var5x == 0 && var6x == 0 && var7x == 0) {
               class="kw">return true;
            }

            int var12 = var2.x() + var5x;
            int var13 = var2.y() + var6x;
            int var14 = var2.z() + var7x;
            BlockSection var15 = var11.getComponentSectionAtBlock(var12, var13, var14, BLOCK_SECTION);
            class="kw">return var15 == null
               ? false
               : BlockOperations.testPlaceBlock(
                  var10,
                  var15,
                  var12,
                  var13,
                  var14,
                  BlockType.getAssetMap().getAsset(var8x),
                  var9x,
                  (var1x, var2x, var3x, var4x, var5xx, var6xx) -> var4 != null && var4.contains(BlockType.getAssetMap().getIndex(var4x.getId()))
               );
         },
         new PrefabBufferCall(var5, PrefabRotation.fromRotation(var3))
      );
   }

   class="kw">public class="kw">static int getNextPrefabId() {
      class="kw">return PREFAB_ID_SOURCE.getAndIncrement();
   }

   class="kw">private class="kw">static void preload(@Nonnull CachedAccessor var0, @Nullable PrefabUtil.PasteRegion var1) {
      if (var1 != null) {
         for (int var2 = var1.minZ; var2 <= var1.maxZ; var2++) {
            for (int var3 = var1.minX; var3 <= var1.maxX; var3++) {
               for (int var4 = var1.minY; var4 <= var1.maxY; var4++) {
                  Ref var5 = var1.getSectionRef(var3, var4, var2);
                  if (var5 != null && var5.isValid()) {
                     PrefabUtil.PasteRegion.Section var6 = var1.getSection(var3, var4, var2);
                     var0.insertSection(var5, var3, var4, var2);
                     if (var6.blocks() != null) {
                        var0.insertSectionComponent(BLOCK_SECTION, var6.blocks(), var3, var4, var2);
                     }

                     if (var6.blockComponents() != null) {
                        var0.insertSectionComponent(BLOCK_COMPONENT_SECTION, var6.blockComponents(), var3, var4, var2);
                     }
                  }
               }
            }
         }
      }
   }

   class="kw">private class="kw">static void setBlockEntity(
      @Nonnull World var0, @Nonnull Ref<ChunkStore> var1, int var2, int var3, int var4, @Nonnull BlockType var5, int var6, @Nullable Holder<ChunkStore> var7
   ) {
      if (!var0.isInThread()) {
         CompletableFutureUtil._catch(CompletableFuture.runAsync(() -> setBlockEntity(var0, var1, var2, var3, var4, var5, var6, var7), var0));
      } else if (var1.isValid()) {
         Store var8 = var0.getChunkStore().getStore();
         BlockComponentSection var9 = var8.getComponent(var1, BlockComponentSection.getComponentType());
         if (var9 != null) {
            BlockEntity.setBlockEntity(var8, var1, var9, var2, var3, var4, var5, var6, var7);
         }
      }
   }

   class="kw">private class="kw">static void setSupportValue(@Nonnull World var0, @Nonnull Ref<ChunkStore> var1, int var2, int var3, int var4, int var5) {
      if (!var0.isInThread()) {
         CompletableFutureUtil._catch(CompletableFuture.runAsync(() -> setSupportValue(var0, var1, var2, var3, var4, var5), var0));
      } else if (var1.isValid()) {
         BlockPhysics.setSupportValue(var0.getChunkStore().getStore(), var1, var2, var3, var4, var5);
      }
   }

   @Nonnull
   class="kw">public class="kw">static PrefabUtil.PasteRegion loadPasteRegionIfInMemory(
      @Nonnull IPrefabBuffer var0, @Nonnull World var1, @Nonnull Vector3ic var2, @Nonnull PrefabRotation var3
   ) {
      ChunkStore var4 = var1.getChunkStore();
      Store var5 = var4.getStore();
      int var6 = ChunkUtil.chunkCoordinate(var2.y() + var0.getMinY());
      int var7 = ChunkUtil.chunkCoordinate(var2.y() + var0.getMaxY());
      int var8 = ChunkUtil.chunkCoordinate(var2.x() + var0.getMinX(var3));
      int var9 = ChunkUtil.chunkCoordinate(var2.z() + var0.getMinZ(var3));
      int var10 = ChunkUtil.chunkCoordinate(var2.x() + var0.getMaxX(var3));
      int var11 = ChunkUtil.chunkCoordinate(var2.z() + var0.getMaxZ(var3));
      PrefabUtil.PasteRegion var12 = new PrefabUtil.PasteRegion(var8, var6, var9, var10, var7, var11, var5);

      for (int var13 = var9; var13 <= var11; var13++) {
         for (int var14 = var8; var14 <= var10; var14++) {
            var12.set(var14, var13, var4.getChunkReference(ChunkUtil.indexChunk(var14, var13)));

            for (int var15 = var6; var15 <= var7; var15++) {
               var12.set(var14, var15, var13, var4.getChunkSectionReference(var14, var15, var13));
            }
         }
      }

      class="kw">return var12.completeLoad();
   }

   @Nonnull
   class="kw">public class="kw">static CompletableFuture<PrefabUtil.PasteRegion> loadPasteRegionAsync(
      @Nonnull IPrefabBuffer var0, @Nonnull World var1, @Nonnull Vector3ic var2, @Nonnull PrefabRotation var3, int var4
   ) {
      ChunkStore var5 = var1.getChunkStore();
      Store var6 = var5.getStore();
      int var7 = ChunkUtil.chunkCoordinate(var2.y() + var0.getMinY());
      int var8 = ChunkUtil.chunkCoordinate(var2.y() + var0.getMaxY());
      int var9 = ChunkUtil.chunkCoordinate(var2.x() + var0.getMinX(var3));
      int var10 = ChunkUtil.chunkCoordinate(var2.z() + var0.getMinZ(var3));
      int var11 = ChunkUtil.chunkCoordinate(var2.x() + var0.getMaxX(var3));
      int var12 = ChunkUtil.chunkCoordinate(var2.z() + var0.getMaxZ(var3));
      CompletableFuture var13 = new CompletableFuture<>();
      PrefabUtil.PasteRegion var14 = new PrefabUtil.PasteRegion(var9, var7, var10, var11, var8, var12, var6);
      var1.execute(SneakyThrow.sneakyRunnable(() -> {
         for (int var10 = var10; var10 <= var12; var10++) {
            for (int var11 = var9; var11 <= var11; var11++) {
               var14.awaitLoad(var11, var10, var13, var5.getChunkReferenceAsync(ChunkUtil.indexChunk(var11, var10), var4));

               for (int var12 = var7; var12 <= var8; var12++) {
                  var14.awaitLoad(var11, var12, var10, var13, var5.getChunkSectionReferenceAsync(var11, var12, var10, var4));
               }
            }
         }
      }));
      class="kw">return var13.thenApplyAsync(PrefabUtil.PasteRegion::completeLoad, var1);
   }

   class="kw">public class="kw">static void paste(
      @Nonnull IPrefabBuffer var0,
      @Nonnull World var1,
      @Nonnull Vector3i var2,
      @Nonnull Rotation var3,
      @Nonnull Random var4,
      @Nonnull ComponentAccessor<EntityStore> var5
   ) {
      paste(var0, var1, var2, var3, var4, 0, 0, NOOP_BLOCK_ENTITY_CONSUMER, NOOP_ENTITY_CONSUMER, var5);
   }

   class="kw">public class="kw">static void paste(
      @Nonnull IPrefabBuffer var0,
      @Nonnull World var1,
      @Nonnull Vector3i var2,
      @Nonnull Rotation var3,
      @Nonnull Random var4,
      int var5,
      int var6,
      @Nonnull ComponentAccessor<EntityStore> var7
   ) {
      paste(var0, var1, var2, var3, var4, var5, var6, NOOP_BLOCK_ENTITY_CONSUMER, NOOP_ENTITY_CONSUMER, var7);
   }

   class="kw">public class="kw">static void paste(
      @Nonnull IPrefabBuffer var0,
      @Nonnull World var1,
      @Nonnull Vector3i var2,
      @Nonnull Rotation var3,
      @Nonnull Random var4,
      int var5,
      int var6,
      @Nonnull Consumer<Holder<ChunkStore>> var7,
      @Nonnull Consumer<Holder<EntityStore>> var8,
      @Nonnull ComponentAccessor<EntityStore> var9
   ) {
      paste(var0, var1, var2, var3, var4, var5, var6, null, var7, var8, var9);
   }

   class="kw">public class="kw">static void paste(
      @Nonnull IPrefabBuffer var0,
      @Nonnull World var1,
      @Nonnull Vector3i var2,
      @Nonnull Rotation var3,
      @Nonnull Random var4,
      int var5,
      int var6,
      @Nullable PrefabUtil.PasteRegion var7,
      @Nonnull Consumer<Holder<ChunkStore>> var8,
      @Nonnull Consumer<Holder<EntityStore>> var9,
      @Nonnull ComponentAccessor<EntityStore> var10
   ) {
      int var11 = var0.getMaxX() - var0.getMinX();
      int var12 = var0.getMaxY() - var0.getMinY();
      int var13 = var0.getMaxZ() - var0.getMinZ();
      ChunkStore var14 = var1.getChunkStore();
      Store var15 = var14.getStore();
      CachedAccessor var16 = ACCESSOR.getAtBlock(var15, var2.x(), var2.y(), var2.z(), var11, var12, var13);
      preload(var16, var7);
      BlockTypeAssetMap var17 = BlockType.getAssetMap();
      int var18 = var17.getIndex("Editor_Block");
      if (var18 == Integer.MIN_VALUE) {
         throw new IllegalArgumentException("Unknown key! Editor_Block");
      }

      PrefabRotation var19 = PrefabRotation.fromRotation(var3);
      int var20 = getNextPrefabId();
      PrefabPasteEvent var21 = new PrefabPasteEvent(var20, true);
      var10.invoke(var21);
      if (!var21.isCancelled()) {
         var0.forEach(IPrefabBuffer.iterateAllColumns(), (var10x, var11x, var12x, var13x, var14x, var15x, var16x, var17x, var18x, var19x, var20x) -> {
            int var21 = var2.x + var10x;
            int var22 = var2.y + var11x;
            int var23 = var2.z + var12x;
            Ref var24 = var16.getSectionAtBlock(var21, var22, var23);
            if (var24 != null) {
               FluidSection var25 = var15.ensureAndGetComponent(var24, FluidSection.getComponentType());
               var25.setFluid(var21, var22, var23, var19x, (byte)var20x);
               BlockType var26;
               if (PrefabUtil.Flags.test(var5, 2)) {
                  if (var13x == 0 && var19x == 0) {
                     var26 = var17.getAsset("Editor_Empty");
                  } else {
                     var26 = var17.getAsset(var13x);
                  }
               } else {
                  var26 = var17.getAsset(var13x);
               }

               String var27 = var26.getId();
               if (var17x != 0) {
                  if (var14x != null) {
                     Holder var36 = var14x.clone();
                     var8.accept(var36);
                     setBlockEntity(var1, var24, var21, var22, var23, var26, var16x, var36);
                  }
               } else {
                  if (PrefabUtil.Flags.test(var5, 6) && var10x == var0.getAnchorX() && var11x == var0.getAnchorY() && var12x == var0.getAnchorZ()) {
                     int var34 = var17.getIndex("Editor_Anchor");
                     BlockType var38 = var17.getAsset(var34);
                     BlockOperations.setBlock(var14, var24, var21, var22, var23, var34, var38, var16x, var17x, var6);
                  } else if (PrefabUtil.Flags.test(var5, 1)) {
                     int var28 = var17.getIndex(var27);
                     BlockType var29 = var17.getAsset(var28);
                     BlockOperations.setBlock(var14, var24, var21, var22, var23, var28, var29, var16x, var17x, var6);
                  } else {
                     RotationTuple var33 = RotationTuple.get(var16x);
                     int var37 = RotationTuple.of(var33.yaw(), var33.pitch(), var33.roll()).index();
                     int var30 = var17.getIndex(var27);
                     BlockType var31 = var17.getAsset(var30);
                     BlockSection var32 = var16.getComponentSectionAtBlock(var21, var22, var23, BLOCK_SECTION);
                     if (var32 != null && BlockOperations.testPlaceBlock(var15, var32, var21, var22, var23, var31, var37)) {
                        BlockOperations.setBlock(var14, var24, var21, var22, var23, var30, var31, var37, 0, 0);
                     }
                  }

                  if (var15x != 0) {
                     setSupportValue(var1, var24, var21, var22, var23, var15x);
                  }

                  if (var14x != null) {
                     Holder var35 = var14x.clone();
                     var8.accept(var35);
                     setBlockEntity(var1, var24, var21, var22, var23, var26, var16x, var35);
                  }
               }
            }
         }, (var6x, var7x, var8x, var9x) -> {
            if (!PrefabUtil.Flags.test(var5, 8)) {
               if (var8x != null && var8x.length != 0) {
                  for (int var10 = 0; var10 < var8x.length; var10++) {
                     Holder var11 = var8x[var10].clone();
                     TransformComponent var12 = var11.getComponent(TransformComponent.getComponentType());
                     if (var12 != null) {
                        Vector3d var13 = new Vector3d(var12.getPosition());
                        var19.rotate(var13);
                        Vector3d var14 = var13.add(var2.x, var2.y, var2.z);
                        var12 = var11.getComponent(TransformComponent.getComponentType());
                        if (var12 != null) {
                           var13 = var12.getPosition();
                           var13.x = var14.x;
                           var13.y = var14.y;
                           var13.z = var14.z;
                           PrefabPlaceEntityEvent var15 = new PrefabPlaceEntityEvent(var20, var11);
                           var10.invoke(var15);
                           if (!var15.isCancelled()) {
                              var11.ensureComponent(FromPrefab.getComponentType());
                              if (PrefabUtil.Flags.test(var5, 2)) {
                                 var11.ensureComponent(PrefabCopyableComponent.getComponentType());
                              }

                              var9.accept(var11);
                              var10.addEntity(var11, AddReason.LOAD);
                           }
                        }
                     }
                  }
               }
            }
         }, (var0x, var1x, var2x, var3x, var4x, var5x, var6x, var7x, var8x, var9x) -> {}, new PrefabBufferCall(var4, var19));
         PrefabPasteEvent var22 = new PrefabPasteEvent(var20, false);
         var10.invoke(var22);
      }
   }

   class="kw">public class="kw">static void remove(
      @Nonnull IPrefabBuffer var0, @Nonnull World var1, @Nonnull Vector3i var2, @Nonnull Rotation var3, @Nonnull Random var4, int var5, int var6, double var7
   ) {
      remove(var0, var1, var2, var3, var4, var5, var6, var7, null);
   }

   class="kw">public class="kw">static void remove(
      @Nonnull IPrefabBuffer var0,
      @Nonnull World var1,
      @Nonnull Vector3i var2,
      @Nonnull Rotation var3,
      @Nonnull Random var4,
      int var5,
      int var6,
      double var7,
      @Nullable PrefabUtil.PasteRegion var9
   ) {
      int var10 = var0.getMaxX() - var0.getMinX();
      int var11 = var0.getMaxY() - var0.getMinY();
      int var12 = var0.getMaxZ() - var0.getMinZ();
      ChunkStore var13 = var1.getChunkStore();
      Store var14 = var13.getStore();
      CachedAccessor var15 = ACCESSOR.getAtBlock(var14, var2.x(), var2.y(), var2.z(), var10, var11, var12);
      preload(var15, var9);
      var0.forEach(
         IPrefabBuffer.iterateAllColumns(),
         (var8, var9x, var10x, var11x, var12x, var13x, var14x, var15x, var16, var17, var18) -> {
            int var19 = var2.x + var8;
            int var20 = var2.y + var9x;
            int var21 = var2.z + var10x;
            Ref var22 = var15.getSectionAtBlock(var19, var20, var21);
            if (var22 != null) {
               if (var17 != 0) {
                  FluidSection var23 = var14.ensureAndGetComponent(var22, FluidSection.getComponentType());
                  var23.setFluid(var19, var20, var21, 0, (byte)0);
               }

               if (var11x != 0) {
                  if (var15x == 0) {
                     int var24 = var6;
                     if ((var6 & 4) != 4 && var4.nextDouble() > var7) {
                        var24 |= 4;
                     }

                     BlockOperations.setBlock(var13, var22, var19, var20, var21, 0, BlockType.EMPTY, 0, 0, var24);
                  }
               }
            }
         },
         (var0x, var1x, var2x, var3x) -> {},
         (var0x, var1x, var2x, var3x, var4x, var5x, var6x, var7x, var8, var9x) -> {},
         new PrefabBufferCall(var4, PrefabRotation.fromRotation(var3))
      );
   }

   @Deprecated(forRemoval = true, since = "2026-06-16")
   class="kw">public class="kw">static void paste(
      @Nonnull IPrefabBuffer var0,
      @Nonnull World var1,
      @Nonnull Vector3i var2,
      @Nonnull Rotation var3,
      boolean var4,
      Random var5,
      @Nonnull ComponentAccessor<EntityStore> var6
   ) {
      paste(var0, var1, var2, var3, var4, var5, 0, var6);
   }

   @Deprecated(forRemoval = true, since = "2026-06-16")
   class="kw">public class="kw">static void paste(
      @Nonnull IPrefabBuffer var0,
      @Nonnull World var1,
      @Nonnull Vector3i var2,
      @Nonnull Rotation var3,
      boolean var4,
      Random var5,
      int var6,
      @Nonnull ComponentAccessor<EntityStore> var7
   ) {
      paste(var0, var1, var2, var3, var4, var5, var6, false, false, false, var7);
   }

   @Deprecated(forRemoval = true, since = "2026-06-16")
   class="kw">public class="kw">static void paste(
      @Nonnull IPrefabBuffer var0,
      @Nonnull World var1,
      @Nonnull Vector3i var2,
      @Nonnull Rotation var3,
      boolean var4,
      Random var5,
      int var6,
      boolean var7,
      boolean var8,
      boolean var9,
      @Nonnull ComponentAccessor<EntityStore> var10
   ) {
      int var11 = 0;
      if (var4) {
         var11 |= 1;
      }

      if (var7) {
         var11 |= 2;
      }

      if (var8) {
         var11 |= 4;
      }

      if (!var9) {
         var11 |= 8;
      }

      paste(var0, var1, var2, var3, var5, var11, var6, var10);
   }

   @Deprecated(forRemoval = true, since = "2026-06-16")
   class="kw">public class="kw">static void remove(@Nonnull IPrefabBuffer var0, @Nonnull World var1, @Nonnull Vector3i var2, boolean var3, @Nonnull Random var4, int var5) {
      remove(var0, var1, var2, var3, var4, var5, 1.0);
   }

   @Deprecated(forRemoval = true, since = "2026-06-16")
   class="kw">public class="kw">static void remove(
      @Nonnull IPrefabBuffer var0, @Nonnull World var1, @Nonnull Vector3i var2, boolean var3, @Nonnull Random var4, int var5, double var6
   ) {
      remove(var0, var1, var2, Rotation.None, var3, var4, var5, var6);
   }

   @Deprecated(forRemoval = true, since = "2026-06-16")
   class="kw">public class="kw">static void remove(
      @Nonnull IPrefabBuffer var0, @Nonnull World var1, @Nonnull Vector3i var2, Rotation var3, boolean var4, @Nonnull Random var5, int var6, double var7
   ) {
      int var9 = var4 ? 1 : 0;
      remove(var0, var1, var2, var3, var5, var9, var6, var7);
   }

   class="kw">public class="kw">interface Flags {
      int NONE = 0;
      int FORCE = 1;
      int TECHNICAL = 2;
      int ANCHOR_BLOCK = 4;
      int NO_ENTITIES = 8;

      class="kw">static boolean test(int var0, int var1) {
         class="kw">return (var0 & var1) == var1;
      }
   }

   class="kw">public class="kw">static class="kw">final class PasteRegion {
      class="kw">private class="kw">final int minX;
      class="kw">private class="kw">final int minY;
      class="kw">private class="kw">final int minZ;
      class="kw">private class="kw">final int maxX;
      class="kw">private class="kw">final int maxY;
      class="kw">private class="kw">final int maxZ;
      class="kw">private class="kw">final int sizeX;
      class="kw">private class="kw">final int sizeY;
      class="kw">private class="kw">final int sizeZ;
      class="kw">private class="kw">final Ref<ChunkStore>[] columnRefs;
      class="kw">private class="kw">final Ref<ChunkStore>[] sectionRefs;
      @Nonnull
      class="kw">public class="kw">final PrefabUtil.PasteRegion.Column[] columns;
      @Nonnull
      class="kw">public class="kw">final PrefabUtil.PasteRegion.Section[] sections;
      @Nonnull
      class="kw">private class="kw">final Store<ChunkStore> store;
      class="kw">private class="kw">final AtomicInteger loadCount = new AtomicInteger();
      class="kw">private class="kw">final AtomicBoolean fullyLoaded = new AtomicBoolean(false);

      class="kw">public PasteRegion(int var1, int var2, int var3, int var4, int var5, int var6, @Nonnull Store<ChunkStore> var7) {
         this.minX = var1;
         this.minY = var2;
         this.minZ = var3;
         this.maxX = var4;
         this.maxY = var5;
         this.maxZ = var6;
         this.store = var7;
         this.sizeX = var4 - var1 + 1;
         this.sizeY = var5 - var2 + 1;
         this.sizeZ = var6 - var3 + 1;
         this.columnRefs = new Ref[this.sizeX * this.sizeZ];
         this.sectionRefs = new Ref[this.sizeX * this.sizeY * this.sizeZ];
         this.columns = new PrefabUtil.PasteRegion.Column[this.sizeX * this.sizeZ];
         this.sections = new PrefabUtil.PasteRegion.Section[this.sizeX * this.sizeY * this.sizeZ];
         this.loadCount.set(this.columnRefs.length + this.sectionRefs.length);
      }

      class="kw">public boolean containsColumn(int var1, int var2) {
         class="kw">return var1 >= this.minX && var1 <= this.maxX && var2 >= this.minZ && var2 <= this.maxZ;
      }

      class="kw">public boolean containsSection(int var1, int var2, int var3) {
         class="kw">return var2 >= this.minY && var2 <= this.maxY && this.containsColumn(var1, var3);
      }

      class="kw">public boolean containsBlock(int var1, int var2, int var3) {
         class="kw">return this.containsSection(ChunkUtil.chunkCoordinate(var1), ChunkUtil.chunkCoordinate(var2), ChunkUtil.chunkCoordinate(var3));
      }

      @Nonnull
      class="kw">public PrefabUtil.PasteRegion.Column getColumn(int var1, int var2) {
         assert this.containsColumn(var1, var2);
         class="kw">return this.columns[this.columnIndex(var1, var2)];
      }

      @Nonnull
      class="kw">public PrefabUtil.PasteRegion.Section getSection(int var1, int var2, int var3) {
         assert this.containsSection(var1, var2, var3);
         class="kw">return this.sections[this.sectionIndex(var1, var2, var3)];
      }

      @Nonnull
      class="kw">public PrefabUtil.PasteRegion.Column getColumnAtBlock(int var1, int var2) {
         class="kw">return this.getColumn(ChunkUtil.chunkCoordinate(var1), ChunkUtil.chunkCoordinate(var2));
      }

      @Nonnull
      class="kw">public PrefabUtil.PasteRegion.Section getSectionAtBlock(int var1, int var2, int var3) {
         class="kw">return this.getSection(ChunkUtil.chunkCoordinate(var1), ChunkUtil.chunkCoordinate(var2), ChunkUtil.chunkCoordinate(var3));
      }

      @Nullable
      class="kw">private Ref<ChunkStore> getSectionRef(int var1, int var2, int var3) {
         assert this.containsSection(var1, var2, var3);
         class="kw">return this.sectionRefs[this.sectionIndex(var1, var2, var3)];
      }

      class="kw">public boolean isFullyLoaded() {
         class="kw">return this.fullyLoaded.get();
      }

      class="kw">private PrefabUtil.PasteRegion completeLoad() {
         this.store.assertThread();
         boolean var1 = true;
         ComponentType var2 = WorldChunk.getComponentType();

         for (int var3 = 0; var3 < this.columnRefs.length; var3++) {
            if (this.columnRefs[var3] != null && this.columnRefs[var3].isValid()) {
               this.columns[var3] = new PrefabUtil.PasteRegion.Column(this.store.getComponent(this.columnRefs[var3], var2));
            } else {
               this.columns[var3] = PrefabUtil.PasteRegion.Column.EMPTY;
               var1 = false;
            }
         }

         ComponentType var9 = BlockSection.getComponentType();
         ComponentType var4 = FluidSection.getComponentType();
         ComponentType var5 = BlockPhysics.getComponentType();
         ComponentType var6 = EntitySection.getComponentType();
         ComponentType var7 = BlockComponentSection.getComponentType();

         for (int var8 = 0; var8 < this.sectionRefs.length; var8++) {
            if (this.sectionRefs[var8] != null && this.sectionRefs[var8].isValid()) {
               this.sections[var8] = new PrefabUtil.PasteRegion.Section(
                  this.store.getComponent(this.sectionRefs[var8], var9),
                  this.store.getComponent(this.sectionRefs[var8], var4),
                  this.store.getComponent(this.sectionRefs[var8], var5),
                  this.store.getComponent(this.sectionRefs[var8], var6),
                  this.store.getComponent(this.sectionRefs[var8], var7)
               );
            } else {
               this.sections[var8] = PrefabUtil.PasteRegion.Section.EMPTY;
               var1 = false;
            }
         }

         this.fullyLoaded.set(var1);
         class="kw">return this;
      }

      class="kw">private void set(int var1, int var2, @Nullable Ref<ChunkStore> var3) {
         int var4 = this.columnIndex(var1, var2);
         this.columnRefs[var4] = var3;
      }

      class="kw">private void set(int var1, int var2, int var3, @Nullable Ref<ChunkStore> var4) {
         int var5 = this.sectionIndex(var1, var2, var3);
         this.sectionRefs[var5] = var4;
      }

      class="kw">private void awaitLoad(int var1, int var2, @Nonnull CompletableFuture<PrefabUtil.PasteRegion> var3, @Nonnull CompletableFuture<Ref<ChunkStore>> var4) {
         int var5 = this.columnIndex(var1, var2);
         var4.whenComplete((var3x, var4x) -> {
            if (!var3.isDone()) {
               if (var4x != null) {
                  var3.completeExceptionally(var4x);
               } else {
                  this.columnRefs[var5] = (Ref<ChunkStore>)var3x;
                  if (this.loadCount.decrementAndGet() == 0) {
                     var3.complete(this);
                  }
               }
            }
         });
      }

      class="kw">private void awaitLoad(
         int var1, int var2, int var3, @Nonnull CompletableFuture<PrefabUtil.PasteRegion> var4, @Nonnull CompletableFuture<Ref<ChunkStore>> var5
      ) {
         int var6 = this.sectionIndex(var1, var2, var3);
         var5.whenComplete((var3x, var4x) -> {
            if (!var4.isDone()) {
               if (var4x != null) {
                  var4.completeExceptionally(var4x);
               } else {
                  this.sectionRefs[var6] = (Ref<ChunkStore>)var3x;
                  if (this.loadCount.decrementAndGet() == 0) {
                     var4.complete(this);
                  }
               }
            }
         });
      }

      class="kw">private int columnIndex(int var1, int var2) {
         class="kw">return var1 - this.minX + (var2 - this.minZ) * this.sizeX;
      }

      class="kw">private int sectionIndex(int var1, int var2, int var3) {
         class="kw">return var2 - this.minY + (var1 - this.minX) * this.sizeY + (var3 - this.minZ) * this.sizeY * this.sizeX;
      }

      class="kw">public record Column(@Nullable WorldChunk worldChunk) {
         class="kw">private class="kw">static class="kw">final PrefabUtil.PasteRegion.Column EMPTY = new PrefabUtil.PasteRegion.Column(null);

         class="kw">public Column {
         }
      }

      class="kw">public record Section(
         @Nullable BlockSection blocks,
         @Nullable FluidSection fluids,
         @Nullable BlockPhysics physics,
         @Nullable EntitySection entities,
         @Nullable BlockComponentSection blockComponents
      ) {
         class="kw">private class="kw">static class="kw">final PrefabUtil.PasteRegion.Section EMPTY = new PrefabUtil.PasteRegion.Section(null, null, null, null, null);

         class="kw">public Section {
         }

         class="kw">public int getBlock(int var1) {
            class="kw">return this.blocks == null ? 0 : this.blocks.get(var1);
         }

         class="kw">public int getFiller(int var1) {
            class="kw">return this.blocks == null ? 0 : this.blocks.getFiller(var1);
         }

         class="kw">public int getRotation(int var1) {
            class="kw">return this.blocks == null ? 0 : this.blocks.getRotationIndex(var1);
         }

         class="kw">public byte getSupport(int var1) {
            class="kw">return this.physics == null ? 0 : (byte)this.physics.get(var1);
         }

         class="kw">public int getFluid(int var1) {
            class="kw">return this.fluids == null ? 0 : this.fluids.getFluidId(var1);
         }

         class="kw">public byte getFluidLevel(int var1) {
            class="kw">return this.fluids == null ? 0 : this.fluids.getFluidLevel(var1);
         }

         @Nullable
         class="kw">public Holder<ChunkStore> getState(int var1) {
            if (this.blockComponents == null) {
               class="kw">return null;
            }

            Holder var2 = this.blockComponents.getBlockHolder(var1);
            class="kw">return var2 == null ? null : var2.clone();
         }
      }
   }
}