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

class="kw">import com.hypixel.fastutil.shorts.Short2ObjectConcurrentHashMap;
class="kw">import com.hypixel.hytale.codec.lookup.CodecMapCodec;
class="kw">import com.hypixel.hytale.event.EventPriority;
class="kw">import com.hypixel.hytale.event.EventRegistration;
class="kw">import com.hypixel.hytale.event.IEvent;
class="kw">import com.hypixel.hytale.event.SyncEventBusRegistry;
class="kw">import com.hypixel.hytale.function.consumer.ShortObjectConsumer;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.protocol.InventorySection;
class="kw">import com.hypixel.hytale.protocol.ItemResourceType;
class="kw">import com.hypixel.hytale.protocol.ItemWithAllMetadata;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.config.Item;
class="kw">import com.hypixel.hytale.server.core.inventory.ItemStack;
class="kw">import com.hypixel.hytale.server.core.inventory.MaterialQuantity;
class="kw">import com.hypixel.hytale.server.core.inventory.ResourceQuantity;
class="kw">import com.hypixel.hytale.server.core.inventory.container.filter.FilterActionType;
class="kw">import com.hypixel.hytale.server.core.inventory.container.filter.FilterType;
class="kw">import com.hypixel.hytale.server.core.inventory.container.filter.SlotFilter;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.ActionType;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.ClearTransaction;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.ItemStackSlotTransaction;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.ItemStackTransaction;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.ListTransaction;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.MaterialSlotTransaction;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.MaterialTransaction;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.MoveTransaction;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.MoveType;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.ResourceSlotTransaction;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.ResourceTransaction;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.SlotTransaction;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.TagSlotTransaction;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.TagTransaction;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.Transaction;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.ints.IntArrays;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collections;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.function.Consumer;
class="kw">import java.util.function.Function;
class="kw">import java.util.function.Predicate;
class="kw">import java.util.function.Supplier;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class="kw">abstract class ItemContainer {
   class="kw">public class="kw">static class="kw">final CodecMapCodec<ItemContainer> CODEC = new CodecMapCodec<>(true);
   class="kw">public class="kw">static class="kw">final boolean DEFAULT_ADD_ALL_OR_NOTHING = false;
   class="kw">public class="kw">static class="kw">final boolean DEFAULT_REMOVE_ALL_OR_NOTHING = true;
   class="kw">public class="kw">static class="kw">final boolean DEFAULT_FULL_STACKS = false;
   class="kw">public class="kw">static class="kw">final boolean DEFAULT_EXACT_AMOUNT = true;
   class="kw">public class="kw">static class="kw">final boolean DEFAULT_FILTER = true;
   class="kw">protected class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">protected class="kw">final SyncEventBusRegistry<Void, ItemContainer.ItemContainerChangeEvent> externalChangeEventRegistry = new SyncEventBusRegistry<>(
      LOGGER, ItemContainer.ItemContainerChangeEvent.class
   );
   class="kw">protected class="kw">final SyncEventBusRegistry<Void, ItemContainer.ItemContainerChangeEvent> internalChangeEventRegistry = new SyncEventBusRegistry<>(
      LOGGER, ItemContainer.ItemContainerChangeEvent.class
   );

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

   class="kw">public class="kw">abstract short getCapacity();

   class="kw">public class="kw">abstract void setGlobalFilter(FilterType var1);

   class="kw">public class="kw">abstract void setSlotFilter(FilterActionType var1, short var2, SlotFilter var3);

   class="kw">public class="kw">abstract ItemContainer clone();

   class="kw">protected class="kw">abstract <V> V readAction(Supplier<V> var1);

   class="kw">protected class="kw">abstract <X, V> V readAction(Function<X, V> var1, X var2);

   class="kw">protected class="kw">abstract <V> V writeAction(Supplier<V> var1);

   class="kw">protected class="kw">abstract <X, V> V writeAction(Function<X, V> var1, X var2);

   class="kw">protected class="kw">abstract void lockForRead();

   class="kw">protected class="kw">abstract void unlockForRead();

   class="kw">protected class="kw">abstract void lockForWrite();

   class="kw">protected class="kw">abstract void unlockForWrite();

   class="kw">protected class="kw">abstract ClearTransaction internal_clear();

   @Nullable
   class="kw">protected class="kw">abstract ItemStack internal_getSlot(short var1);

   @Nullable
   class="kw">protected class="kw">abstract ItemStack internal_setSlot(short var1, ItemStack var2);

   @Nullable
   class="kw">protected class="kw">abstract ItemStack internal_removeSlot(short var1);

   class="kw">protected class="kw">abstract boolean cantAddToSlot(short var1, ItemStack var2, ItemStack var3);

   class="kw">protected class="kw">abstract boolean cantRemoveFromSlot(short var1);

   class="kw">protected class="kw">abstract boolean cantDropFromSlot(short var1);

   class="kw">protected class="kw">abstract boolean cantMoveToSlot(ItemContainer var1, short var2);

   @Nonnull
   class="kw">public InventorySection toPacket() {
      InventorySection var1 = new InventorySection();
      var1.capacity = this.getCapacity();
      var1.items = this.toProtocolMap();
      class="kw">return var1;
   }

   @Nonnull
   class="kw">public Map<Integer, ItemWithAllMetadata> toProtocolMap() {
      Map var1 = new Int2ObjectOpenHashMap();
      this.forEachWithMeta((var0, var1x, var2) -> {
         if (!ItemStack.isEmpty(var1x) && var1x.isValid()) {
            var2.put(Integer.valueOf(var0), var1x.toPacket());
         }
      }, var1);
      class="kw">return var1;
   }

   class="kw">public EventRegistration<Void, ItemContainer.ItemContainerChangeEvent> registerChangeEvent(@Nonnull Consumer<ItemContainer.ItemContainerChangeEvent> var1) {
      class="kw">return this.registerChangeEvent((short)0, var1);
   }

   class="kw">public EventRegistration<Void, ItemContainer.ItemContainerChangeEvent> registerChangeEvent(
      @Nonnull EventPriority var1, @Nonnull Consumer<ItemContainer.ItemContainerChangeEvent> var2
   ) {
      class="kw">return this.registerChangeEvent(var1.getValue(), var2);
   }

   class="kw">public EventRegistration<Void, ItemContainer.ItemContainerChangeEvent> registerChangeEvent(
      short var1, @Nonnull Consumer<ItemContainer.ItemContainerChangeEvent> var2
   ) {
      class="kw">return this.externalChangeEventRegistry.register(var1, null, var2);
   }

   class="kw">public ClearTransaction clear() {
      ClearTransaction var1 = this.writeAction(this::internal_clear);
      this.sendUpdate(var1);
      class="kw">return var1;
   }

   class="kw">public boolean canAddItemStackToSlot(short var1, @Nonnull ItemStack var2, boolean var3, boolean var4) {
      validateSlotIndex(var1, this.getCapacity());
      class="kw">return this.writeAction(() -> {
         int var5 = var2.getQuantity();
         ItemStack var6 = this.internal_getSlot(var1);
         if (var4 && this.cantAddToSlot(var1, var2, var6)) {
            class="kw">return false;
         }

         if (var6 == null) {
            class="kw">return true;
         }

         if (!var2.isStackableWith(var6)) {
            class="kw">return false;
         }

         int var7 = var6.getQuantity();
         int var8 = Math.min(var6.getItem().getMaxStack() - var7, var5);
         int var9 = var5 - var8;
         class="kw">return var3 ? var5 <= 0 : var5 != var9;
      });
   }

   @Nonnull
   class="kw">public ItemStackSlotTransaction addItemStackToSlot(short var1, @Nonnull ItemStack var2) {
      class="kw">return this.addItemStackToSlot(var1, var2, false, true);
   }

   @Nonnull
   class="kw">public ItemStackSlotTransaction addItemStackToSlot(short var1, @Nonnull ItemStack var2, boolean var3, boolean var4) {
      ItemStackSlotTransaction var5 = InternalContainerUtilItemStack.internal_addItemStackToSlot(this, var1, var2, var3, var4);
      this.sendUpdate(var5);
      class="kw">return var5;
   }

   @Nonnull
   class="kw">public ItemStackSlotTransaction setItemStackForSlot(short var1, ItemStack var2) {
      class="kw">return this.setItemStackForSlot(var1, var2, true);
   }

   @Nonnull
   class="kw">public ItemStackSlotTransaction setItemStackForSlot(short var1, ItemStack var2, boolean var3) {
      ItemStackSlotTransaction var4 = InternalContainerUtilItemStack.internal_setItemStackForSlot(this, var1, var2, var3);
      this.sendUpdate(var4);
      class="kw">return var4;
   }

   @Nullable
   class="kw">public ItemStack getItemStack(short var1) {
      validateSlotIndex(var1, this.getCapacity());
      class="kw">return this.readAction(() -> this.internal_getSlot(var1));
   }

   @Nonnull
   class="kw">public ItemStackSlotTransaction replaceItemStackInSlot(short var1, ItemStack var2, ItemStack var3) {
      ItemStackSlotTransaction var4 = this.internal_replaceItemStack(var1, var2, var3);
      this.sendUpdate(var4);
      class="kw">return var4;
   }

   class="kw">public ListTransaction<ItemStackSlotTransaction> replaceAll(SlotReplacementFunction var1) {
      class="kw">return this.replaceAll(var1, true);
   }

   class="kw">private ListTransaction<ItemStackSlotTransaction> replaceAll(SlotReplacementFunction var1, boolean var2) {
      ListTransaction var3 = this.writeAction(() -> {
         short var3 = this.getCapacity();
         ObjectArrayList var4 = new ObjectArrayList(var3);

         for (short var5 = 0; var5 < var3; var5++) {
            ItemStack var6 = this.internal_getSlot(var5);
            if (!var2 || !ItemStack.isEmpty(var6)) {
               ItemStack var7 = var1.replace(var5, var6);
               this.internal_setSlot(var5, var7);
               var4.add(new ItemStackSlotTransaction(true, ActionType.REPLACE, var5, var6, var7, var6, true, false, false, false, var7, var7));
            }
         }

         class="kw">return new ListTransaction<>(true, var4);
      });
      this.sendUpdate(var3);
      class="kw">return var3;
   }

   class="kw">protected ItemStackSlotTransaction internal_replaceItemStack(short var1, @Nullable ItemStack var2, ItemStack var3) {
      validateSlotIndex(var1, this.getCapacity());
      class="kw">return this.writeAction(() -> {
         ItemStack var4 = this.internal_getSlot(var1);
         if ((var4 != null || var2 == null) && (var4 == null || var2 != null) && (var4 == null || var2.isStackableWith(var4))) {
            this.internal_setSlot(var1, var3);
            class="kw">return new ItemStackSlotTransaction(true, ActionType.REPLACE, var1, var4, var3, var4, true, false, false, false, var3, null);
         } else {
            class="kw">return new ItemStackSlotTransaction(false, ActionType.REPLACE, var1, var4, var4, null, true, false, false, false, var3, var3);
         }
      });
   }

   @Nonnull
   class="kw">public SlotTransaction removeItemStackFromSlot(short var1) {
      class="kw">return this.removeItemStackFromSlot(var1, true);
   }

   @Nonnull
   class="kw">public SlotTransaction removeItemStackFromSlot(short var1, boolean var2) {
      SlotTransaction var3 = InternalContainerUtilItemStack.internal_removeItemStackFromSlot(this, var1, var2);
      this.sendUpdate(var3);
      class="kw">return var3;
   }

   @Nonnull
   class="kw">public ItemStackSlotTransaction removeItemStackFromSlot(short var1, int var2) {
      class="kw">return this.removeItemStackFromSlot(var1, var2, true, true);
   }

   @Nonnull
   class="kw">public ItemStackSlotTransaction removeItemStackFromSlot(short var1, int var2, boolean var3, boolean var4) {
      ItemStackSlotTransaction var5 = InternalContainerUtilItemStack.internal_removeItemStackFromSlot(this, var1, var2, var3, var4);
      this.sendUpdate(var5);
      class="kw">return var5;
   }

   @Deprecated
   class="kw">public ItemStackSlotTransaction internal_removeItemStack(short var1, int var2) {
      class="kw">return InternalContainerUtilItemStack.internal_removeItemStackFromSlot(this, var1, var2, true, true);
   }

   @Nonnull
   class="kw">public ItemStackSlotTransaction removeItemStackFromSlot(short var1, ItemStack var2, int var3) {
      class="kw">return this.removeItemStackFromSlot(var1, var2, var3, true, true);
   }

   @Nonnull
   class="kw">public ItemStackSlotTransaction removeItemStackFromSlot(short var1, ItemStack var2, int var3, boolean var4, boolean var5) {
      ItemStackSlotTransaction var6 = InternalContainerUtilItemStack.internal_removeItemStackFromSlot(this, var1, var2, var3, var4, var5);
      this.sendUpdate(var6);
      class="kw">return var6;
   }

   @Nonnull
   class="kw">public MaterialSlotTransaction removeMaterialFromSlot(short var1, @Nonnull MaterialQuantity var2) {
      class="kw">return this.removeMaterialFromSlot(var1, var2, true, true, true);
   }

   @Nonnull
   class="kw">public MaterialSlotTransaction removeMaterialFromSlot(short var1, @Nonnull MaterialQuantity var2, boolean var3, boolean var4, boolean var5) {
      MaterialSlotTransaction var6 = InternalContainerUtilMaterial.internal_removeMaterialFromSlot(this, var1, var2, var3, var5);
      this.sendUpdate(var6);
      class="kw">return var6;
   }

   @Nonnull
   class="kw">public ResourceSlotTransaction removeResourceFromSlot(short var1, @Nonnull ResourceQuantity var2) {
      class="kw">return this.removeResourceFromSlot(var1, var2, true, true, true);
   }

   @Nonnull
   class="kw">public ResourceSlotTransaction removeResourceFromSlot(short var1, @Nonnull ResourceQuantity var2, boolean var3, boolean var4, boolean var5) {
      ResourceSlotTransaction var6 = InternalContainerUtilResource.internal_removeResourceFromSlot(this, var1, var2, var3, var5);
      this.sendUpdate(var6);
      class="kw">return var6;
   }

   @Nonnull
   class="kw">public TagSlotTransaction removeTagFromSlot(short var1, int var2, int var3) {
      class="kw">return this.removeTagFromSlot(var1, var2, var3, true, true);
   }

   @Nonnull
   class="kw">public TagSlotTransaction removeTagFromSlot(short var1, int var2, int var3, boolean var4, boolean var5) {
      TagSlotTransaction var6 = InternalContainerUtilTag.internal_removeTagFromSlot(this, var1, var2, var3, var4, var5);
      this.sendUpdate(var6);
      class="kw">return var6;
   }

   @Nonnull
   class="kw">public MoveTransaction<ItemStackTransaction> moveItemStackFromSlot(short var1, @Nonnull ItemContainer var2) {
      class="kw">return this.moveItemStackFromSlot(var1, var2, true);
   }

   @Nonnull
   class="kw">public MoveTransaction<ItemStackTransaction> moveItemStackFromSlot(short var1, @Nonnull ItemContainer var2, boolean var3) {
      class="kw">return this.moveItemStackFromSlot(var1, var2, false, var3);
   }

   @Nonnull
   class="kw">public MoveTransaction<ItemStackTransaction> moveItemStackFromSlot(short var1, @Nonnull ItemContainer var2, boolean var3, boolean var4) {
      MoveTransaction var5 = this.internal_moveItemStackFromSlot(var1, var2, var3, var4);
      this.sendUpdate(var5);
      var2.sendUpdate(var5.toInverted(this));
      class="kw">return var5;
   }

   class="kw">protected MoveTransaction<ItemStackTransaction> internal_moveItemStackFromSlot(short var1, @Nonnull ItemContainer var2, boolean var3, boolean var4) {
      validateSlotIndex(var1, this.getCapacity());
      class="kw">return this.writeAction(() -> var2.writeAction(() -> {
         if (var4 && this.cantRemoveFromSlot(var1)) {
            class="kw">return null;
         }

         ItemStack var5 = this.internal_removeSlot(var1);
         if (ItemStack.isEmpty(var5)) {
            SlotTransaction var9 = new SlotTransaction(false, ActionType.REMOVE, var1, null, null, null, false, false, var4);
            class="kw">return new MoveTransaction<>(false, var9, MoveType.MOVE_FROM_SELF, var2, ItemStackTransaction.FAILED_ADD);
         }

         SlotTransaction var6 = new SlotTransaction(true, ActionType.REMOVE, var1, var5, null, null, false, false, var4);
         ItemStackTransaction var7 = InternalContainerUtilItemStack.internal_addItemStack(var2, var5, var3, false, var4);
         ItemStack var8 = var7.getRemainder();
         if (!ItemStack.isEmpty(var8)) {
            InternalContainerUtilItemStack.internal_addItemStackToSlot(this, var1, var8, var3, false);
         }

         class="kw">return new MoveTransaction<>(var7.succeeded(), var6, MoveType.MOVE_FROM_SELF, var2, var7);
      }));
   }

   @Nonnull
   class="kw">public MoveTransaction<ItemStackTransaction> moveItemStackFromSlot(short var1, int var2, @Nonnull ItemContainer var3) {
      class="kw">return this.moveItemStackFromSlot(var1, var2, var3, false, true);
   }

   @Nonnull
   class="kw">public MoveTransaction<ItemStackTransaction> moveItemStackFromSlot(short var1, int var2, @Nonnull ItemContainer var3, boolean var4, boolean var5) {
      MoveTransaction var6 = this.internal_moveItemStackFromSlot(var1, var2, var3, var4, var5);
      this.sendUpdate(var6);
      var3.sendUpdate(var6.toInverted(this));
      class="kw">return var6;
   }

   class="kw">protected MoveTransaction<ItemStackTransaction> internal_moveItemStackFromSlot(short var1, int var2, @Nonnull ItemContainer var3, boolean var4, boolean var5) {
      validateSlotIndex(var1, this.getCapacity());
      validateQuantity(var2);
      class="kw">return this.writeAction(() -> var3.writeAction(() -> {
         if (var5 && this.cantRemoveFromSlot(var1)) {
            class="kw">return null;
         }

         if (var5 && var3.cantMoveToSlot(this, var1)) {
            ItemStack var10 = this.internal_getSlot(var1);
            SlotTransaction var12 = new SlotTransaction(false, ActionType.REMOVE, var1, var10, var10, null, false, false, var5);
            class="kw">return new MoveTransaction<>(false, var12, MoveType.MOVE_FROM_SELF, var3, ItemStackTransaction.FAILED_ADD);
         }

         ItemStackSlotTransaction var6 = this.internal_removeItemStack(var1, var2);
         if (!var6.succeeded()) {
            SlotTransaction var11 = new SlotTransaction(false, ActionType.REMOVE, var1, null, null, null, false, false, var5);
            class="kw">return new MoveTransaction<>(false, var11, MoveType.MOVE_FROM_SELF, var3, ItemStackTransaction.FAILED_ADD);
         }

         ItemStack var7 = var6.getOutput();
         if (ItemStack.isEmpty(var7)) {
            SlotTransaction var13 = new SlotTransaction(false, ActionType.REMOVE, var1, null, null, null, false, false, var5);
            class="kw">return new MoveTransaction<>(false, var13, MoveType.MOVE_FROM_SELF, var3, ItemStackTransaction.FAILED_ADD);
         }

         ItemStackTransaction var8 = InternalContainerUtilItemStack.internal_addItemStack(var3, var7, var4, false, var5);
         ItemStack var9 = var8.getRemainder();
         if (!ItemStack.isEmpty(var9)) {
            InternalContainerUtilItemStack.internal_addItemStackToSlot(this, var1, var9, var4, false);
         }

         class="kw">return new MoveTransaction<>(var8.succeeded(), var6, MoveType.MOVE_FROM_SELF, var3, var8);
      }));
   }

   @Nonnull
   class="kw">public ListTransaction<MoveTransaction<ItemStackTransaction>> moveItemStackFromSlot(short var1, ItemContainer... var2) {
      class="kw">return this.moveItemStackFromSlot(var1, false, true, var2);
   }

   @Nonnull
   class="kw">public ListTransaction<MoveTransaction<ItemStackTransaction>> moveItemStackFromSlot(short var1, boolean var2, boolean var3, @Nonnull ItemContainer... var4) {
      ListTransaction var5 = this.internal_moveItemStackFromSlot(var1, var2, var3, var4);
      this.sendUpdate(var5);

      for (MoveTransaction var7 : var5.getList()) {
         var7.getOtherContainer().sendUpdate(var7.toInverted(this));
      }

      class="kw">return var5;
   }

   @Nonnull
   class="kw">private ListTransaction<MoveTransaction<ItemStackTransaction>> internal_moveItemStackFromSlot(
      short var1, boolean var2, boolean var3, @Nonnull ItemContainer[] var4
   ) {
      List var5 = new ObjectArrayList();
      boolean var6 = false;

      for (ItemContainer var10 : var4) {
         MoveTransaction var11 = this.internal_moveItemStackFromSlot(var1, var10, var2, var3);
         var5.add(var11);
         if (var11.succeeded()) {
            var6 = true;
            ItemStackTransaction var12 = var11.getAddTransaction();
            if (ItemStack.isEmpty(var12.getRemainder())) {
               break;
            }
         }
      }

      class="kw">return new ListTransaction<>(var6, var5);
   }

   @Nonnull
   class="kw">public ListTransaction<MoveTransaction<ItemStackTransaction>> moveItemStackFromSlot(short var1, int var2, ItemContainer... var3) {
      class="kw">return this.moveItemStackFromSlot(var1, var2, false, true, var3);
   }

   @Nonnull
   class="kw">public ListTransaction<MoveTransaction<ItemStackTransaction>> moveItemStackFromSlot(
      short var1, int var2, boolean var3, boolean var4, @Nonnull ItemContainer... var5
   ) {
      ListTransaction var6 = this.internal_moveItemStackFromSlot(var1, var2, var3, var4, var5);
      this.sendUpdate(var6);

      for (MoveTransaction var8 : var6.getList()) {
         var8.getOtherContainer().sendUpdate(var8.toInverted(this));
      }

      class="kw">return var6;
   }

   @Nonnull
   class="kw">private ListTransaction<MoveTransaction<ItemStackTransaction>> internal_moveItemStackFromSlot(
      short var1, int var2, boolean var3, boolean var4, @Nonnull ItemContainer[] var5
   ) {
      List var6 = new ObjectArrayList();
      boolean var7 = false;

      for (ItemContainer var11 : var5) {
         MoveTransaction var12 = this.internal_moveItemStackFromSlot(var1, var2, var11, var3, var4);
         var6.add(var12);
         if (var12.succeeded()) {
            var7 = true;
            ItemStackTransaction var13 = var12.getAddTransaction();
            if (ItemStack.isEmpty(var13.getRemainder())) {
               break;
            }
         }
      }

      class="kw">return new ListTransaction<>(var7, var6);
   }

   @Nonnull
   class="kw">public MoveTransaction<SlotTransaction> moveItemStackFromSlotToSlot(short var1, int var2, @Nonnull ItemContainer var3, short var4) {
      class="kw">return this.moveItemStackFromSlotToSlot(var1, var2, var3, var4, true);
   }

   @Nonnull
   class="kw">public MoveTransaction<SlotTransaction> moveItemStackFromSlotToSlot(short var1, int var2, @Nonnull ItemContainer var3, short var4, boolean var5) {
      MoveTransaction var6 = this.internal_moveItemStackFromSlot(var1, var2, var3, var4, var5);
      this.sendUpdate(var6);
      var3.sendUpdate(var6.toInverted(this));
      class="kw">return var6;
   }

   class="kw">protected MoveTransaction<SlotTransaction> internal_moveItemStackFromSlot(short var1, int var2, @Nonnull ItemContainer var3, short var4, boolean var5) {
      validateSlotIndex(var1, this.getCapacity());
      validateSlotIndex(var4, var3.getCapacity());
      validateQuantity(var2);
      class="kw">return this.writeAction(
         () -> var3.writeAction(
            () -> {
               if (var5 && this.cantRemoveFromSlot(var1)) {
                  ItemStack var15 = this.internal_getSlot(var1);
                  SlotTransaction var17 = new SlotTransaction(false, ActionType.REMOVE, var1, var15, var15, null, false, false, var5);
                  class="kw">return new MoveTransaction<>(false, var17, MoveType.MOVE_FROM_SELF, var3, SlotTransaction.FAILED_ADD);
               }

               if (var5 && var3.cantMoveToSlot(this, var1)) {
                  ItemStack var14 = this.internal_getSlot(var1);
                  SlotTransaction var16 = new SlotTransaction(false, ActionType.REMOVE, var1, var14, var14, null, false, false, var5);
                  class="kw">return new MoveTransaction<>(false, var16, MoveType.MOVE_FROM_SELF, var3, SlotTransaction.FAILED_ADD);
               }

               ItemStackSlotTransaction var6 = this.internal_removeItemStack(var1, var2);
               if (!var6.succeeded()) {
                  class="kw">return new MoveTransaction<>(false, var6, MoveType.MOVE_FROM_SELF, var3, SlotTransaction.FAILED_ADD);
               }

               ItemStack var7 = var6.getOutput();
               if (ItemStack.isEmpty(var7)) {
                  class="kw">return new MoveTransaction<>(true, var6, MoveType.MOVE_FROM_SELF, var3, SlotTransaction.FAILED_ADD);
               }

               ItemStack var8 = var3.getItemStack(var4);
               if (var5 && var3.cantAddToSlot(var4, var7, var8)) {
                  this.internal_setSlot(var1, var6.getSlotBefore());
                  SlotTransaction var22 = new SlotTransaction(
                     true, ActionType.REMOVE, var1, var6.getSlotBefore(), var6.getSlotAfter(), null, false, false, var5
                  );
                  SlotTransaction var26 = new SlotTransaction(false, ActionType.ADD, var4, var8, var8, null, false, false, var5);
                  class="kw">return new MoveTransaction<>(false, var22, MoveType.MOVE_FROM_SELF, var3, var26);
               }

               if (ItemStack.isEmpty(var8)) {
                  ItemStackSlotTransaction var21 = InternalContainerUtilItemStack.internal_setItemStackForSlot(var3, var4, var7, var5);
                  class="kw">return new MoveTransaction<>(true, var6, MoveType.MOVE_FROM_SELF, var3, var21);
               }

               if (!var7.isStackableWith(var8)) {
                  if (ItemStack.isEmpty(var6.getSlotAfter())) {
                     if (var5 && this.cantAddToSlot(var1, var8, var7)) {
                        this.internal_setSlot(var1, var6.getSlotBefore());
                        SlotTransaction var20 = new SlotTransaction(
                           true, ActionType.REMOVE, var1, var6.getSlotBefore(), var6.getSlotAfter(), null, false, false, var5
                        );
                        SlotTransaction var25 = new SlotTransaction(false, ActionType.ADD, var4, var8, var8, null, false, false, var5);
                        class="kw">return new MoveTransaction<>(false, var20, MoveType.MOVE_FROM_SELF, var3, var25);
                     } else {
                        this.internal_setSlot(var1, var8);
                        var3.internal_setSlot(var4, var7);
                        SlotTransaction var19 = new SlotTransaction(true, ActionType.REPLACE, var1, var7, var8, null, false, false, var5);
                        SlotTransaction var24 = new SlotTransaction(true, ActionType.REPLACE, var4, var8, var7, null, false, false, var5);
                        class="kw">return new MoveTransaction<>(true, var19, MoveType.MOVE_FROM_SELF, var3, var24);
                     }
                  } else {
                     this.internal_setSlot(var1, var6.getSlotBefore());
                     SlotTransaction var18 = new SlotTransaction(
                        true, ActionType.REMOVE, var1, var6.getSlotBefore(), var6.getSlotAfter(), null, false, false, var5
                     );
                     SlotTransaction var23 = new SlotTransaction(false, ActionType.ADD, var4, var8, var8, null, false, false, var5);
                     class="kw">return new MoveTransaction<>(false, var18, MoveType.MOVE_FROM_SELF, var3, var23);
                  }
               } else {
                  int var9 = var7.getItem().getMaxStack();
                  int var10 = var7.getQuantity() + var8.getQuantity();
                  if (var10 <= var9) {
                     ItemStackSlotTransaction var27 = InternalContainerUtilItemStack.internal_setItemStackForSlot(var3, var4, var8.withQuantity(var10), var5);
                     class="kw">return new MoveTransaction<>(true, var6, MoveType.MOVE_FROM_SELF, var3, var27);
                  } else {
                     ItemStackSlotTransaction var11 = InternalContainerUtilItemStack.internal_setItemStackForSlot(var3, var4, var8.withQuantity(var9), var5);
                     int var12 = var10 - var9;
                     int var13 = !ItemStack.isEmpty(var6.getSlotAfter()) ? var6.getSlotAfter().getQuantity() : 0;
                     this.internal_setSlot(var1, var7.withQuantity(var12 + var13));
                     class="kw">return new MoveTransaction<>(true, var6, MoveType.MOVE_FROM_SELF, var3, var11);
                  }
               }
            }
         )
      );
   }

   @Nonnull
   class="kw">public ListTransaction<MoveTransaction<ItemStackTransaction>> moveAllItemStacksTo(ItemContainer... var1) {
      class="kw">return this.moveAllItemStacksTo(null, var1);
   }

   @Nonnull
   class="kw">public ListTransaction<MoveTransaction<ItemStackTransaction>> moveAllItemStacksTo(Predicate<ItemStack> var1, ItemContainer... var2) {
      ListTransaction var3 = this.internal_moveAllItemStacksTo(var1, var2);
      this.sendUpdate(var3);

      for (MoveTransaction var5 : var3.getList()) {
         var5.getOtherContainer().sendUpdate(var5.toInverted(this));
      }

      class="kw">return var3;
   }

   @Nonnull
   class="kw">protected ListTransaction<MoveTransaction<ItemStackTransaction>> internal_moveAllItemStacksTo(@Nullable Predicate<ItemStack> var1, ItemContainer[] var2) {
      class="kw">return this.writeAction(() -> {
         List var3 = new ObjectArrayList();
         boolean var4 = false;

         for (short var6 = 0; var6 < this.getCapacity(); var6++) {
            if (!this.cantRemoveFromSlot(var6)) {
               ItemStack var5 = this.internal_getSlot(var6);
               if (!ItemStack.isEmpty(var5) && (var1 == null || var1.test(var5))) {
                  for (MoveTransaction var8 : this.moveItemStackFromSlot(var6, var2).getList()) {
                     var3.add(var8);
                     if (var8.succeeded()) {
                        var4 = true;
                     }
                  }
               }
            }
         }

         class="kw">return new ListTransaction<>(var3.isEmpty() || var4, var3);
      });
   }

   @Nonnull
   class="kw">public ListTransaction<MoveTransaction<ItemStackTransaction>> quickStackTo(@Nonnull ItemContainer... var1) {
      class="kw">return this.moveAllItemStacksTo(var1x -> {
         for (ItemContainer var5 : var1) {
            if (var5.containsItemStacksStackableWith(var1x)) {
               class="kw">return true;
            }
         }

         class="kw">return false;
      }, var1);
   }

   @Nonnull
   class="kw">public ListTransaction<MoveTransaction<SlotTransaction>> combineItemStacksIntoSlot(@Nonnull ItemContainer var1, short var2) {
      ListTransaction var3 = this.internal_combineItemStacksIntoSlot(var1, var2);
      this.sendUpdate(var3);

      for (MoveTransaction var5 : var3.getList()) {
         var5.getOtherContainer().sendUpdate(var5.toInverted(this));
      }

      class="kw">return var3;
   }

   @Nonnull
   class="kw">protected ListTransaction<MoveTransaction<SlotTransaction>> internal_combineItemStacksIntoSlot(@Nonnull ItemContainer var1, short var2) {
      validateSlotIndex(var2, var1.getCapacity());
      class="kw">return this.writeAction(() -> {
         ItemStack var3 = var1.internal_getSlot(var2);
         Item var4 = var3.getItem();
         int var5 = var4.getMaxStack();
         if (!ItemStack.isEmpty(var3) && var3.getQuantity() < var5) {
            int var6 = 0;
            int[] var7 = new int[this.getCapacity()];
            int[] var8 = new int[this.getCapacity()];

            for (short var9 = 0; var9 < this.getCapacity(); var9++) {
               if (!this.cantRemoveFromSlot(var9)) {
                  ItemStack var10 = this.internal_getSlot(var9);
                  if (var3 != var10 && !ItemStack.isEmpty(var10) && var10.isStackableWith(var3)) {
                     var8[var6] = var9;
                     var7[var6] = var10.getQuantity();
                     var6++;
                  }
               }
            }

            IntArrays.quickSort(var7, var8, 0, var6);
            int var15 = var3.getQuantity();
            List var16 = new ObjectArrayList();

            for (int var11 = 0; var11 < var6 && var15 < var5; var11++) {
               short var12 = (short)var8[var11];
               ItemStack var13 = this.internal_getSlot(var12);
               MoveTransaction var14 = this.internal_moveItemStackFromSlot(var12, var13.getQuantity(), var1, var2, true);
               var16.add(var14);
               var15 = !ItemStack.isEmpty(var14.getAddTransaction().getSlotAfter()) ? var14.getAddTransaction().getSlotAfter().getQuantity() : 0;
            }

            class="kw">return new ListTransaction<>(true, var16);
         } else {
            class="kw">return new ListTransaction<>(false, Collections.emptyList());
         }
      });
   }

   @Nonnull
   class="kw">public ListTransaction<MoveTransaction<SlotTransaction>> swapItems(short var1, @Nonnull ItemContainer var2, short var3, short var4) {
      ListTransaction var5 = this.internal_swapItems(var1, var2, var3, var4);
      this.sendUpdate(var5);

      for (MoveTransaction var7 : var5.getList()) {
         var7.getOtherContainer().sendUpdate(var7.toInverted(this));
      }

      class="kw">return var5;
   }

   @Nonnull
   class="kw">protected ListTransaction<MoveTransaction<SlotTransaction>> internal_swapItems(short var1, @Nonnull ItemContainer var2, short var3, short var4) {
      if (var1 < 0) {
         throw new IndexOutOfBoundsException("srcPos < 0");
      } else if (var1 + var4 > this.getCapacity()) {
         throw new IndexOutOfBoundsException("srcPos + length > capacity");
      } else if (var3 < 0) {
         throw new IndexOutOfBoundsException("destPos < 0");
      } else if (var3 + var4 > var2.getCapacity()) {
         throw new IndexOutOfBoundsException("destPos + length > dest.capacity");
      } else {
         class="kw">return this.writeAction(() -> var2.writeAction(() -> {
            List var5 = new ObjectArrayList(var4);

            for (short var6 = 0; var6 < var4; var6++) {
               var5.add(this.internal_swapItems(var2, (short)(var1 + var6), (short)(var3 + var6)));
            }

            class="kw">return new ListTransaction<>(true, var5);
         }));
      }
   }

   @Nonnull
   class="kw">protected MoveTransaction<SlotTransaction> internal_swapItems(@Nonnull ItemContainer var1, short var2, short var3) {
      ItemStack var4 = this.internal_removeSlot(var2);
      ItemStack var5 = var1.internal_removeSlot(var3);
      if (var5 != null && !var5.isEmpty()) {
         this.internal_setSlot(var2, var5);
      }

      if (var4 != null && !var4.isEmpty()) {
         var1.internal_setSlot(var3, var4);
      }

      SlotTransaction var6 = new SlotTransaction(true, ActionType.REPLACE, var2, var4, var5, null, false, false, false);
      SlotTransaction var7 = new SlotTransaction(true, ActionType.REPLACE, var3, var5, var4, null, false, false, false);
      class="kw">return new MoveTransaction<>(true, var6, MoveType.MOVE_FROM_SELF, var1, var7);
   }

   class="kw">public boolean canAddItemStack(@Nonnull ItemStack var1) {
      class="kw">return this.canAddItemStack(var1, false, true);
   }

   class="kw">public boolean canAddItemStack(@Nonnull ItemStack var1, boolean var2, boolean var3) {
      Item var4 = var1.getItem();
      if (var4 == null) {
         throw new IllegalArgumentException(var1.getItemId() + " is an invalid item!");
      }

      int var5 = var4.getMaxStack();
      class="kw">return this.readAction(() -> {
         int var5 = var1.getQuantity();
         if (!var2) {
            var5 = InternalContainerUtilItemStack.testAddToExistingItemStacks(this, var1, var5, var5, var3);
         }

         var5 = InternalContainerUtilItemStack.testAddToEmptySlots(this, var1, var5, var5, var3);
         class="kw">return var5 <= 0;
      });
   }

   @Nonnull
   class="kw">public ItemStackTransaction addItemStack(@Nonnull ItemStack var1) {
      class="kw">return this.addItemStack(var1, false, false, true);
   }

   @Nonnull
   class="kw">public ItemStackTransaction addItemStack(@Nonnull ItemStack var1, boolean var2, boolean var3, boolean var4) {
      ItemStackTransaction var5 = InternalContainerUtilItemStack.internal_addItemStack(this, var1, var2, var3, var4);
      this.sendUpdate(var5);
      class="kw">return var5;
   }

   class="kw">public boolean canAddItemStacks(List<ItemStack> var1) {
      class="kw">return this.canAddItemStacks(var1, false, true);
   }

   class="kw">public boolean canAddItemStacks(@Nullable List<ItemStack> var1, boolean var2, boolean var3) {
      if (var1 != null && !var1.isEmpty()) {
         List var4 = new ObjectArrayList(var1.size());

         for (ItemStack var6 : var1) {
            Item var7 = var6.getItem();
            if (var7 == null) {
               throw new IllegalArgumentException(var6.getItemId() + " is an invalid item!");
            }

            var4.add(new ItemContainer.TempItemData(var6, var7));
         }

         class="kw">return this.readAction(() -> {
            for (ItemContainer.TempItemData var5 : var4) {
               int var6 = var5.item().getMaxStack();
               ItemStack var7 = var5.itemStack();
               int var8 = var7.getQuantity();
               if (!var2) {
                  var8 = InternalContainerUtilItemStack.testAddToExistingItemStacks(this, var7, var6, var8, var3);
               }

               var8 = InternalContainerUtilItemStack.testAddToEmptySlots(this, var7, var6, var8, var3);
               if (var8 > 0) {
                  class="kw">return false;
               }
            }

            class="kw">return true;
         });
      } else {
         class="kw">return true;
      }
   }

   class="kw">public ListTransaction<ItemStackTransaction> addItemStacks(List<ItemStack> var1) {
      class="kw">return this.addItemStacks(var1, false, false, true);
   }

   class="kw">public ListTransaction<ItemStackTransaction> addItemStacks(@Nullable List<ItemStack> var1, boolean var2, boolean var3, boolean var4) {
      if (var1 != null && !var1.isEmpty()) {
         ListTransaction var5 = InternalContainerUtilItemStack.internal_addItemStacks(this, var1, var2, var3, var4);
         this.sendUpdate(var5);
         class="kw">return var5;
      } else {
         class="kw">return ListTransaction.getEmptyTransaction(true);
      }
   }

   class="kw">public ListTransaction<ItemStackSlotTransaction> addItemStacksOrdered(List<ItemStack> var1) {
      class="kw">return this.addItemStacksOrdered(var1, false, true);
   }

   class="kw">public ListTransaction<ItemStackSlotTransaction> addItemStacksOrdered(short var1, List<ItemStack> var2) {
      class="kw">return this.addItemStacksOrdered(var1, var2, false, true);
   }

   class="kw">public ListTransaction<ItemStackSlotTransaction> addItemStacksOrdered(List<ItemStack> var1, boolean var2, boolean var3) {
      class="kw">return this.addItemStacksOrdered((short)0, var1, var2, var3);
   }

   class="kw">public ListTransaction<ItemStackSlotTransaction> addItemStacksOrdered(short var1, @Nullable List<ItemStack> var2, boolean var3, boolean var4) {
      if (var2 != null && !var2.isEmpty()) {
         ListTransaction var5 = InternalContainerUtilItemStack.internal_addItemStacksOrdered(this, var1, var2, var3, var4);
         this.sendUpdate(var5);
         class="kw">return var5;
      } else {
         class="kw">return ListTransaction.getEmptyTransaction(true);
      }
   }

   class="kw">public boolean canRemoveItemStack(ItemStack var1) {
      class="kw">return this.canRemoveItemStack(var1, true, true);
   }

   class="kw">public boolean canRemoveItemStack(@Nullable ItemStack var1, boolean var2, boolean var3) {
      class="kw">return var1 == null ? true : this.readAction(() -> {
         int var4 = InternalContainerUtilItemStack.testRemoveItemStackFromItems(this, var1, var1.getQuantity(), var3);
         class="kw">return var4 > 0 ? false : !var2 || var4 >= 0;
      });
   }

   @Nonnull
   class="kw">public ItemStackTransaction removeItemStack(@Nonnull ItemStack var1) {
      class="kw">return this.removeItemStack(var1, true, true);
   }

   @Nonnull
   class="kw">public ItemStackTransaction removeItemStack(@Nonnull ItemStack var1, boolean var2, boolean var3) {
      ItemStackTransaction var4 = InternalContainerUtilItemStack.internal_removeItemStack(this, var1, var2, var3);
      this.sendUpdate(var4);
      class="kw">return var4;
   }

   class="kw">public boolean canRemoveItemStacks(List<ItemStack> var1) {
      class="kw">return this.canRemoveItemStacks(var1, true, true);
   }

   class="kw">public boolean canRemoveItemStacks(@Nullable List<ItemStack> var1, boolean var2, boolean var3) {
      class="kw">return var1 != null && !var1.isEmpty() ? this.readAction(() -> {
         for (ItemStack var5 : var1) {
            int var6 = InternalContainerUtilItemStack.testRemoveItemStackFromItems(this, var5, var5.getQuantity(), var3);
            if (var6 > 0) {
               class="kw">return false;
            }

            if (var2 && var6 < 0) {
               class="kw">return false;
            }
         }

         class="kw">return true;
      }) : true;
   }

   class="kw">public ListTransaction<ItemStackTransaction> removeItemStacks(List<ItemStack> var1) {
      class="kw">return this.removeItemStacks(var1, true, true);
   }

   class="kw">public ListTransaction<ItemStackTransaction> removeItemStacks(@Nullable List<ItemStack> var1, boolean var2, boolean var3) {
      if (var1 != null && !var1.isEmpty()) {
         ListTransaction var4 = InternalContainerUtilItemStack.internal_removeItemStacks(this, var1, var2, var3);
         this.sendUpdate(var4);
         class="kw">return var4;
      } else {
         class="kw">return ListTransaction.getEmptyTransaction(true);
      }
   }

   class="kw">public boolean canRemoveTag(int var1, int var2) {
      class="kw">return this.canRemoveTag(var1, var2, true, true);
   }

   class="kw">public boolean canRemoveTag(int var1, int var2, boolean var3, boolean var4) {
      class="kw">return this.readAction(() -> {
         int var5 = InternalContainerUtilTag.testRemoveTagFromItems(this, var1, var2, var4);
         class="kw">return var5 > 0 ? false : !var3 || var5 >= 0;
      });
   }

   @Nonnull
   class="kw">public TagTransaction removeTag(int var1, int var2) {
      class="kw">return this.removeTag(var1, var2, true, true, true);
   }

   @Nonnull
   class="kw">public TagTransaction removeTag(int var1, int var2, boolean var3, boolean var4, boolean var5) {
      TagTransaction var6 = InternalContainerUtilTag.internal_removeTag(this, var1, var2, var3, var4, var5);
      this.sendUpdate(var6);
      class="kw">return var6;
   }

   class="kw">public boolean canRemoveResource(ResourceQuantity var1) {
      class="kw">return this.canRemoveResource(var1, true, true);
   }

   class="kw">public boolean canRemoveResource(@Nullable ResourceQuantity var1, boolean var2, boolean var3) {
      class="kw">return var1 == null ? true : this.readAction(() -> {
         int var4 = InternalContainerUtilResource.testRemoveResourceFromItems(this, var1, var1.getQuantity(), var3);
         class="kw">return var4 > 0 ? false : !var2 || var4 >= 0;
      });
   }

   @Nonnull
   class="kw">public ResourceTransaction removeResource(@Nonnull ResourceQuantity var1) {
      class="kw">return this.removeResource(var1, true, true, true);
   }

   @Nonnull
   class="kw">public ResourceTransaction removeResource(@Nonnull ResourceQuantity var1, boolean var2, boolean var3, boolean var4) {
      ResourceTransaction var5 = InternalContainerUtilResource.internal_removeResource(this, var1, var2, var3, var4);
      this.sendUpdate(var5);
      class="kw">return var5;
   }

   class="kw">public boolean canRemoveResources(List<ResourceQuantity> var1) {
      class="kw">return this.canRemoveResources(var1, true, true);
   }

   class="kw">public boolean canRemoveResources(@Nullable List<ResourceQuantity> var1, boolean var2, boolean var3) {
      class="kw">return var1 != null && !var1.isEmpty() ? this.readAction(() -> {
         for (ResourceQuantity var5 : var1) {
            int var6 = InternalContainerUtilResource.testRemoveResourceFromItems(this, var5, var5.getQuantity(), var3);
            if (var6 > 0) {
               class="kw">return false;
            }

            if (var2 && var6 < 0) {
               class="kw">return false;
            }
         }

         class="kw">return true;
      }) : true;
   }

   class="kw">public ListTransaction<ResourceTransaction> removeResources(List<ResourceQuantity> var1) {
      class="kw">return this.removeResources(var1, true, true, true);
   }

   class="kw">public ListTransaction<ResourceTransaction> removeResources(@Nullable List<ResourceQuantity> var1, boolean var2, boolean var3, boolean var4) {
      if (var1 != null && !var1.isEmpty()) {
         ListTransaction var5 = InternalContainerUtilResource.internal_removeResources(this, var1, var2, var3, var4);
         this.sendUpdate(var5);
         class="kw">return var5;
      } else {
         class="kw">return ListTransaction.getEmptyTransaction(true);
      }
   }

   class="kw">public boolean canRemoveMaterial(MaterialQuantity var1) {
      class="kw">return this.canRemoveMaterial(var1, true, true);
   }

   class="kw">public boolean canRemoveMaterial(@Nullable MaterialQuantity var1, boolean var2, boolean var3) {
      class="kw">return var1 == null ? true : this.readAction(() -> {
         int var4 = InternalContainerUtilMaterial.testRemoveMaterialFromItems(this, var1, var1.getQuantity(), var3);
         class="kw">return var4 > 0 ? false : !var2 || var4 >= 0;
      });
   }

   class="kw">public int countRemovableMaterial(@Nonnull MaterialQuantity var1) {
      class="kw">return this.countRemovableMaterial(var1, true);
   }

   class="kw">public int countRemovableMaterial(@Nonnull MaterialQuantity var1, boolean var2) {
      class="kw">return this.readAction(() -> InternalContainerUtilMaterial.countMaterialFromItems(this, var1, var2));
   }

   @Nonnull
   class="kw">public MaterialTransaction removeMaterial(@Nonnull MaterialQuantity var1) {
      class="kw">return this.removeMaterial(var1, true, true, true);
   }

   @Nonnull
   class="kw">public MaterialTransaction removeMaterial(@Nonnull MaterialQuantity var1, boolean var2, boolean var3, boolean var4) {
      MaterialTransaction var5 = InternalContainerUtilMaterial.internal_removeMaterial(this, var1, var2, var3, var4);
      this.sendUpdate(var5);
      class="kw">return var5;
   }

   class="kw">public boolean canRemoveMaterials(List<MaterialQuantity> var1) {
      class="kw">return this.canRemoveMaterials(var1, true, true);
   }

   class="kw">public boolean canRemoveMaterials(@Nullable List<MaterialQuantity> var1, boolean var2, boolean var3) {
      class="kw">return var1 != null && !var1.isEmpty() ? this.readAction(() -> {
         for (MaterialQuantity var5 : var1) {
            int var6 = InternalContainerUtilMaterial.testRemoveMaterialFromItems(this, var5, var5.getQuantity(), var3);
            if (var6 > 0) {
               class="kw">return false;
            }

            if (var2 && var6 < 0) {
               class="kw">return false;
            }
         }

         class="kw">return true;
      }) : true;
   }

   class="kw">public List<TestRemoveItemSlotResult> getSlotMaterialsToRemove(@Nullable List<MaterialQuantity> var1, boolean var2, boolean var3) {
      List var4 = new ObjectArrayList();
      class="kw">return var1 != null && !var1.isEmpty() ? this.readAction(() -> {
         for (MaterialQuantity var6 : var1) {
            TestRemoveItemSlotResult var7 = InternalContainerUtilMaterial.getTestRemoveMaterialFromItems(this, var6, var6.getQuantity(), var3);
            if (var7.quantityRemaining > 0) {
               var4.clear();
               class="kw">return var4;
            }

            if (var2 && var7.quantityRemaining < 0) {
               var4.clear();
               class="kw">return var4;
            }

            var4.add(var7);
         }

         class="kw">return var4;
      }) : var4;
   }

   class="kw">public ListTransaction<MaterialTransaction> removeMaterials(List<MaterialQuantity> var1) {
      class="kw">return this.removeMaterials(var1, true, true, true);
   }

   class="kw">public ListTransaction<MaterialTransaction> removeMaterials(@Nullable List<MaterialQuantity> var1, boolean var2, boolean var3, boolean var4) {
      if (var1 != null && !var1.isEmpty()) {
         ListTransaction var5 = InternalContainerUtilMaterial.internal_removeMaterials(this, var1, var2, var3, var4);
         this.sendUpdate(var5);
         class="kw">return var5;
      } else {
         class="kw">return ListTransaction.getEmptyTransaction(true);
      }
   }

   class="kw">public ListTransaction<MaterialSlotTransaction> removeMaterialsOrdered(short var1, List<MaterialQuantity> var2) {
      class="kw">return this.removeMaterialsOrdered(var1, var2, true, true, true);
   }

   class="kw">public ListTransaction<MaterialSlotTransaction> removeMaterialsOrdered(List<MaterialQuantity> var1, boolean var2, boolean var3, boolean var4) {
      class="kw">return this.removeMaterialsOrdered((short)0, var1, var2, var3, var4);
   }

   class="kw">public ListTransaction<MaterialSlotTransaction> removeMaterialsOrdered(
      short var1, @Nullable List<MaterialQuantity> var2, boolean var3, boolean var4, boolean var5
   ) {
      if (var2 != null && !var2.isEmpty()) {
         if (var1 + var2.size() > this.getCapacity()) {
            class="kw">return ListTransaction.getEmptyTransaction(false);
         }

         ListTransaction var6 = InternalContainerUtilMaterial.internal_removeMaterialsOrdered(this, var1, var2, var3, var4, var5);
         this.sendUpdate(var6);
         class="kw">return var6;
      } else {
         class="kw">return ListTransaction.getEmptyTransaction(true);
      }
   }

   class="kw">public boolean isEmpty() {
      class="kw">return this.readAction(() -> {
         for (short var1 = 0; var1 < this.getCapacity(); var1++) {
            ItemStack var2 = this.internal_getSlot(var1);
            if (var2 != null && !var2.isEmpty()) {
               class="kw">return false;
            }
         }

         class="kw">return true;
      });
   }

   class="kw">public int countItemStacks(@Nonnull Predicate<ItemStack> var1) {
      class="kw">return this.readAction(() -> {
         int var2 = 0;

         for (short var3 = 0; var3 < this.getCapacity(); var3++) {
            ItemStack var4 = this.internal_getSlot(var3);
            if (!ItemStack.isEmpty(var4) && var1.test(var4)) {
               var2 += var4.getQuantity();
            }
         }

         class="kw">return var2;
      });
   }

   class="kw">public boolean containsItemStacksStackableWith(@Nonnull ItemStack var1) {
      class="kw">return this.readAction(() -> {
         for (short var2 = 0; var2 < this.getCapacity(); var2++) {
            ItemStack var3 = this.internal_getSlot(var2);
            if (!ItemStack.isEmpty(var3) && var1.isStackableWith(var3)) {
               class="kw">return true;
            }
         }

         class="kw">return false;
      });
   }

   class="kw">public void forEach(@Nonnull ShortObjectConsumer<ItemStack> var1) {
      for (short var2 = 0; var2 < this.getCapacity(); var2++) {
         ItemStack var3 = this.getItemStack(var2);
         if (!ItemStack.isEmpty(var3)) {
            var1.accept(var2, var3);
         }
      }
   }

   class="kw">public <T> void forEachWithMeta(@Nonnull Short2ObjectConcurrentHashMap.ShortBiObjConsumer<ItemStack, T> var1, T var2) {
      for (short var3 = 0; var3 < this.getCapacity(); var3++) {
         ItemStack var4 = this.getItemStack(var3);
         if (!ItemStack.isEmpty(var4)) {
            var1.accept(var3, var4, var2);
         }
      }
   }

   @Nonnull
   class="kw">public List<ItemStack> removeAllItemStacks() {
      List var1 = new ObjectArrayList();
      ListTransaction var2 = this.writeAction(() -> {
         List var2 = new ObjectArrayList();

         for (short var3 = 0; var3 < this.getCapacity(); var3++) {
            if (!this.cantRemoveFromSlot(var3)) {
               ItemStack var4 = this.internal_removeSlot(var3);
               if (!ItemStack.isEmpty(var4)) {
                  var1.add(var4);
                  var2.add(new SlotTransaction(true, ActionType.REMOVE, var3, var4, null, var4, false, false, true));
               }
            }
         }

         class="kw">return new ListTransaction<>(true, var2);
      });
      this.sendUpdate(var2);
      class="kw">return var1;
   }

   @Nonnull
   class="kw">public List<ItemStack> dropAllItemStacks() {
      class="kw">return this.dropAllItemStacks(true);
   }

   @Nonnull
   class="kw">public List<ItemStack> dropAllItemStacks(boolean var1) {
      List var2 = new ObjectArrayList();
      ListTransaction var3 = this.writeAction(() -> {
         List var3 = new ObjectArrayList();

         for (short var4 = 0; var4 < this.getCapacity(); var4++) {
            if (!var1 || !this.cantDropFromSlot(var4)) {
               ItemStack var5 = this.internal_removeSlot(var4);
               if (!ItemStack.isEmpty(var5)) {
                  var2.add(var5);
                  var3.add(new SlotTransaction(true, ActionType.REMOVE, var4, var5, null, var5, false, false, true));
               }
            }
         }

         class="kw">return new ListTransaction<>(true, var3);
      });
      this.sendUpdate(var3);
      class="kw">return var2;
   }

   @Nonnull
   class="kw">public ListTransaction<SlotTransaction> sortItems(@Nonnull SortType var1) {
      ListTransaction var2 = this.internal_sortItems(var1);
      this.sendUpdate(var2);
      class="kw">return var2;
   }

   class="kw">protected ListTransaction<SlotTransaction> internal_sortItems(@Nonnull SortType var1) {
      class="kw">return this.writeAction(() -> {
         ItemStack[] var2 = new ItemStack[this.getCapacity()];
         int var3 = 0;

         for (short var4 = 0; var4 < var2.length; var4++) {
            if (!this.cantRemoveFromSlot(var4)) {
               ItemStack var5 = this.internal_removeSlot(var4);
               if (var5 != null) {
                  Item var6 = var5.getItem();
                  int var7 = var6.getMaxStack();
                  int var8 = var5.getQuantity();
                  if (var7 > 1) {
                     for (int var9 = 0; var9 < var3 && var8 > 0; var9++) {
                        ItemStack var10 = var2[var9];
                        if (var5.isStackableWith(var10)) {
                           int var11 = var10.getQuantity();
                           if (var11 < var7) {
                              int var12 = Math.min(var8, var7 - var11);
                              var8 -= var12;
                              var2[var9] = var10.withQuantity(var11 + var12);
                           }
                        }
                     }
                  }

                  if (var8 > 0) {
                     var2[var3++] = var8 != var5.getQuantity() ? var5.withQuantity(var8) : var5;
                  }
               }
            }
         }

         Arrays.sort(var2, var1.getComparator());
         List var14 = new ObjectArrayList(var2.length);
         var3 = 0;

         for (short var15 = 0; var15 < var2.length; var15++) {
            if (!this.cantRemoveFromSlot(var15)) {
               ItemStack var17 = this.internal_getSlot(var15);
               ItemStack var19 = var2[var3];
               if (!this.cantAddToSlot(var15, var19, var17)) {
                  var3++;
                  if (var17 != var19) {
                     this.internal_setSlot(var15, var19);
                     var14.add(new SlotTransaction(true, ActionType.REMOVE, var15, var17, null, var19, false, false, true));
                  }
               }
            }
         }

         for (short var16 = 0; var16 < var2.length && var3 < var2.length; var16++) {
            ItemStack var18 = var2[var3];
            if (var18 == null) {
               break;
            }

            if (!this.cantRemoveFromSlot(var16) && this.internal_getSlot(var16) == null) {
               var3++;
               this.internal_setSlot(var16, var18);
               var14.add(new SlotTransaction(true, ActionType.REMOVE, var16, null, null, var18, false, false, true));
            }
         }

         class="kw">return new ListTransaction<>(true, var14);
      });
   }

   class="kw">protected void sendUpdate(@Nonnull Transaction var1) {
      if (var1.succeeded()) {
         ItemContainer.ItemContainerChangeEvent var2 = new ItemContainer.ItemContainerChangeEvent(this, var1);
         this.externalChangeEventRegistry.dispatchFor(null).dispatch(var2);
         this.internalChangeEventRegistry.dispatchFor(null).dispatch(var2);
      }
   }

   class="kw">public boolean containsContainer(ItemContainer var1) {
      class="kw">return var1 == this;
   }

   class="kw">public void doMigration(Function<String, String> var1) {
      this.writeAction(var1x -> {
         for (short var2 = 0; var2 < this.getCapacity(); var2++) {
            ItemStack var3 = this.internal_getSlot(var2);
            if (!ItemStack.isEmpty(var3)) {
               String var4 = var3.getItemId();
               String var5 = (String)var1x.apply(var3.getItemId());
               if (!var4.equals(var5)) {
                  this.internal_setSlot(var2, new ItemStack(var5, var3.getQuantity(), var3.getMetadata()));
               }
            }
         }

         class="kw">return null;
      }, var1);
   }

   @Nullable
   class="kw">public class="kw">static ItemResourceType getMatchingResourceType(@Nonnull Item var0, @Nonnull String var1) {
      ItemResourceType[] var2 = var0.getResourceTypes();
      if (var2 == null) {
         class="kw">return null;
      }

      for (ItemResourceType var6 : var2) {
         if (var1.equals(var6.id)) {
            class="kw">return var6;
         }
      }

      class="kw">return null;
   }

   class="kw">public class="kw">static void validateQuantity(int var0) {
      if (var0 < 0) {
         throw new IllegalArgumentException("Quantity is less than zero! " + var0 + " < 0");
      }
   }

   class="kw">public class="kw">static void validateSlotIndex(short var0, int var1) {
      if (var0 < 0) {
         throw new IllegalArgumentException("Slot is less than zero! " + var0 + " < 0");
      }

      if (var0 >= var1) {
         throw new IllegalArgumentException("Slot is outside capacity! " + var0 + " >= " + var1);
      }
   }

   @Nonnull
   class="kw">public class="kw">static <T class="kw">extends ItemContainer> T copy(@Nonnull ItemContainer var0, @Nonnull T var1, @Nullable List<ItemStack> var2) {
      var0.forEach((var2x, var3) -> {
         if (var2x >= var1.getCapacity()) {
            if (var2 != null) {
               var2.add(var3);
            }
         } else if (!ItemStack.isEmpty(var3)) {
            var1.setItemStackForSlot(var2x, var3);
         }
      });
      class="kw">return var1;
   }

   class="kw">public class="kw">static <T class="kw">extends ItemContainer> T ensureContainerCapacity(
      @Nullable T var0, short var1, @Nonnull Short2ObjectConcurrentHashMap.ShortFunction<T> var2, @Nullable List<ItemStack> var3
   ) {
      if (var0 == null) {
         class="kw">return var2.apply(var1);
      } else {
         class="kw">return var0.getCapacity() == var1 ? var0 : copy(var0, var2.apply(var1), var3);
      }
   }

   class="kw">public class="kw">static ItemContainer getNewContainer(short var0, @Nonnull Short2ObjectConcurrentHashMap.ShortFunction<ItemContainer> var1) {
      class="kw">return var0 > 0 ? var1.apply(var0) : EmptyItemContainer.INSTANCE;
   }

   class="kw">public record ItemContainerChangeEvent(ItemContainer container, Transaction transaction) class="kw">implements IEvent<Void> {
      class="kw">public ItemContainerChangeEvent {
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "ItemContainerChangeEvent{container=" + this.container + ", transaction=" + this.transaction + "}";
      }
   }

   class="kw">public record TempItemData(ItemStack itemStack, Item item) {
      class="kw">public TempItemData {
      }
   }
}