com/hypixel/hytale/server/core/inventory

com/hypixel/hytale/server/core/inventory/Inventory.java

package com.hypixel.hytale.server.core.inventory;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.component.Store;
import com.hypixel.hytale.event.EventRegistration;
import com.hypixel.hytale.event.IEventDispatcher;
import com.hypixel.hytale.protocol.BlockMaterial;
import com.hypixel.hytale.protocol.BlockPosition;
import com.hypixel.hytale.protocol.InteractionChainData;
import com.hypixel.hytale.protocol.InteractionType;
import com.hypixel.hytale.protocol.ItemArmorSlot;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.PickupLocation;
import com.hypixel.hytale.protocol.SmartMoveType;
import com.hypixel.hytale.protocol.Vector3f;
import com.hypixel.hytale.protocol.packets.inventory.UpdatePlayerInventory;
import com.hypixel.hytale.server.core.HytaleServer;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemArmor;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemUtility;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemWeapon;
import com.hypixel.hytale.server.core.entity.InteractionChain;
import com.hypixel.hytale.server.core.entity.InteractionContext;
import com.hypixel.hytale.server.core.entity.InteractionManager;
import com.hypixel.hytale.server.core.entity.LivingEntity;
import com.hypixel.hytale.server.core.entity.StatModifiersManager;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.entity.entities.player.windows.ItemContainerWindow;
import com.hypixel.hytale.server.core.entity.entities.player.windows.Window;
import com.hypixel.hytale.server.core.event.events.entity.LivingEntityInventoryChangeEvent;
import com.hypixel.hytale.server.core.inventory.container.CombinedItemContainer;
import com.hypixel.hytale.server.core.inventory.container.EmptyItemContainer;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import com.hypixel.hytale.server.core.inventory.container.ItemContainerUtil;
import com.hypixel.hytale.server.core.inventory.container.SimpleItemContainer;
import com.hypixel.hytale.server.core.inventory.container.SortType;
import com.hypixel.hytale.server.core.inventory.transaction.ItemStackTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ListTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.MoveTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.SlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.Transaction;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import com.hypixel.hytale.server.core.modules.entity.player.PlayerSettings;
import com.hypixel.hytale.server.core.modules.interaction.InteractionModule;
import com.hypixel.hytale.server.core.modules.interaction.interaction.config.Interaction;
import com.hypixel.hytale.server.core.modules.interaction.interaction.config.RootInteraction;
import com.hypixel.hytale.server.core.modules.interaction.interaction.config.none.ChangeActiveSlotInteraction;
import com.hypixel.hytale.server.core.universe.PlayerRef;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import com.hypixel.hytale.server.core.util.UUIDUtil;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Function;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class Inventory implements NetworkSerializable<UpdatePlayerInventory> {
   public static final short DEFAULT_HOTBAR_CAPACITY = 9;
   public static final short DEFAULT_UTILITY_CAPACITY = 4;
   public static final short DEFAULT_TOOLS_CAPACITY = 23;
   public static final short DEFAULT_ARMOR_CAPACITY;
   public static final short DEFAULT_STORAGE_ROWS = 4;
   public static final short DEFAULT_STORAGE_COLUMNS = 9;
   public static final short DEFAULT_STORAGE_CAPACITY = 36;
   public static final int HOTBAR_SECTION_ID = -1;
   public static final int STORAGE_SECTION_ID = -2;
   public static final int ARMOR_SECTION_ID = -3;
   public static final int UTILITY_SECTION_ID = -5;
   public static final int TOOLS_SECTION_ID = -8;
   public static final int BACKPACK_SECTION_ID = -9;
   public static final byte INACTIVE_SLOT_INDEX = -1;
   public static final int VERSION = 4;
   public static final BuilderCodec<Inventory> CODEC;
   private final AtomicBoolean isDirty;
   private final AtomicBoolean needsSaving;
   private ItemContainer storage;
   private ItemContainer armor;
   private ItemContainer hotbar;
   private ItemContainer utility;
   /** @deprecated */
   @Deprecated
   private ItemContainer tools;
   private ItemContainer backpack;
   private CombinedItemContainer combinedHotbarFirst;
   private CombinedItemContainer combinedStorageFirst;
   private CombinedItemContainer combinedBackpackStorageHotbar;
   private CombinedItemContainer combinedStorageHotbarBackpack;
   private CombinedItemContainer combinedArmorHotbarStorage;
   private CombinedItemContainer combinedArmorHotbarUtilityStorage;
   private CombinedItemContainer combinedHotbarUtilityConsumableStorage;
   private CombinedItemContainer combinedEverything;
   private byte activeHotbarSlot;
   private byte activeUtilitySlot;
   private byte activeToolsSlot;
   @Nullable
   private LivingEntity entity;
   /** @deprecated */
   @Deprecated
   private SortType sortType;
   @Nullable
   private EventRegistration armorChange;
   @Nullable
   private EventRegistration storageChange;
   @Nullable
   private EventRegistration hotbarChange;
   @Nullable
   private EventRegistration utilityChange;
   @Nullable
   private EventRegistration toolChange;
   @Nullable
   private EventRegistration backpackChange;
   private boolean _usingToolsItem;

   private Inventory(Void dummy) {
      this.isDirty = new AtomicBoolean();
      this.needsSaving = new AtomicBoolean();
      this.storage = EmptyItemContainer.INSTANCE;
      this.armor = EmptyItemContainer.INSTANCE;
      this.hotbar = EmptyItemContainer.INSTANCE;
      this.utility = EmptyItemContainer.INSTANCE;
      this.tools = EmptyItemContainer.INSTANCE;
      this.backpack = EmptyItemContainer.INSTANCE;
      this.activeUtilitySlot = -1;
      this.activeToolsSlot = -1;
      this.sortType = SortType.NAME;
      this._usingToolsItem = false;
   }

   public Inventory() {
      this((short)36, DEFAULT_ARMOR_CAPACITY, (short)9, (short)4, (short)23);
   }

   public Inventory(short storageCapacity, short armorCapacity, short hotbarCapacity, short utilityCapacity, short toolCapacity) {
      this((ItemContainer)(storageCapacity == 0 ? EmptyItemContainer.INSTANCE : new SimpleItemContainer(storageCapacity)), (ItemContainer)(armorCapacity == 0 ? EmptyItemContainer.INSTANCE : new SimpleItemContainer(armorCapacity)), (ItemContainer)(hotbarCapacity == 0 ? EmptyItemContainer.INSTANCE : new SimpleItemContainer(hotbarCapacity)), (ItemContainer)(utilityCapacity == 0 ? EmptyItemContainer.INSTANCE : new SimpleItemContainer(utilityCapacity)), (ItemContainer)(toolCapacity == 0 ? EmptyItemContainer.INSTANCE : new SimpleItemContainer(toolCapacity)), EmptyItemContainer.INSTANCE);
   }

   public Inventory(ItemContainer storage, ItemContainer armor, ItemContainer hotbar, ItemContainer utility, ItemContainer tools, ItemContainer backpack) {
      this.isDirty = new AtomicBoolean();
      this.needsSaving = new AtomicBoolean();
      this.storage = EmptyItemContainer.INSTANCE;
      this.armor = EmptyItemContainer.INSTANCE;
      this.hotbar = EmptyItemContainer.INSTANCE;
      this.utility = EmptyItemContainer.INSTANCE;
      this.tools = EmptyItemContainer.INSTANCE;
      this.backpack = EmptyItemContainer.INSTANCE;
      this.activeUtilitySlot = -1;
      this.activeToolsSlot = -1;
      this.sortType = SortType.NAME;
      this._usingToolsItem = false;
      this.storage = storage;
      this.armor = ItemContainerUtil.trySetArmorFilters(armor);
      this.hotbar = hotbar;
      this.utility = ItemContainerUtil.trySetSlotFilters(utility, (type, container, slot, itemStack) -> itemStack == null || itemStack.getItem().getUtility().isUsable());
      this.tools = tools;
      this.backpack = backpack;
      this.buildCombinedContains();
      this.registerChangeEvents();
   }

   protected void registerChangeEvents() {
      this.storageChange = this.storage.registerChangeEvent((e) -> {
         this.markChanged();
         IEventDispatcher<LivingEntityInventoryChangeEvent, LivingEntityInventoryChangeEvent> dispatcher = HytaleServer.get().getEventBus().dispatchFor(LivingEntityInventoryChangeEvent.class, this.entity.getWorld().getName());
         if (dispatcher.hasListener()) {
            dispatcher.dispatch(new LivingEntityInventoryChangeEvent(this.entity, e.container(), e.transaction()));
         }

      });
      this.armorChange = this.armor.registerChangeEvent((e) -> {
         this.markChanged();
         IEventDispatcher<LivingEntityInventoryChangeEvent, LivingEntityInventoryChangeEvent> dispatcher = HytaleServer.get().getEventBus().dispatchFor(LivingEntityInventoryChangeEvent.class, this.entity.getWorld().getName());
         if (dispatcher.hasListener()) {
            dispatcher.dispatch(new LivingEntityInventoryChangeEvent(this.entity, e.container(), e.transaction()));
         }

         this.entity.invalidateEquipmentNetwork();
      });
      this.hotbarChange = this.hotbar.registerChangeEvent((e) -> {
         this.markChanged();
         IEventDispatcher<LivingEntityInventoryChangeEvent, LivingEntityInventoryChangeEvent> dispatcher = HytaleServer.get().getEventBus().dispatchFor(LivingEntityInventoryChangeEvent.class, this.entity.getWorld().getName());
         if (dispatcher.hasListener()) {
            dispatcher.dispatch(new LivingEntityInventoryChangeEvent(this.entity, e.container(), e.transaction()));
         }

         if (this.activeHotbarSlot != -1 && this.entity != null && e.transaction().wasSlotModified((short)this.activeHotbarSlot)) {
            Transaction patt0$temp = e.transaction();
            if (patt0$temp instanceof SlotTransaction) {
               SlotTransaction slot = (SlotTransaction)patt0$temp;
               if (ItemStack.isEquivalentType(slot.getSlotBefore(), slot.getSlotAfter())) {
                  return;
               }
            }

            StatModifiersManager statModifiersManager = this.entity.getStatModifiersManager();
            this.entity.invalidateEquipmentNetwork();
            statModifiersManager.setRecalculate(true);
            ItemStack itemStack = this.getItemInHand();
            if (itemStack == null) {
               return;
            }

            ItemWeapon itemWeapon = itemStack.getItem().getWeapon();
            if (itemWeapon == null) {
               return;
            }

            int[] entityStatsToClear = itemWeapon.getEntityStatsToClear();
            if (entityStatsToClear == null) {
               return;
            }

            statModifiersManager.queueEntityStatsToClear(entityStatsToClear);
         }

      });
      this.utilityChange = this.utility.registerChangeEvent((e) -> {
         this.markChanged();
         IEventDispatcher<LivingEntityInventoryChangeEvent, LivingEntityInventoryChangeEvent> dispatcher = HytaleServer.get().getEventBus().dispatchFor(LivingEntityInventoryChangeEvent.class, this.entity.getWorld().getName());
         if (dispatcher.hasListener()) {
            dispatcher.dispatch(new LivingEntityInventoryChangeEvent(this.entity, e.container(), e.transaction()));
         }

         if (this.activeUtilitySlot != -1 && this.entity != null && e.transaction().wasSlotModified((short)this.activeUtilitySlot)) {
            Transaction patt0$temp = e.transaction();
            if (patt0$temp instanceof SlotTransaction) {
               SlotTransaction slot = (SlotTransaction)patt0$temp;
               if (ItemStack.isEquivalentType(slot.getSlotBefore(), slot.getSlotAfter())) {
                  return;
               }
            }

            StatModifiersManager statModifiersManager = this.entity.getStatModifiersManager();
            this.entity.invalidateEquipmentNetwork();
            statModifiersManager.setRecalculate(true);
            ItemStack itemStack = this.getUtilityItem();
            if (itemStack == null) {
               return;
            }

            ItemUtility itemUtility = itemStack.getItem().getUtility();
            if (itemUtility == null) {
               return;
            }

            int[] entityStatsToClear = itemUtility.getEntityStatsToClear();
            if (entityStatsToClear == null) {
               return;
            }

            statModifiersManager.queueEntityStatsToClear(entityStatsToClear);
         }

      });
      this.toolChange = this.tools.registerChangeEvent((e) -> {
         this.markChanged();
         IEventDispatcher<LivingEntityInventoryChangeEvent, LivingEntityInventoryChangeEvent> dispatcher = HytaleServer.get().getEventBus().dispatchFor(LivingEntityInventoryChangeEvent.class, this.entity.getWorld().getName());
         if (dispatcher.hasListener()) {
            dispatcher.dispatch(new LivingEntityInventoryChangeEvent(this.entity, e.container(), e.transaction()));
         }

      });
      this.registerBackpackListener();
   }

   private void registerBackpackListener() {
      this.unregisterBackpackChange();
      this.backpackChange = this.backpack.registerChangeEvent((e) -> {
         this.markChanged();
         IEventDispatcher<LivingEntityInventoryChangeEvent, LivingEntityInventoryChangeEvent> dispatcher = HytaleServer.get().getEventBus().dispatchFor(LivingEntityInventoryChangeEvent.class, this.entity.getWorld().getName());
         if (dispatcher.hasListener()) {
            dispatcher.dispatch(new LivingEntityInventoryChangeEvent(this.entity, e.container(), e.transaction()));
         }

      });
   }

   public void unregister() {
      this.entity = null;
      if (this.storageChange != null) {
         this.storageChange.unregister();
         this.storageChange = null;
      }

      if (this.armorChange != null) {
         this.armorChange.unregister();
         this.armorChange = null;
      }

      if (this.hotbarChange != null) {
         this.hotbarChange.unregister();
         this.hotbarChange = null;
      }

      if (this.utilityChange != null) {
         this.utilityChange.unregister();
         this.utilityChange = null;
      }

      if (this.toolChange != null) {
         this.toolChange.unregister();
         this.toolChange = null;
      }

      this.unregisterBackpackChange();
   }

   private void unregisterBackpackChange() {
      if (this.backpackChange != null) {
         this.backpackChange.unregister();
         this.backpackChange = null;
      }

   }

   public void markChanged() {
      this.isDirty.set(true);
      this.needsSaving.set(true);
   }

   public void moveItem(int fromSectionId, int fromSlotId, int quantity, int toSectionId, int toSlotId) {
      ItemContainer fromContainer = this.getSectionById(fromSectionId);
      if (fromContainer != null) {
         ItemContainer toContainer = this.getSectionById(toSectionId);
         if (toContainer != null) {
            if (this.entity instanceof Player && (toSectionId == -1 && this.activeHotbarSlot == toSlotId || fromSectionId == -1 && this.activeHotbarSlot == fromSlotId)) {
               ItemStack fromItem = fromContainer.getItemStack((short)fromSlotId);
               ItemStack currentItem = toContainer.getItemStack((short)toSlotId);
               if (ItemStack.isStackableWith(fromItem, currentItem) || ItemStack.isSameItemType(fromItem, currentItem)) {
                  fromContainer.moveItemStackFromSlotToSlot((short)fromSlotId, quantity, toContainer, (short)toSlotId);
                  return;
               }

               int interactionSlot = toSectionId == -1 && this.activeHotbarSlot == toSlotId ? toSlotId : this.activeHotbarSlot;
               Ref<EntityStore> ref = this.entity.getReference();
               Store<EntityStore> store = ref.getStore();
               InteractionManager interactionManagerComponent = (InteractionManager)store.getComponent(ref, InteractionModule.get().getInteractionManagerComponent());
               if (interactionManagerComponent != null) {
                  PlayerRef playerRefComponent = (PlayerRef)store.getComponent(ref, PlayerRef.getComponentType());

                  assert playerRefComponent != null;

                  InteractionContext context = InteractionContext.forInteraction(interactionManagerComponent, ref, InteractionType.SwapFrom, store);
                  context.getMetaStore().putMetaObject(Interaction.TARGET_SLOT, interactionSlot);
                  context.getMetaStore().putMetaObject(ChangeActiveSlotInteraction.PLACE_MOVED_ITEM, (Runnable)() -> {
                     fromContainer.moveItemStackFromSlotToSlot((short)fromSlotId, quantity, toContainer, (short)toSlotId);
                     playerRefComponent.getPacketHandler().write((Packet)this.toPacket());
                  });
                  String interactions = context.getRootInteractionId(InteractionType.SwapFrom);
                  InteractionChainData data = new InteractionChainData(-1, UUIDUtil.EMPTY_UUID, (Vector3f)null, (String)null, (BlockPosition)null, -interactionSlot - 1, (Vector3f)null);
                  InteractionChain chain = interactionManagerComponent.initChain(data, InteractionType.SwapFrom, context, RootInteraction.getRootInteractionOrUnknown(interactions), (Runnable)null, false);
                  interactionManagerComponent.queueExecuteChain(chain);
                  return;
               }
            }

            fromContainer.moveItemStackFromSlotToSlot((short)fromSlotId, quantity, toContainer, (short)toSlotId);
         }
      }
   }

   public void smartMoveItem(int fromSectionId, int fromSlotId, int quantity, @Nonnull SmartMoveType moveType) {
      ItemContainer targetContainer = this.getSectionById(fromSectionId);
      if (targetContainer != null) {
         switch (moveType) {
            case EquipOrMergeStack:
               ItemStack itemStack = targetContainer.getItemStack((short)fromSlotId);
               Item item = itemStack.getItem();
               ItemArmor itemArmor = item.getArmor();
               if (itemArmor != null && fromSectionId != -3) {
                  targetContainer.moveItemStackFromSlotToSlot((short)fromSlotId, quantity, this.armor, (short)itemArmor.getArmorSlot().ordinal());
                  return;
               }

               if (this.entity instanceof Player) {
                  for(Window window : ((Player)this.entity).getWindowManager().getWindows()) {
                     if (window instanceof ItemContainerWindow) {
                        ((ItemContainerWindow)window).getItemContainer().combineItemStacksIntoSlot(targetContainer, (short)fromSlotId);
                     }
                  }
               }

               this.combinedHotbarFirst.combineItemStacksIntoSlot(targetContainer, (short)fromSlotId);
               break;
            case PutInHotbarOrWindow:
               if (fromSectionId >= 0) {
                  targetContainer.moveItemStackFromSlot((short)fromSlotId, quantity, (ItemContainer)this.combinedHotbarFirst);
                  return;
               }

               if (this.entity instanceof Player) {
                  for(Window window : ((Player)this.entity).getWindowManager().getWindows()) {
                     if (window instanceof ItemContainerWindow) {
                        ItemContainer itemContainer = ((ItemContainerWindow)window).getItemContainer();
                        MoveTransaction<ItemStackTransaction> transaction = targetContainer.moveItemStackFromSlot((short)fromSlotId, quantity, itemContainer);
                        ItemStack remainder = ((ItemStackTransaction)transaction.getAddTransaction()).getRemainder();
                        if (ItemStack.isEmpty(remainder) || remainder.getQuantity() != quantity) {
                           return;
                        }
                     }
                  }
               }

               switch (fromSectionId) {
                  case -2:
                     targetContainer.moveItemStackFromSlot((short)fromSlotId, quantity, this.hotbar);
                     return;
                  case -1:
                     targetContainer.moveItemStackFromSlot((short)fromSlotId, quantity, this.storage);
                     return;
                  default:
                     targetContainer.moveItemStackFromSlot((short)fromSlotId, quantity, (ItemContainer)this.combinedHotbarFirst);
                     return;
               }
            case PutInHotbarOrBackpack:
               if (fromSectionId == -9) {
                  targetContainer.moveItemStackFromSlot((short)fromSlotId, quantity, (ItemContainer)this.combinedHotbarFirst);
               } else {
                  targetContainer.moveItemStackFromSlot((short)fromSlotId, quantity, (ItemContainer)this.combinedBackpackStorageHotbar);
               }
         }

      }
   }

   @Nullable
   public ListTransaction<MoveTransaction<ItemStackTransaction>> takeAll(int inventorySectionId) {
      ItemContainer sectionById = this.getSectionById(inventorySectionId);
      return sectionById != null ? sectionById.moveAllItemStacksTo(this.combinedArmorHotbarStorage) : null;
   }

   @Nullable
   public ListTransaction<MoveTransaction<ItemStackTransaction>> putAll(int inventorySectionId) {
      ItemContainer sectionById = this.getSectionById(inventorySectionId);
      return sectionById != null ? this.storage.moveAllItemStacksTo(sectionById) : null;
   }

   @Nullable
   public ListTransaction<MoveTransaction<ItemStackTransaction>> quickStack(int inventorySectionId) {
      ItemContainer sectionById = this.getSectionById(inventorySectionId);
      return sectionById != null ? this.combinedHotbarFirst.quickStackTo(new ItemContainer[]{sectionById}) : null;
   }

   @Nonnull
   public List<ItemStack> dropAllItemStacks() {
      List<ItemStack> items = new ObjectArrayList<ItemStack>();
      items.addAll(this.storage.dropAllItemStacks());
      items.addAll(this.armor.dropAllItemStacks());
      items.addAll(this.hotbar.dropAllItemStacks());
      items.addAll(this.utility.dropAllItemStacks());
      items.addAll(this.backpack.dropAllItemStacks());
      return items;
   }

   public void clear() {
      this.storage.clear();
      this.armor.clear();
      this.hotbar.clear();
      this.utility.clear();
      this.backpack.clear();
   }

   public ItemContainer getStorage() {
      return this.storage;
   }

   public ItemContainer getArmor() {
      return this.armor;
   }

   public ItemContainer getHotbar() {
      return this.hotbar;
   }

   public ItemContainer getUtility() {
      return this.utility;
   }

   public ItemContainer getTools() {
      return this.tools;
   }

   public ItemContainer getBackpack() {
      return this.backpack;
   }

   public void resizeBackpack(short capacity, List<ItemStack> remainder) {
      if (capacity > 0) {
         this.backpack = ItemContainer.ensureContainerCapacity(this.backpack, capacity, SimpleItemContainer::new, remainder);
      } else {
         this.backpack = ItemContainer.copy(this.backpack, EmptyItemContainer.INSTANCE, remainder);
      }

      this.buildCombinedContains();
      if (this.entity != null) {
         this.registerBackpackListener();
      }

      this.markChanged();
   }

   public CombinedItemContainer getCombinedHotbarFirst() {
      return this.combinedHotbarFirst;
   }

   public CombinedItemContainer getCombinedStorageFirst() {
      return this.combinedStorageFirst;
   }

   public CombinedItemContainer getCombinedBackpackStorageHotbar() {
      return this.combinedBackpackStorageHotbar;
   }

   public CombinedItemContainer getCombinedArmorHotbarStorage() {
      return this.combinedArmorHotbarStorage;
   }

   public CombinedItemContainer getCombinedArmorHotbarUtilityStorage() {
      return this.combinedArmorHotbarUtilityStorage;
   }

   public CombinedItemContainer getCombinedHotbarUtilityConsumableStorage() {
      return this.combinedHotbarUtilityConsumableStorage;
   }

   public CombinedItemContainer getCombinedEverything() {
      return this.combinedEverything;
   }

   @Nonnull
   public ItemContainer getContainerForItemPickup(@Nonnull Item item, PlayerSettings playerSettings) {
      if (item.getArmor() != null) {
         return playerSettings.armorItemsPreferredPickupLocation() == PickupLocation.Hotbar ? this.getCombinedHotbarFirst() : this.getCombinedStorageFirst();
      } else if (item.getWeapon() == null && item.getTool() == null) {
         if (item.getUtility().isUsable()) {
            return playerSettings.usableItemsItemsPreferredPickupLocation() == PickupLocation.Hotbar ? this.getCombinedHotbarFirst() : this.getCombinedStorageFirst();
         } else {
            BlockType blockType = item.hasBlockType() ? (BlockType)BlockType.getAssetMap().getAsset(item.getBlockId()) : BlockType.EMPTY;
            if (blockType == null) {
               blockType = BlockType.EMPTY;
            }

            if (blockType.getMaterial() == BlockMaterial.Solid) {
               return playerSettings.solidBlockItemsPreferredPickupLocation() == PickupLocation.Hotbar ? this.getCombinedHotbarFirst() : this.getCombinedStorageFirst();
            } else {
               return playerSettings.miscItemsPreferredPickupLocation() == PickupLocation.Hotbar ? this.getCombinedHotbarFirst() : this.getCombinedStorageFirst();
            }
         }
      } else {
         return playerSettings.weaponAndToolItemsPreferredPickupLocation() == PickupLocation.Hotbar ? this.getCombinedHotbarFirst() : this.getCombinedStorageFirst();
      }
   }

   public void setActiveSlot(int inventorySectionId, byte slot) {
      int[] entityStatsToClear = null;
      switch (inventorySectionId) {
         case -8:
            this.activeToolsSlot = slot;
            break;
         case -5:
            this.activeUtilitySlot = slot;
            ItemStack itemStack = this.getUtilityItem();
            if (itemStack != null) {
               ItemUtility utility = itemStack.getItem().getUtility();
               entityStatsToClear = utility.getEntityStatsToClear();
            }
            break;
         case -1:
            this.activeHotbarSlot = slot;
            ItemStack itemStack = this.getItemInHand();
            if (itemStack != null) {
               ItemWeapon weapon = itemStack.getItem().getWeapon();
               if (weapon != null) {
                  entityStatsToClear = weapon.getEntityStatsToClear();
               }
            }
            break;
         default:
            throw new IllegalArgumentException("Inventory section with id " + inventorySectionId + " cannot select an active slot");
      }

      StatModifiersManager statModifiersManager = this.entity.getStatModifiersManager();
      this.entity.invalidateEquipmentNetwork();
      statModifiersManager.setRecalculate(true);
      if (entityStatsToClear != null) {
         statModifiersManager.queueEntityStatsToClear(entityStatsToClear);
      }

   }

   public byte getActiveSlot(int inventorySectionId) {
      byte var10000;
      switch (inventorySectionId) {
         case -8 -> var10000 = this.activeToolsSlot;
         case -5 -> var10000 = this.activeUtilitySlot;
         case -1 -> var10000 = this.activeHotbarSlot;
         default -> throw new IllegalArgumentException("Inventory section with id " + inventorySectionId + " cannot select an active slot");
      }

      return var10000;
   }

   public byte getActiveHotbarSlot() {
      return this.activeHotbarSlot;
   }

   public void setActiveHotbarSlot(byte slot) {
      this.setUsingToolsItem(false);
      this.setActiveSlot(-1, slot);
   }

   @Nullable
   public ItemStack getActiveHotbarItem() {
      return this.activeHotbarSlot == -1 ? null : this.hotbar.getItemStack((short)this.activeHotbarSlot);
   }

   @Nullable
   public ItemStack getActiveToolItem() {
      return this.activeToolsSlot == -1 ? null : this.tools.getItemStack((short)this.activeToolsSlot);
   }

   @Nullable
   public ItemStack getItemInHand() {
      return this._usingToolsItem ? this.getActiveToolItem() : this.getActiveHotbarItem();
   }

   public byte getActiveUtilitySlot() {
      return this.activeUtilitySlot;
   }

   public void setActiveUtilitySlot(byte slot) {
      this.setActiveSlot(-5, slot);
   }

   @Nullable
   public ItemStack getUtilityItem() {
      return this.activeUtilitySlot == -1 ? null : this.utility.getItemStack((short)this.activeUtilitySlot);
   }

   public byte getActiveToolsSlot() {
      return this.activeToolsSlot;
   }

   public void setActiveToolsSlot(byte slot) {
      this.setUsingToolsItem(true);
      this.setActiveSlot(-8, slot);
   }

   @Nullable
   public ItemStack getToolsItem() {
      return this.activeToolsSlot == -1 ? null : this.tools.getItemStack((short)this.activeToolsSlot);
   }

   @Nullable
   public ItemContainer getSectionById(int id) {
      if (id >= 0) {
         if (this.entity instanceof Player) {
            Window window = ((Player)this.entity).getWindowManager().getWindow(id);
            if (window instanceof ItemContainerWindow) {
               return ((ItemContainerWindow)window).getItemContainer();
            }
         }

         return null;
      } else {
         ItemContainer var10000;
         switch (id) {
            case -9:
               var10000 = this.backpack;
               break;
            case -8:
               var10000 = this.tools;
               break;
            case -7:
            case -6:
            case -4:
            default:
               var10000 = null;
               break;
            case -5:
               var10000 = this.utility;
               break;
            case -3:
               var10000 = this.armor;
               break;
            case -2:
               var10000 = this.storage;
               break;
            case -1:
               var10000 = this.hotbar;
         }

         return var10000;
      }
   }

   public boolean consumeIsDirty() {
      return this.isDirty.getAndSet(false);
   }

   public boolean consumeNeedsSaving() {
      return this.needsSaving.getAndSet(false);
   }

   public void setEntity(LivingEntity entity) {
      this.entity = entity;
   }

   public void sortStorage(@Nonnull SortType type) {
      this.sortType = type;
      this.storage.sortItems(type);
      this.markChanged();
   }

   public void setSortType(SortType type) {
      this.sortType = type;
      this.markChanged();
   }

   public boolean containsBrokenItem() {
      boolean hasBrokenItem = false;

      for(short i = 0; i < this.combinedEverything.getCapacity(); ++i) {
         ItemStack itemStack = this.combinedEverything.getItemStack(i);
         if (!ItemStack.isEmpty(itemStack) && itemStack.isBroken()) {
            hasBrokenItem = true;
         }
      }

      return hasBrokenItem;
   }

   @Nonnull
   public UpdatePlayerInventory toPacket() {
      UpdatePlayerInventory packet = new UpdatePlayerInventory();
      packet.storage = this.storage.toPacket();
      packet.armor = this.armor.toPacket();
      packet.hotbar = this.hotbar.toPacket();
      packet.utility = this.utility.toPacket();
      packet.tools = this.tools.toPacket();
      packet.backpack = this.backpack.toPacket();
      packet.sortType = this.sortType.toPacket();
      return packet;
   }

   public void doMigration(Function<String, String> blockMigration) {
      Objects.requireNonNull(blockMigration);
      this.hotbar.doMigration(blockMigration);
      this.storage.doMigration(blockMigration);
      this.armor.doMigration(blockMigration);
      this.utility.doMigration(blockMigration);
      this.tools.doMigration(blockMigration);
      this.backpack.doMigration(blockMigration);
   }

   private void postDecode() {
      this.armor = ItemContainerUtil.trySetArmorFilters(this.armor);
      this.utility = ItemContainerUtil.trySetSlotFilters(this.utility, (type, container, slot, itemStack) -> itemStack == null || itemStack.getItem().getUtility().isUsable());
      this.activeHotbarSlot = (byte)(this.activeHotbarSlot < this.hotbar.getCapacity() ? this.activeHotbarSlot : (this.hotbar.getCapacity() > 0 ? 0 : -1));
      this.activeUtilitySlot = this.activeUtilitySlot < this.utility.getCapacity() ? this.activeUtilitySlot : -1;
      this.activeToolsSlot = this.activeToolsSlot < this.tools.getCapacity() ? this.activeToolsSlot : -1;
      this.buildCombinedContains();
      this.registerChangeEvents();
   }

   private void buildCombinedContains() {
      this.combinedHotbarFirst = new CombinedItemContainer(new ItemContainer[]{this.hotbar, this.storage});
      this.combinedStorageFirst = new CombinedItemContainer(new ItemContainer[]{this.storage, this.hotbar});
      this.combinedBackpackStorageHotbar = new CombinedItemContainer(new ItemContainer[]{this.backpack, this.storage, this.hotbar});
      this.combinedStorageHotbarBackpack = new CombinedItemContainer(new ItemContainer[]{this.storage, this.hotbar, this.backpack});
      this.combinedArmorHotbarStorage = new CombinedItemContainer(new ItemContainer[]{this.armor, this.hotbar, this.storage});
      this.combinedArmorHotbarUtilityStorage = new CombinedItemContainer(new ItemContainer[]{this.armor, this.hotbar, this.utility, this.storage});
      this.combinedHotbarUtilityConsumableStorage = new CombinedItemContainer(new ItemContainer[]{this.hotbar, this.utility, this.storage});
      this.combinedEverything = new CombinedItemContainer(new ItemContainer[]{this.armor, this.hotbar, this.utility, this.storage, this.backpack});
   }

   public boolean equals(@Nullable Object o) {
      if (this == o) {
         return true;
      } else if (o != null && this.getClass() == o.getClass()) {
         Inventory inventory = (Inventory)o;
         if (this.activeHotbarSlot != inventory.activeHotbarSlot) {
            return false;
         } else if (this.activeUtilitySlot != inventory.activeUtilitySlot) {
            return false;
         } else if (this.isDirty != inventory.isDirty) {
            return false;
         } else if (this.needsSaving != inventory.needsSaving) {
            return false;
         } else if (!Objects.equals(this.storage, inventory.storage)) {
            return false;
         } else if (!Objects.equals(this.armor, inventory.armor)) {
            return false;
         } else if (!Objects.equals(this.utility, inventory.utility)) {
            return false;
         } else if (!Objects.equals(this.tools, inventory.tools)) {
            return false;
         } else {
            return !Objects.equals(this.backpack, inventory.backpack) ? false : Objects.equals(this.hotbar, inventory.hotbar);
         }
      } else {
         return false;
      }
   }

   public int hashCode() {
      int result = this.storage != null ? this.storage.hashCode() : 0;
      result = 31 * result + (this.armor != null ? this.armor.hashCode() : 0);
      result = 31 * result + (this.hotbar != null ? this.hotbar.hashCode() : 0);
      result = 31 * result + (this.utility != null ? this.utility.hashCode() : 0);
      result = 31 * result + (this.tools != null ? this.tools.hashCode() : 0);
      result = 31 * result + (this.backpack != null ? this.backpack.hashCode() : 0);
      result = 31 * result + this.activeHotbarSlot;
      result = 31 * result + this.activeUtilitySlot;
      result = 31 * result + this.activeToolsSlot;
      result = 31 * result + this.isDirty.hashCode();
      result = 31 * result + this.needsSaving.hashCode();
      return result;
   }

   @Nonnull
   public String toString() {
      String var10000 = String.valueOf(this.storage);
      return "Inventory{, storage=" + var10000 + ", armor=" + String.valueOf(this.armor) + ", hotbar=" + String.valueOf(this.hotbar) + ", utility=" + String.valueOf(this.utility) + ", activeHotbarSlot=" + this.activeHotbarSlot + ", activeUtilitySlot=" + this.activeUtilitySlot + ", activeToolsSlot=" + this.activeToolsSlot + ", isDirty=" + String.valueOf(this.isDirty) + ", needsSaving=" + String.valueOf(this.needsSaving) + "}";
   }

   @Nonnull
   public static Inventory ensureCapacity(@Nonnull Inventory inventory, List<ItemStack> remainder) {
      ItemContainer storage = inventory.getStorage();
      ItemContainer armor = inventory.getArmor();
      ItemContainer hotbar = inventory.getHotbar();
      ItemContainer utility = inventory.getUtility();
      ItemContainer tool = inventory.getTools();
      if (storage.getCapacity() == 36 && armor.getCapacity() == DEFAULT_ARMOR_CAPACITY && hotbar.getCapacity() == 9 && utility.getCapacity() == 4 && tool.getCapacity() == 23) {
         return inventory;
      } else {
         ItemContainer newStorage = ItemContainer.ensureContainerCapacity(storage, (short)36, SimpleItemContainer::new, remainder);
         ItemContainer newArmor = ItemContainer.ensureContainerCapacity(armor, DEFAULT_ARMOR_CAPACITY, SimpleItemContainer::new, remainder);
         ItemContainer newHotbar = ItemContainer.ensureContainerCapacity(hotbar, (short)9, SimpleItemContainer::new, remainder);
         ItemContainer newUtility = ItemContainer.ensureContainerCapacity(utility, (short)4, SimpleItemContainer::new, remainder);
         ItemContainer newTool = ItemContainer.ensureContainerCapacity(tool, (short)23, SimpleItemContainer::new, remainder);
         byte activeHotbarSlot = inventory.getActiveHotbarSlot();
         if (activeHotbarSlot > newHotbar.getCapacity()) {
            activeHotbarSlot = (byte)(hotbar.getCapacity() > 0 ? 0 : -1);
         }

         byte activeUtilitySlot = inventory.getActiveUtilitySlot();
         if (activeUtilitySlot > newUtility.getCapacity()) {
            activeUtilitySlot = -1;
         }

         byte activeToolsSlot = inventory.getActiveToolsSlot();
         if (activeToolsSlot > newTool.getCapacity()) {
            activeToolsSlot = -1;
         }

         inventory.unregister();
         Inventory newInventory = new Inventory(newStorage, newArmor, newHotbar, newUtility, newTool, EmptyItemContainer.INSTANCE);
         newInventory.activeHotbarSlot = activeHotbarSlot;
         newInventory.activeUtilitySlot = activeUtilitySlot;
         newInventory.activeToolsSlot = activeToolsSlot;
         newInventory.setSortType(inventory.sortType);
         return newInventory;
      }
   }

   public void setUsingToolsItem(boolean value) {
      this._usingToolsItem = value;
   }

   public boolean usingToolsItem() {
      return this._usingToolsItem;
   }

   static {
      DEFAULT_ARMOR_CAPACITY = (short)ItemArmorSlot.VALUES.length;
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(Inventory.class, () -> new Inventory((Void)null)).versioned()).codecVersion(4)).append(new KeyedCodec("Storage", ItemContainer.CODEC), (o, i) -> o.storage = i, (o) -> o.storage).add()).append(new KeyedCodec("Armor", ItemContainer.CODEC), (o, i) -> o.armor = i, (o) -> o.armor).add()).append(new KeyedCodec("HotBar", ItemContainer.CODEC), (o, i) -> o.hotbar = i, (o) -> o.hotbar).add()).append(new KeyedCodec("Utility", ItemContainer.CODEC), (o, i) -> o.utility = i, (o) -> o.utility).add()).append(new KeyedCodec("Backpack", ItemContainer.CODEC), (o, i) -> o.backpack = i, (o) -> o.backpack).add()).append(new KeyedCodec("ActiveHotbarSlot", Codec.BYTE), (o, i) -> o.activeHotbarSlot = i, (o) -> o.activeHotbarSlot).add()).append(new KeyedCodec("Tool", ItemContainer.CODEC), (o, i) -> o.tools = i, (o) -> o.tools).add()).append(new KeyedCodec("ActiveToolsSlot", Codec.BYTE), (o, i) -> o.activeToolsSlot = i, (o) -> o.activeToolsSlot).add()).append(new KeyedCodec("ActiveUtilitySlot", Codec.BYTE), (o, i) -> o.activeUtilitySlot = i, (o) -> o.activeUtilitySlot).add()).append(new KeyedCodec("SortType", new EnumCodec(SortType.class, EnumCodec.EnumStyle.LEGACY)), (o, i) -> o.sortType = i, (o) -> o.sortType).setVersionRange(0, 3).add()).append(new KeyedCodec("SortType", new EnumCodec(SortType.class)), (o, i) -> o.sortType = i, (o) -> o.sortType).setVersionRange(4, 4).add()).afterDecode(Inventory::postDecode)).build();
   }

   public static enum ItemPickupType {
      PASSIVE,
      INTERACTION;

      private ItemPickupType() {
      }
   }
}

com/hypixel/hytale/server/core/inventory/ItemContext.java

package com.hypixel.hytale.server.core.inventory;

import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;

public class ItemContext {
   @Nonnull
   private final ItemContainer container;
   private final short slot;
   @Nonnull
   private final ItemStack itemStack;

   public ItemContext(@Nonnull ItemContainer container, short slot, @Nonnull ItemStack itemStack) {
      this.container = container;
      this.slot = slot;
      this.itemStack = itemStack;
   }

   @Nonnull
   public ItemContainer getContainer() {
      return this.container;
   }

   public short getSlot() {
      return this.slot;
   }

   @Nonnull
   public ItemStack getItemStack() {
      return this.itemStack;
   }

   @Nonnull
   public String toString() {
         String.valueOf(.container);
        + var10000 +  + .slot +  + String.valueOf(.itemStack) + ;
   }
}

com/hypixel/hytale/server/core/inventory/ItemStack.java

package com.hypixel.hytale.server.core.inventory;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.math.util.MathUtil;
import com.hypixel.hytale.protocol.ItemQuantity;
import com.hypixel.hytale.protocol.ItemWithAllMetadata;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;
import org.bson.BsonValue;

public class ItemStack implements NetworkSerializable<ItemWithAllMetadata> {
   @Nonnull
   public static final ItemStack[] EMPTY_ARRAY = new ItemStack[0];
   @Nonnull
   public static final BuilderCodec<ItemStack> CODEC;
   @Nonnull
   public static final ItemStack EMPTY;
   protected String itemId;
   protected int quantity;
   protected double durability;
   protected double maxDurability;
     overrideDroppedItemAnimation;
   
    BsonDocument metadata;
   
    ItemWithAllMetadata cachedPacket;

     {
      .quantity = ;
       (quantity <= ) {
           (String.format(, quantity));
      }   (itemId == ) {
           ();
      }   (itemId.equals()) {
           ();
      }  {
         .itemId = itemId;
         .quantity = quantity;
            .getItem().getMaxDurability();
         .durability = maxDurability;
         .maxDurability = maxDurability;
         .metadata = metadata;
      }
   }

     {
      (itemId, quantity, metadata);
      .durability = durability;
      .maxDurability = maxDurability;
   }

     {
      (itemId, );
   }

     {
      (itemId, quantity, (BsonDocument));
   }

     {
      .quantity = ;
   }

   
    String  {
       .itemId;
   }

      {
       .quantity;
   }

   
   
   
    BsonDocument  {
       .metadata ==  ?  : .metadata.clone();
   }

      {
       .maxDurability <= ;
   }

      {
       (.isUnbreakable()) {
          ;
      }  {
          .durability == ;
      }
   }

      {
       .maxDurability;
   }

      {
       .durability;
   }

      {
       .itemId.equals();
   }

      {
       .overrideDroppedItemAnimation;
   }

      {
      .overrideDroppedItemAnimation = b;
   }

   
    String  {
       (.isEmpty()) {
          ;
      }  {
            .getItem();
          (item == ) {
             ;
         }  {
             item.hasBlockType() ? item.getBlockId() : ;
         }
      }
   }

   
    Item  {
         (Item)Item.getAssetMap().getAsset(.itemId);
       item !=  ? item : Item.UNKNOWN;
   }

      {
       .isEmpty() || .getItem() != ;
   }

   
    ItemStack  {
        (.itemId, .quantity, MathUtil.clamp(durability, , .maxDurability), .maxDurability, .metadata);
   }

   
    ItemStack  {
        (.itemId, .quantity, Math.min(.durability, maxDurability), maxDurability, .metadata);
   }

   
    ItemStack  {
       .withDurability(.durability + inc);
   }

   
    ItemStack  {
        (.itemId, .quantity, maxDurability, maxDurability, .metadata);
   }

   
    ItemStack  {
         .getItem().getItemIdForState(state);
       (newItemId == ) {
           ( + state);
      }  {
           (newItemId, .quantity, .durability, .maxDurability, .metadata);
      }
   }

   
    ItemStack  {
       (quantity == ) {
          ;
      }  {
          quantity == .quantity ?  :  (.itemId, quantity, .durability, .maxDurability, .metadata);
      }
   }

   
    ItemStack  {
        (.itemId, .quantity, .durability, .maxDurability, metadata);
   }

   
    <T> ItemStack  {
       .withMetadata(keyedCodec.getKey(), keyedCodec.getChildCodec(), data);
   }

   
    <T> ItemStack  {
         .metadata ==  ?  () : .metadata.clone();
       (data == ) {
         clonedMeta.remove(key);
      }  {
         BsonValue bsonValue;
          var10000;
         label39: {
            bsonValue = codec.encode(data);
             (!bsonValue.isNull()) {
               label38: {
                   (bsonValue  BsonDocument) {
                        (BsonDocument)bsonValue;
                      (doc.isEmpty()) {
                         label38;
                     }
                  }

                  var10000 = ;
                   label39;
               }
            }

            var10000 = ;
         }

            var10000;
          (empty) {
            clonedMeta.remove(key);
         }  {
            clonedMeta.put(key, bsonValue);
         }
      }

       (clonedMeta.isEmpty()) {
         clonedMeta = ;
      }

        (.itemId, .quantity, .durability, .maxDurability, clonedMeta);
   }

   
    ItemStack  {
         .metadata ==  ?  () : .metadata.clone();
       (bsonValue !=  && !bsonValue.isNull()) {
         clonedMeta.put(key, bsonValue);
      }  {
         clonedMeta.remove(key);
      }

        (.itemId, .quantity, .durability, .maxDurability, clonedMeta);
   }

    ItemWithAllMetadata  {
       (.cachedPacket != ) {
          .cachedPacket;
      }  {
             ();
         packet.itemId = .itemId.toString();
         packet.quantity = .quantity;
         packet.durability = .durability;
         packet.maxDurability = .maxDurability;
         packet.overrideDroppedItemAnimation = .overrideDroppedItemAnimation;
         packet.metadata = .metadata !=  ? .metadata.toJson() : ;
         .cachedPacket = packet;
          .cachedPacket;
      }
   }

      {
       (itemStack == ) {
          ;
      }   (Double.compare(itemStack.durability, .durability) != ) {
          ;
      }   (Double.compare(itemStack.maxDurability, .maxDurability) != ) {
          ;
      }   (!.itemId.equals(itemStack.itemId)) {
          ;
      }  {
          .metadata !=  ? .metadata.equals(itemStack.metadata) : itemStack.metadata == ;
      }
   }

      {
       (itemStack == ) {
          ;
      }   (!.itemId.equals(itemStack.itemId)) {
          ;
      }  {
          .metadata !=  ? .metadata.equals(itemStack.metadata) : itemStack.metadata == ;
      }
   }

   
    <T> T  {
       keyedCodec.getOrNull(.metadata);
   }

   
    <T> T  {
         .metadata ==  ?  : .metadata.get(key);
       (T)(bsonValue ==  ?  : codec.decode(bsonValue));
   }

    <T> T  {
         .metadata ==  ?  () : .metadata.clone();
       (clonedMeta == ) {
          codec.getDefaultValue();
      }  {
            clonedMeta.get(key);
          (T)(bsonValue ==  ? codec.getDefaultValue() : codec.decode(bsonValue));
      }
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
            (ItemStack)o;
          (.quantity != itemStack.quantity) {
             ;
         }   (Double.compare(itemStack.durability, .durability) != ) {
             ;
         }   (Double.compare(itemStack.maxDurability, .maxDurability) != ) {
             ;
         }   (!.itemId.equals(itemStack.itemId)) {
             ;
         }  {
             .metadata !=  ? .metadata.equals(itemStack.metadata) : itemStack.metadata == ;
         }
      }  {
          ;
      }
   }

      {
         .itemId.hashCode();
      result =  * result + .quantity;
         Double.doubleToLongBits(.durability);
      result =  * result + ()(temp ^ temp >>> );
      temp = Double.doubleToLongBits(.maxDurability);
      result =  * result + ()(temp ^ temp >>> );
      result =  * result + (.metadata !=  ? .metadata.hashCode() : );
       result;
   }

   
    String  {
         .itemId;
        + var10000 +  + .quantity +  + .maxDurability +  + .durability +  + String.valueOf(.metadata) + ;
   }

       {
       itemFrom ==  || itemFrom.isEmpty();
   }

       {
       a == b || a !=  && a.isStackableWith(b);
   }

       {
       a == b || a !=  && a.isEquivalentType(b);
   }

       {
       a == b || a !=  && b !=  && a.itemId.equals(b.itemId);
   }

   
     ItemStack  {
       (packet == ) {
          ;
      }  {
            packet.quantity;
          quantity <=  ?  :  (packet.itemId, quantity, (BsonDocument));
      }
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ItemStack.class, ItemStack::).append( (, Codec.STRING), (itemStack, id) -> itemStack.itemId = id, (itemStack) -> itemStack.itemId).addValidator(Validators.nonNull()).addValidator(Item.VALIDATOR_CACHE.getValidator().late()).add()).append( (, Codec.INTEGER), (itemStack, quantity) -> itemStack.quantity = quantity, (itemStack) -> itemStack.quantity).addValidator(Validators.greaterThan()).add()).append( (, Codec.DOUBLE), (itemStack, durability) -> itemStack.durability = durability, (itemStack) -> itemStack.durability).addValidator(Validators.greaterThanOrEqual()).add()).append( (, Codec.DOUBLE), (itemStack, maxDurability) -> itemStack.maxDurability = maxDurability, (itemStack) -> itemStack.maxDurability).addValidator(Validators.greaterThanOrEqual()).add()).append( (, Codec.BSON_DOCUMENT), (itemStack, bsonDocument) -> itemStack.metadata = bsonDocument, (itemStack) -> itemStack.metadata).add()).append( (, Codec.BOOLEAN), (itemStack, b) -> itemStack.overrideDroppedItemAnimation = b, (itemStack) -> itemStack.overrideDroppedItemAnimation).add()).build();
      EMPTY =  () {
         {
            .itemId = ;
         }
      };
   }

       {
            ;

        {
      }
   }
}

com/hypixel/hytale/server/core/inventory/MaterialQuantity.java

package com.hypixel.hytale.server.core.inventory;

import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;

public class MaterialQuantity implements NetworkSerializable<com.hypixel.hytale.protocol.MaterialQuantity> {
   public static final MaterialQuantity[] EMPTY_ARRAY = new MaterialQuantity[0];
   public static final BuilderCodec<MaterialQuantity> CODEC;
   @Nullable
   protected String itemId;
   @Nullable
   protected String resourceTypeId;
   protected String tag;
   protected int tagIndex = -2147483648;
   protected int quantity = 1;
   @Nullable
   protected BsonDocument metadata;

   public MaterialQuantity {
       (itemId ==  && resourceTypeId ==  && tag == ) {
           ();
      }   (quantity <= ) {
           ( + quantity + );
      }  {
         .itemId = itemId;
         .resourceTypeId = resourceTypeId;
         .tag = tag;
         .quantity = quantity;
         .metadata = metadata;
      }
   }

     {
   }

   
    String  {
       .itemId;
   }

   
    String  {
       .resourceTypeId;
   }

      {
       .tagIndex;
   }

      {
       .quantity;
   }

    BsonDocument  {
       .metadata;
   }

   
    MaterialQuantity  {
        (.itemId, .resourceTypeId, .tag, quantity, .metadata);
   }

   
    ItemStack  {
       (.itemId == ) {
          ;
      }  {
          .itemId.equals() ? ItemStack.EMPTY :  (.itemId, .quantity, .metadata);
      }
   }

   
    ResourceQuantity  {
       .resourceTypeId ==  ?  :  (.resourceTypeId, .quantity);
   }

   
    com.hypixel.hytale.protocol.MaterialQuantity  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.MaterialQuantity();
       (.itemId != ) {
         packet.itemId = .itemId.toString();
      }

      packet.itemTag = .tagIndex;
      packet.resourceTypeId = .resourceTypeId;
      packet.quantity = .quantity;
       packet;
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
            (MaterialQuantity)o;
          (.quantity != that.quantity) {
             ;
         }  {
             (.itemId != ) {
                (!.itemId.equals(that.itemId)) {
                   ;
               }
            }   (that.itemId != ) {
                ;
            }

             (.resourceTypeId != ) {
                (!.resourceTypeId.equals(that.resourceTypeId)) {
                   ;
               }
            }   (that.resourceTypeId != ) {
                ;
            }

             (.tag != ) {
                (!.tag.equals(that.tag)) {
                   ;
               }
            }   (that.tag != ) {
                ;
            }

             .metadata !=  ? .metadata.equals(that.metadata) : that.metadata == ;
         }
      }  {
          ;
      }
   }

      {
         .itemId !=  ? .itemId.hashCode() : ;
      result =  * result + (.resourceTypeId !=  ? .resourceTypeId.hashCode() : );
      result =  * result + (.tag !=  ? .tag.hashCode() : );
      result =  * result + .quantity;
      result =  * result + (.metadata !=  ? .metadata.hashCode() : );
       result;
   }

   
    String  {
         .itemId;
        + var10000 +  + .resourceTypeId +  + .tag +  + .quantity +  + String.valueOf(.metadata) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(MaterialQuantity.class, MaterialQuantity::).addField( (, Codec.STRING), (craftingMaterial, blockTypeKey) -> craftingMaterial.itemId = blockTypeKey, (craftingMaterial) -> craftingMaterial.itemId)).addField( (, Codec.STRING), (craftingMaterial, s) -> craftingMaterial.resourceTypeId = s, (craftingMaterial) -> craftingMaterial.resourceTypeId)).addField( (, Codec.STRING), (materialQuantity, s) -> materialQuantity.tag = s, (materialQuantity) -> materialQuantity.tag)).append( (, Codec.INTEGER), (craftingMaterial, s) -> craftingMaterial.quantity = s, (craftingMaterial) -> craftingMaterial.quantity).addValidator(Validators.greaterThan()).add()).addField( (, Codec.BSON_DOCUMENT), (craftingMaterial, s) -> craftingMaterial.metadata = s, (craftingMaterial) -> craftingMaterial.metadata)).afterDecode((materialQuantity, extraInfo) -> {
          (materialQuantity.tag != ) {
            materialQuantity.tagIndex = AssetRegistry.getOrCreateTagIndex(materialQuantity.tag);
         }

      })).build();
   }
}

com/hypixel/hytale/server/core/inventory/ResourceQuantity.java

package com.hypixel.hytale.server.core.inventory;

import com.hypixel.hytale.protocol.ItemResourceType;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import java.util.Objects;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ResourceQuantity {
   protected String resourceId;
   protected int quantity;

   public ResourceQuantity(String resourceId, int quantity) {
      Objects.requireNonNull(resourceId, "resourceId cannot be null!");
      if (quantity <= 0) {
         throw new IllegalArgumentException("quantity " + quantity + " must be >0!");
      } else {
         this.resourceId = resourceId;
         this.quantity = quantity;
      }
   }

   protected ResourceQuantity() {
   }

   public String getResourceId() {
      return this.resourceId;
   }

   public int getQuantity() {
      return this.quantity;
   }

   
    ResourceQuantity  {
        (.resourceId, quantity);
   }

   
    ItemResourceType  {
       ItemContainer.getMatchingResourceType(item, .resourceId);
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
            (ResourceQuantity)o;
          (.quantity != itemStack.quantity) {
             ;
         }  {
             .resourceId !=  ? .resourceId.equals(itemStack.resourceId) : itemStack.resourceId == ;
         }
      }  {
          ;
      }
   }

      {
         .resourceId !=  ? .resourceId.hashCode() : ;
      result =  * result + .quantity;
       result;
   }

   
    String  {
        + .resourceId +  + .quantity + ;
   }
}

com/hypixel/hytale/server/core/inventory/container/CombinedItemContainer.java

package com.hypixel.hytale.server.core.inventory.container;

import com.hypixel.hytale.event.EventRegistration;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterActionType;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterType;
import com.hypixel.hytale.server.core.inventory.container.filter.SlotFilter;
import com.hypixel.hytale.server.core.inventory.transaction.ClearTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.Transaction;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class CombinedItemContainer extends ItemContainer {
   protected final ItemContainer[] containers;

   public CombinedItemContainer(ItemContainer... containers) {
      this.containers = containers;
   }

   public ItemContainer getContainer(int index) {
      return this.containers[index];
   }

   public int getContainersSize() {
      return this.containers.length;
   }

   @Nullable
    ItemContainer  {
      (ItemContainer container : .containers) {
            container.getCapacity();
          (slot < capacity) {
             container;
         }

         slot -= capacity;
      }

       ;
   }

    <V> V  {
       (V).readAction0(, action);
   }

    <V> V  {
       (V)(i >= .containers.length ? action.get() : .containers[i].readAction(() -> .readAction0(i + , action)));
   }

    <X, V> V  {
       (V).readAction0(, action, x);
   }

    <X, V> V  {
       (V)(i >= .containers.length ? action.apply(x) : .containers[i].readAction(() -> .readAction0(i + , action, x)));
   }

    <V> V  {
       (V).writeAction0(, action);
   }

    <V> V  {
       (V)(i >= .containers.length ? action.get() : .containers[i].writeAction(() -> .writeAction0(i + , action)));
   }

    <X, V> V  {
       (V).writeAction0(, action, x);
   }

    <X, V> V  {
       (V)(i >= .containers.length ? action.apply(x) : .containers[i].writeAction(() -> .writeAction0(i + , action, x)));
   }

   
    ClearTransaction  {
      ItemStack[] itemStacks =  [.getCapacity()];
         ;

      (ItemContainer container : .containers) {
            container.internal_clear();
         ItemStack[] items = clear.getItems();

         (   ; slot < itemStacks.length; ++slot) {
            itemStacks[()(start + slot)] = items[slot];
         }

         start += container.getCapacity();
      }

        (, (), itemStacks);
   }

   
    ItemStack  {
      (ItemContainer container : .containers) {
            container.getCapacity();
          (slot < capacity) {
             container.internal_getSlot(slot);
         }

         slot -= capacity;
      }

       ;
   }

   
    ItemStack  {
       (ItemStack.isEmpty(itemStack)) {
          .internal_removeSlot(slot);
      }  {
         (ItemContainer container : .containers) {
               container.getCapacity();
             (slot < capacity) {
                container.internal_setSlot(slot, itemStack);
            }

            slot -= capacity;
         }

          ;
      }
   }

   
    ItemStack  {
      (ItemContainer container : .containers) {
            container.getCapacity();
          (slot < capacity) {
             container.internal_removeSlot(slot);
         }

         slot -= capacity;
      }

       ;
   }

      {
      (ItemContainer container : .containers) {
            container.getCapacity();
          (slot < capacity) {
             container.cantAddToSlot(slot, itemStack, slotItemStack);
         }

         slot -= capacity;
      }

       ;
   }

      {
      (ItemContainer container : .containers) {
            container.getCapacity();
          (slot < capacity) {
             container.cantRemoveFromSlot(slot);
         }

         slot -= capacity;
      }

       ;
   }

      {
      (ItemContainer container : .containers) {
            container.getCapacity();
          (slot < capacity) {
             container.cantDropFromSlot(slot);
         }

         slot -= capacity;
      }

       ;
   }

      {
      (ItemContainer container : .containers) {
            container.cantMoveToSlot(fromContainer, slotFrom);
          (cantMoveToSlot) {
             ;
         }
      }

       ;
   }

      {
         ;

      (ItemContainer container : .containers) {
         capacity += container.getCapacity();
      }

       capacity;
   }

    CombinedItemContainer  {
        ();
   }

   
    EventRegistration  {
         .registerChangeEvent(priority, consumer);
      EventRegistration[] containerRegistrations =  [.containers.length];
         ;

      (   ; i < .containers.length; ++i) {
            .containers[i];
         containerRegistrations[i] = container.internalChangeEventRegistry.register(priority, (Object), (event) -> consumer.accept( .ItemContainerChangeEvent(, event.transaction().toParent(, start, container))));
         start += container.getCapacity();
      }

       EventRegistration.combine(thisRegistration, containerRegistrations);
   }

      {
       (transaction.succeeded()) {
         .sendUpdate(transaction);
            ;

         (ItemContainer container : .containers) {
               transaction.fromParent(, start, container);
             (containerTransaction != ) {
                (!containerTransaction.succeeded()) {
                  start += container.getCapacity();
                  ;
               }

               container.sendUpdate(containerTransaction);
            }

            start += container.getCapacity();
         }

      }
   }

      {
       (itemContainer == ) {
          ;
      }  {
         (ItemContainer container : .containers) {
             (container.containsContainer(itemContainer)) {
                ;
            }
         }

          ;
      }
   }

      {
       ( == o) {
          ;
      }   (o  CombinedItemContainer) {
            (CombinedItemContainer)o;
            .getCapacity();
          capacity != that.getCapacity() ?  : (Boolean).readAction((_that) -> (Boolean)_that.readAction((_that2) -> {
               (   ; i < capacity; ++i) {
                   (!Objects.equals(.internal_getSlot(i), _that2.internal_getSlot(i))) {
                      ;
                  }
               }

                ;
            }, _that), that);
      }  {
          ;
      }
   }

      {
         .getCapacity();
         (Integer).readAction(() -> {
            ;

         (   ; i < capacity; ++i) {
               .internal_getSlot(i);
            hash =  * hash + (itemStack !=  ? itemStack.hashCode() : );
         }

          hash;
      });
      result =  * result + capacity;
       result;
   }

      {
        ();
   }

      {
      (ItemContainer container : .containers) {
            container.getCapacity();
          (slot < capacity) {
            container.setSlotFilter(actionType, slot, filter);
            ;
         }

         slot -= capacity;
      }

   }
}

com/hypixel/hytale/server/core/inventory/container/DelegateItemContainer.java

package com.hypixel.hytale.server.core.inventory.container;

import com.hypixel.fastutil.ints.Int2ObjectConcurrentHashMap;
import com.hypixel.hytale.event.EventRegistration;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterActionType;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterType;
import com.hypixel.hytale.server.core.inventory.container.filter.SlotFilter;
import com.hypixel.hytale.server.core.inventory.transaction.ClearTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.Transaction;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class DelegateItemContainer<T extends ItemContainer> extends ItemContainer {
   private T delegate;
   private final Map<FilterActionType, Int2ObjectConcurrentHashMap<SlotFilter>> slotFilters = new ConcurrentHashMap();
   @Nonnull
   private FilterType globalFilter;

   public DelegateItemContainer(T delegate) {
      this.globalFilter = FilterType.ALLOW_ALL;
      Objects.requireNonNull(delegate, );
      .delegate = delegate;
   }

    T  {
       .delegate;
   }

    <V> V  {
       (V).delegate.readAction(action);
   }

    <X, V> V  {
       (V).delegate.readAction(action, x);
   }

    <V> V  {
       (V).delegate.writeAction(action);
   }

    <X, V> V  {
       (V).delegate.writeAction(action, x);
   }

    ClearTransaction  {
       .delegate.internal_clear();
   }

    ItemStack  {
       .delegate.internal_getSlot(slot);
   }

    ItemStack  {
       .delegate.internal_setSlot(slot, itemStack);
   }

    ItemStack  {
       .delegate.internal_removeSlot(slot);
   }

      {
       (!.globalFilter.allowInput()) {
          ;
      }  {
          .testFilter(FilterActionType.ADD, slot, itemStack) ?  : .delegate.cantAddToSlot(slot, itemStack, slotItemStack);
      }
   }

      {
       (!.globalFilter.allowOutput()) {
          ;
      }  {
          .testFilter(FilterActionType.REMOVE, slot, (ItemStack)) ?  : .delegate.cantRemoveFromSlot(slot);
      }
   }

      {
       .testFilter(FilterActionType.DROP, slot, (ItemStack)) ?  : .delegate.cantDropFromSlot(slot);
   }

      {
       .delegate.cantMoveToSlot(fromContainer, slotFrom);
   }

      {
      Int2ObjectConcurrentHashMap<SlotFilter> map = (Int2ObjectConcurrentHashMap).slotFilters.get(actionType);
       (map == ) {
          ;
      }  {
            map.get(slot);
          (filter == ) {
             ;
         }  {
             !filter.test(actionType, , slot, itemStack);
         }
      }
   }

      {
       .delegate.getCapacity();
   }

    ClearTransaction  {
       .delegate.clear();
   }

   
    DelegateItemContainer<T>  {
        <T>(.delegate);
   }

      {
       .delegate.isEmpty();
   }

      {
      .globalFilter = (FilterType)Objects.requireNonNull(globalFilter);
   }

      {
      validateSlotIndex(slot, .getCapacity());
       (filter != ) {
         ((Int2ObjectConcurrentHashMap).slotFilters.computeIfAbsent(actionType, (k) ->  ())).put(slot, filter);
      }  {
         .slotFilters.computeIfPresent(actionType, (k, map) -> {
            map.remove(slot);
             map.isEmpty() ?  : map;
         });
      }

   }

   
    EventRegistration  {
         .registerChangeEvent(priority, consumer);
      EventRegistration[] delegateRegistration =  []{.delegate.internalChangeEventRegistry.register(priority, (Object), (event) -> consumer.accept( .ItemContainerChangeEvent(, event.transaction().toParent(, (), .delegate))))};
       EventRegistration.combine(thisRegistration, delegateRegistration);
   }

      {
       (transaction.succeeded()) {
         .sendUpdate(transaction);
         .delegate.externalChangeEventRegistry.dispatchFor((Object)).dispatch( .ItemContainerChangeEvent(.delegate, transaction));
      }
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
         DelegateItemContainer<?> that = (DelegateItemContainer)o;
          (.delegate != ) {
             (!.delegate.equals(that.delegate)) {
                ;
            }
         }   (that.delegate != ) {
             ;
         }

          (.slotFilters != ) {
             (!.slotFilters.equals(that.slotFilters)) {
                ;
            }
         }   (that.slotFilters != ) {
             ;
         }

          .globalFilter == that.globalFilter;
      }  {
          ;
      }
   }

      {
         .delegate !=  ? .delegate.hashCode() : ;
      result =  * result + (.slotFilters !=  ? .slotFilters.hashCode() : );
      result =  * result + (.globalFilter !=  ? .globalFilter.hashCode() : );
       result;
   }
}

com/hypixel/hytale/server/core/inventory/container/EmptyItemContainer.java

package com.hypixel.hytale.server.core.inventory.container;

import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.event.EventRegistration;
import com.hypixel.hytale.function.consumer.ShortObjectConsumer;
import com.hypixel.hytale.protocol.ItemWithAllMetadata;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterActionType;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterType;
import com.hypixel.hytale.server.core.inventory.container.filter.SlotFilter;
import com.hypixel.hytale.server.core.inventory.transaction.ClearTransaction;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import javax.annotation.Nonnull;

public class EmptyItemContainer extends ItemContainer {
   public static final EmptyItemContainer INSTANCE = new EmptyItemContainer();
   public static final BuilderCodec<EmptyItemContainer> CODEC = BuilderCodec.builder(EmptyItemContainer.class, () -> INSTANCE).build();
   private static final EventRegistration<Void, ItemContainer.ItemContainerChangeEvent> EVENT_REGISTRATION =  <Void, ItemContainer.ItemContainerChangeEvent>(ItemContainer.ItemContainerChangeEvent.class, () -> , () -> {
   });

     {
   }

      {
       ;
   }

   
    ClearTransaction  {
       ClearTransaction.EMPTY;
   }

      {
   }

    <V> V  {
       (V)action.get();
   }

    <X, V> V  {
       (V)action.apply(x);
   }

    <V> V  {
       (V)action.get();
   }

    <X, V> V  {
       (V)action.apply(x);
   }

   
    ClearTransaction  {
       ClearTransaction.EMPTY;
   }

    ItemStack  {
        ();
   }

    ItemStack  {
        ();
   }

    ItemStack  {
        ();
   }

      {
       ;
   }

      {
       ;
   }

      {
       ;
   }

      {
       ;
   }

   
    List<ItemStack>  {
       Collections.emptyList();
   }

   
    Map<Integer, ItemWithAllMetadata>  {
       Collections.emptyMap();
   }

    EmptyItemContainer  {
       INSTANCE;
   }

    EventRegistration  {
       EVENT_REGISTRATION;
   }

      {
   }

      {
      validateSlotIndex(slot, );
   }
}

com/hypixel/hytale/server/core/inventory/container/InternalContainerUtilItemStack.java

package com.hypixel.hytale.server.core.inventory.container;

import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.transaction.ActionType;
import com.hypixel.hytale.server.core.inventory.transaction.ItemStackSlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ItemStackTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ListTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.SlotTransaction;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.BiPredicate;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class InternalContainerUtilItemStack {
   public InternalContainerUtilItemStack() {
   }

   protected static int testAddToExistingSlot(@Nonnull ItemContainer abstractItemContainer, short slot, ItemStack itemStack, int itemMaxStack, int testQuantityRemaining, boolean filter) {
      ItemStack slotItemStack = abstractItemContainer.internal_getSlot(slot);
      if (ItemStack.isEmpty(slotItemStack)) {
         return testQuantityRemaining;
      }   (!slotItemStack.isStackableWith(itemStack)) {
          testQuantityRemaining;
      }   (filter && abstractItemContainer.cantAddToSlot(slot, itemStack, slotItemStack)) {
          testQuantityRemaining;
      }  {
            slotItemStack.getQuantity();
            Math.min(itemMaxStack - quantity, testQuantityRemaining);
         testQuantityRemaining -= quantityAdjustment;
          testQuantityRemaining;
      }
   }

   
     ItemStackSlotTransaction  {
         container.internal_getSlot(slot);
       (ItemStack.isEmpty(slotItemStack)) {
           (, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), , , filter, , itemStack, itemStack);
      }   (!slotItemStack.isStackableWith(itemStack)) {
           (, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), , , filter, , itemStack, itemStack);
      }   (filter && container.cantAddToSlot(slot, itemStack, slotItemStack)) {
           (, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), , , filter, , itemStack, itemStack);
      }  {
            itemStack.getQuantity();
            slotItemStack.getQuantity();
            Math.min(itemMaxStack - quantity, quantityRemaining);
            quantity + quantityAdjustment;
         quantityRemaining -= quantityAdjustment;
          (quantityAdjustment <= ) {
              (, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), , , filter, , itemStack, itemStack);
         }  {
               slotItemStack.withQuantity(newQuantity);
             (newQuantity > ) {
               container.internal_setSlot(slot, slotNew);
            }  {
               container.internal_removeSlot(slot);
            }

               quantityRemaining != itemStack.getQuantity() ? itemStack.withQuantity(quantityRemaining) : itemStack;
              (, ActionType.ADD, slot, slotItemStack, slotNew, (ItemStack), , , filter, , itemStack, remainder);
         }
      }
   }

   
     ItemStackSlotTransaction  {
         container.internal_getSlot(slot);
       (slotItemStack !=  && !slotItemStack.isEmpty()) {
           (, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), , , filter, , itemStack, itemStack);
      }   (filter && container.cantAddToSlot(slot, itemStack, slotItemStack)) {
           (, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), , , filter, , itemStack, itemStack);
      }  {
            itemStack.getQuantity();
            Math.min(itemMaxStack, quantityRemaining);
         quantityRemaining -= quantityAdjustment;
            itemStack.withQuantity(quantityAdjustment);
         container.internal_setSlot(slot, slotNew);
            itemStack.getQuantity() != quantityRemaining ? itemStack.withQuantity(quantityRemaining) : itemStack;
           (, ActionType.ADD, slot, slotItemStack, slotNew, (ItemStack), , , filter, , itemStack, remainder);
      }
   }

       {
      (   ; i < container.getCapacity() && testQuantityRemaining > ; ++i) {
            container.internal_getSlot(i);
          ((slotItemStack ==  || slotItemStack.isEmpty()) && (!filter || !container.cantAddToSlot(i, itemStack, slotItemStack))) {
               Math.min(itemMaxStack, testQuantityRemaining);
            testQuantityRemaining -= quantityAdjustment;
         }
      }

       testQuantityRemaining;
   }

     ItemStackSlotTransaction  {
      ItemContainer.validateSlotIndex(slot, itemContainer.getCapacity());
       (ItemStackSlotTransaction)itemContainer.writeAction(() -> {
            itemStack.getQuantity();
            itemContainer.internal_getSlot(slot);
          (filter && itemContainer.cantAddToSlot(slot, itemStack, slotItemStack)) {
              (, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, , itemStack, itemStack);
         }   (slotItemStack == ) {
            itemContainer.internal_setSlot(slot, itemStack);
              (, ActionType.ADD, slot, (ItemStack), itemStack, (ItemStack), allOrNothing, , filter, , itemStack, (ItemStack));
         }  {
               slotItemStack.getQuantity();
             (!itemStack.isStackableWith(slotItemStack)) {
                 (, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, , itemStack, itemStack);
            }  {
                  Math.min(slotItemStack.getItem().getMaxStack() - quantity, quantityRemaining);
                  quantity + quantityAdjustment;
               quantityRemaining -= quantityAdjustment;
                (allOrNothing && quantityRemaining > ) {
                    (, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, , itemStack, itemStack);
               }   (quantityAdjustment <= ) {
                    (, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, , itemStack, itemStack);
               }  {
                     slotItemStack.withQuantity(newQuantity);
                  itemContainer.internal_setSlot(slot, newItemStack);
                     itemStack.withQuantity(quantityRemaining);
                    (, ActionType.ADD, slot, slotItemStack, newItemStack, (ItemStack), allOrNothing, , filter, , itemStack, remainder);
               }
            }
         }
      });
   }

   
     ItemStackSlotTransaction  {
      ItemContainer.validateSlotIndex(slot, itemContainer.getCapacity());
       (ItemStackSlotTransaction)itemContainer.writeAction(() -> {
            itemContainer.internal_getSlot(slot);
          (filter && itemContainer.cantAddToSlot(slot, itemStack, slotItemStack)) {
              (, ActionType.SET, slot, slotItemStack, slotItemStack, (ItemStack), , , filter, , itemStack, itemStack);
         }  {
               itemContainer.internal_setSlot(slot, itemStack);
              (, ActionType.SET, slot, oldItemStack, itemStack, (ItemStack), , , filter, , itemStack, (ItemStack));
         }
      });
   }

   
     SlotTransaction  {
      ItemContainer.validateSlotIndex(slot, itemContainer.getCapacity());
       (SlotTransaction)itemContainer.writeAction(() -> {
          (filter && itemContainer.cantRemoveFromSlot(slot)) {
               itemContainer.internal_getSlot(slot);
              (, ActionType.REMOVE, slot, itemStack, itemStack, (ItemStack), , , filter, , (ItemStack), itemStack);
         }  {
               itemContainer.internal_removeSlot(slot);
              (, ActionType.REMOVE, slot, oldItemStack, (ItemStack), oldItemStack, , , );
         }
      });
   }

     ItemStackSlotTransaction  {
      ItemContainer.validateSlotIndex(slot, itemContainer.getCapacity());
      ItemContainer.validateQuantity(quantityToRemove);
       (ItemStackSlotTransaction)itemContainer.writeAction(() -> {
          (filter && itemContainer.cantRemoveFromSlot(slot)) {
               itemContainer.internal_getSlot(slot);
              (, ActionType.REMOVE, slot, itemStack, itemStack, (ItemStack), allOrNothing, , filter, , (ItemStack), itemStack.withQuantity(quantityToRemove));
         }  {
               itemContainer.internal_getSlot(slot);
             (slotItemStack == ) {
                 (, ActionType.REMOVE, slot, (ItemStack), (ItemStack), (ItemStack), allOrNothing, , filter, , (ItemStack), (ItemStack));
            }  {
                  slotItemStack.getQuantity();
                  Math.min(quantity, quantityToRemove);
                  quantity - quantityAdjustment;
                  quantityToRemove - quantityAdjustment;
                (allOrNothing && quantityRemaining > ) {
                    (, ActionType.REMOVE, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, , (ItemStack), slotItemStack.withQuantity(quantityRemaining));
               }  {
                     slotItemStack.withQuantity(newQuantity);
                  itemContainer.internal_setSlot(slot, itemStack);
                     slotItemStack.withQuantity(quantityAdjustment);
                     slotItemStack.withQuantity(quantityRemaining);
                    (, ActionType.REMOVE, slot, slotItemStack, itemStack, newStack, allOrNothing, , filter, , (ItemStack), remainder);
               }
            }
         }
      });
   }

     ItemStackSlotTransaction  {
       internal_removeItemStackFromSlot(itemContainer, slot, itemStackToRemove, quantityToRemove, allOrNothing, filter, (a, b) -> ItemStack.isStackableWith(a, b));
   }

     ItemStackSlotTransaction  {
      ItemContainer.validateSlotIndex(slot, itemContainer.getCapacity());
      ItemContainer.validateQuantity(quantityToRemove);
       (ItemStackSlotTransaction)itemContainer.writeAction(() -> {
          (filter && itemContainer.cantRemoveFromSlot(slot)) {
               itemContainer.internal_getSlot(slot);
              (, ActionType.REMOVE, slot, itemStack, itemStack, (ItemStack), allOrNothing, , filter, , itemStackToRemove, itemStackToRemove);
         }  {
               itemContainer.internal_getSlot(slot);
             ((slotItemStack !=  || itemStackToRemove == ) && (slotItemStack ==  || itemStackToRemove != ) && (slotItemStack ==  || predicate.test(slotItemStack, itemStackToRemove))) {
                (slotItemStack == ) {
                    (, ActionType.REMOVE, slot, (ItemStack), (ItemStack), (ItemStack), allOrNothing, , filter, , itemStackToRemove, itemStackToRemove);
               }  {
                     slotItemStack.getQuantity();
                     Math.min(quantity, quantityToRemove);
                     quantity - quantityAdjustment;
                     quantityToRemove - quantityAdjustment;
                   (allOrNothing && quantityRemaining > ) {
                       (, ActionType.REMOVE, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, , itemStackToRemove, itemStackToRemove);
                  }  {
                        slotItemStack.withQuantity(newQuantity);
                     itemContainer.internal_setSlot(slot, itemStack);
                        slotItemStack.withQuantity(quantityAdjustment);
                        itemStackToRemove.withQuantity(quantityRemaining);
                       (, ActionType.REMOVE, slot, slotItemStack, itemStack, newStack, allOrNothing, , filter, , itemStackToRemove, remainder);
                  }
               }
            }  {
                 (, ActionType.REMOVE, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, , itemStackToRemove, itemStackToRemove);
            }
         }
      });
   }

       {
       testRemoveItemStackFromSlot(container, slot, itemStack, testQuantityRemaining, filter, (a, b) -> ItemStack.isStackableWith(a, b));
   }

       {
       (filter && container.cantRemoveFromSlot(slot)) {
          testQuantityRemaining;
      }  {
            container.internal_getSlot(slot);
          (ItemStack.isEmpty(slotItemStack)) {
             testQuantityRemaining;
         }   (!predicate.test(slotItemStack, itemStack)) {
             testQuantityRemaining;
         }  {
               slotItemStack.getQuantity();
               Math.min(quantity, testQuantityRemaining);
            testQuantityRemaining -= quantityAdjustment;
             testQuantityRemaining;
         }
      }
   }

     ItemStackTransaction  {
         itemStack.getItem();
       (item == ) {
           (itemStack.getItemId() + );
      }  {
            item.getMaxStack();
          (ItemStackTransaction)itemContainer.writeAction(() -> {
             (allOrNothing) {
                  itemStack.getQuantity();
                (!fullStacks) {
                  testQuantityRemaining = testAddToExistingItemStacks(itemContainer, itemStack, itemMaxStack, testQuantityRemaining, filter);
               }

               testQuantityRemaining = testAddToEmptySlots(itemContainer, itemStack, itemMaxStack, testQuantityRemaining, filter);
                (testQuantityRemaining > ) {
                    (, ActionType.ADD, itemStack, itemStack, allOrNothing, filter, Collections.emptyList());
               }
            }

            List<ItemStackSlotTransaction> list =  <ItemStackSlotTransaction>();
               itemStack;
             (!fullStacks) {
               (   ; i < itemContainer.getCapacity() && !ItemStack.isEmpty(remaining); ++i) {
                     internal_addToExistingSlot(itemContainer, i, remaining, itemMaxStack, filter);
                  list.add(transaction);
                  remaining = transaction.getRemainder();
               }
            }

            (   ; i < itemContainer.getCapacity() && !ItemStack.isEmpty(remaining); ++i) {
                  internal_addToEmptySlot(itemContainer, i, remaining, itemMaxStack, filter);
               list.add(transaction);
               remaining = transaction.getRemainder();
            }

              (, ActionType.ADD, itemStack, remaining, allOrNothing, filter, list);
         });
      }
   }

     ListTransaction<ItemStackTransaction>  {
       itemStacks !=  && !itemStacks.isEmpty() ? (ListTransaction)itemContainer.writeAction(() -> {
          (allOrNothing) {
            (ItemStack itemStack : itemStacks) {
                  itemStack.getItem().getMaxStack();
                  itemStack.getQuantity();
                (!fullStacks) {
                  testQuantityRemaining = testAddToExistingItemStacks(itemContainer, itemStack, itemMaxStack, testQuantityRemaining, filter);
               }

               testQuantityRemaining = testAddToEmptySlots(itemContainer, itemStack, itemMaxStack, testQuantityRemaining, filter);
                (testQuantityRemaining > ) {
                    (, (List)itemStacks.stream().map((i) ->  (, ActionType.ADD, itemStack, itemStack, allOrNothing, filter, Collections.emptyList())).collect(Collectors.toList()));
               }
            }
         }

         List<ItemStackTransaction> remainingItemStacks =  <ItemStackTransaction>();

         (ItemStack itemStack : itemStacks) {
            remainingItemStacks.add(internal_addItemStack(itemContainer, itemStack, allOrNothing, fullStacks, filter));
         }

           (, remainingItemStacks);
      }) : ListTransaction.getEmptyTransaction();
   }

     ListTransaction<ItemStackSlotTransaction>  {
       (itemStacks !=  && !itemStacks.isEmpty()) {
         ItemContainer.validateSlotIndex(offset, itemContainer.getCapacity());
         ItemContainer.validateSlotIndex(()(offset + itemStacks.size()), itemContainer.getCapacity());
          (ListTransaction)itemContainer.writeAction(() -> {
             (allOrNothing) {
               (   ; i < itemStacks.size(); ++i) {
                     ()(offset + i);
                     (ItemStack)itemStacks.get(i);
                     itemStack.getItem().getMaxStack();
                     itemStack.getQuantity();
                  testQuantityRemaining = testAddToExistingSlot(itemContainer, slot, itemStack, itemMaxStack, testQuantityRemaining, filter);
                   (testQuantityRemaining > ) {
                     List<ItemStackSlotTransaction> list =  <ItemStackSlotTransaction>();

                     (   ; i1 < itemStacks.size(); ++i1) {
                           ()(offset + i1);
                        list.add( (, ActionType.ADD, islot, (ItemStack), (ItemStack), (ItemStack), allOrNothing, , filter, , itemStack, itemStack));
                     }

                       (, list);
                  }
               }
            }

            List<ItemStackSlotTransaction> remainingItemStacks =  <ItemStackSlotTransaction>();

            (   ; i < itemStacks.size(); ++i) {
                  ()(offset + i);
               remainingItemStacks.add(internal_addItemStackToSlot(itemContainer, slot, (ItemStack)itemStacks.get(i), allOrNothing, filter));
            }

              (, remainingItemStacks);
         });
      }  {
          ListTransaction.<ItemStackSlotTransaction>getEmptyTransaction();
      }
   }

       {
      (   ; i < container.getCapacity() && testQuantityRemaining > ; ++i) {
         testQuantityRemaining = testAddToExistingSlot(container, i, itemStack, itemMaxStack, testQuantityRemaining, filter);
      }

       testQuantityRemaining;
   }

     ItemStackTransaction  {
         itemStack.getItem();
       (item == ) {
           (itemStack.getItemId() + );
      }  {
          (ItemStackTransaction)itemContainer.writeAction(() -> {
             (allOrNothing) {
                  testRemoveItemStackFromItems(itemContainer, itemStack, itemStack.getQuantity(), filter);
                (testQuantityRemaining > ) {
                    (, ActionType.REMOVE, itemStack, itemStack, allOrNothing, filter, Collections.emptyList());
               }
            }

            List<ItemStackSlotTransaction> transactions =  <ItemStackSlotTransaction>();
               itemStack.getQuantity();

            (   ; i < itemContainer.getCapacity() && quantityRemaining > ; ++i) {
                  itemContainer.internal_getSlot(i);
                (!ItemStack.isEmpty(slotItemStack) && slotItemStack.isStackableWith(itemStack)) {
                     internal_removeItemStackFromSlot(itemContainer, i, quantityRemaining, , filter);
                  transactions.add(transaction);
                  quantityRemaining = transaction.getRemainder() !=  ? transaction.getRemainder().getQuantity() : ;
               }
            }

               quantityRemaining >  ? itemStack.withQuantity(quantityRemaining) : ;
              (, ActionType.REMOVE, itemStack, remainder, allOrNothing, filter, transactions);
         });
      }
   }

     ListTransaction<ItemStackTransaction>  {
       (itemStacks !=  && !itemStacks.isEmpty()) {
         (ItemStack itemStack : itemStacks) {
               itemStack.getItem();
             (item == ) {
                 (itemStack.getItemId() + );
            }
         }

          (ListTransaction)itemContainer.writeAction(() -> {
             (allOrNothing) {
               (ItemStack itemStack : itemStacks) {
                     testRemoveItemStackFromItems(itemContainer, itemStack, itemStack.getQuantity(), filter);
                   (testQuantityRemaining > ) {
                       (, (List)itemStacks.stream().map((ix) ->  (, ActionType.ADD, itemStack, itemStack, allOrNothing, filter, Collections.emptyList())).collect(Collectors.toList()));
                  }
               }
            }

            List<ItemStackTransaction> transactions =  <ItemStackTransaction>();

            (   ; i < itemStacks.size(); ++i) {
               transactions.add(internal_removeItemStack(itemContainer, (ItemStack)itemStacks.get(i), allOrNothing, filter));
            }

              (, transactions);
         });
      }  {
          ListTransaction.<ItemStackTransaction>getEmptyTransaction();
      }
   }

       {
      (   ; i < container.getCapacity() && testQuantityRemaining > ; ++i) {
          (!filter || !container.cantRemoveFromSlot(i)) {
               container.internal_getSlot(i);
             (!ItemStack.isEmpty(slotItemStack) && slotItemStack.isStackableWith(itemStack)) {
                  slotItemStack.getQuantity();
                  Math.min(quantity, testQuantityRemaining);
               testQuantityRemaining -= quantityAdjustment;
            }
         }
      }

       testQuantityRemaining;
   }

     TestRemoveItemSlotResult  {
       testRemoveItemStackSlotFromItems(container, itemStack, testQuantityRemaining, filter, (a, b) -> ItemStack.isStackableWith(a, b));
   }

     TestRemoveItemSlotResult  {
          (testQuantityRemaining);

      (   ; i < container.getCapacity() && result.quantityRemaining > ; ++i) {
          (!filter || !container.cantRemoveFromSlot(i)) {
               container.internal_getSlot(i);
             (!ItemStack.isEmpty(slotItemStack) && predicate.test(slotItemStack, itemStack)) {
                  slotItemStack.getQuantity();
                  Math.min(quantity, result.quantityRemaining);
               result.quantityRemaining -= quantityAdjustment;
               result.picked.put(i, quantityAdjustment);
            }
         }
      }

       result;
   }
}

com/hypixel/hytale/server/core/inventory/container/InternalContainerUtilMaterial.java

package com.hypixel.hytale.server.core.inventory.container;

import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.MaterialQuantity;
import com.hypixel.hytale.server.core.inventory.transaction.ActionType;
import com.hypixel.hytale.server.core.inventory.transaction.ItemStackSlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ListTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.MaterialSlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.MaterialTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ResourceSlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.SlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.TagSlotTransaction;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class InternalContainerUtilMaterial {
   public InternalContainerUtilMaterial() {
   }

   @Nonnull
   protected static MaterialSlotTransaction internal_removeMaterialFromSlot(@Nonnull ItemContainer itemContainer, short slot, @Nonnull MaterialQuantity material, boolean allOrNothing, boolean filter) {
      ItemContainer.validateSlotIndex(slot, itemContainer.getCapacity());
      ItemContainer.validateQuantity(material.getQuantity());
       (material.getItemId() != ) {
            InternalContainerUtilItemStack.internal_removeItemStackFromSlot(itemContainer, slot, material.toItemStack(), material.getQuantity(), allOrNothing, filter, (a, b) -> ItemStack.isEquivalentType(a, b));
           (material, slotTransaction.getRemainder() !=  ? slotTransaction.getRemainder().getQuantity() : , slotTransaction);
      }   (material.getTagIndex() != -) {
            InternalContainerUtilTag.internal_removeTagFromSlot(itemContainer, slot, material.getTagIndex(), material.getQuantity(), allOrNothing, filter);
           (material, tagTransaction.getRemainder(), tagTransaction);
      }  {
            InternalContainerUtilResource.internal_removeResourceFromSlot(itemContainer, slot, material.toResource(), allOrNothing, filter);
           (material, resourceTransaction.getRemainder(), resourceTransaction);
      }
   }

     MaterialTransaction  {
       (MaterialTransaction)itemContainer.writeAction(() -> {
          (allOrNothing || exactAmount) {
               testRemoveMaterialFromItems(itemContainer, material, material.getQuantity(), filter);
             (testQuantityRemaining > ) {
                 (, ActionType.REMOVE, material, material.getQuantity(), allOrNothing, exactAmount, filter, Collections.emptyList());
            }

             (exactAmount && testQuantityRemaining < ) {
                 (, ActionType.REMOVE, material, material.getQuantity(), allOrNothing, exactAmount, filter, Collections.emptyList());
            }
         }

         List<MaterialSlotTransaction> list =  <MaterialSlotTransaction>();
            material.getQuantity();

         (   ; i < itemContainer.getCapacity() && quantityRemaining > ; ++i) {
               material.clone(quantityRemaining);
               internal_removeMaterialFromSlot(itemContainer, i, clone, , filter);
             (transaction.succeeded()) {
               list.add(transaction);
               quantityRemaining = transaction.getRemainder();
            }
         }

           (quantityRemaining != material.getQuantity(), ActionType.REMOVE, material, material.getQuantity(), allOrNothing, exactAmount, filter, list);
      });
   }

     ListTransaction<MaterialTransaction>  {
       materials !=  && !materials.isEmpty() ? (ListTransaction)itemContainer.writeAction(() -> {
          (allOrNothing || exactAmount) {
            (MaterialQuantity material : materials) {
                  testRemoveMaterialFromItems(itemContainer, material, material.getQuantity(), filter);
                (testQuantityRemaining > ) {
                    (, (List)materials.stream().map((remainder) ->  (, ActionType.REMOVE, material, material.getQuantity(), allOrNothing, exactAmount, filter, Collections.emptyList())).collect(Collectors.toList()));
               }

                (exactAmount && testQuantityRemaining < ) {
                    (, (List)materials.stream().map((remainder) ->  (, ActionType.REMOVE, material, material.getQuantity(), allOrNothing, exactAmount, filter, Collections.emptyList())).collect(Collectors.toList()));
               }
            }
         }

         List<MaterialTransaction> transactions =  <MaterialTransaction>();

         (MaterialQuantity material : materials) {
            transactions.add(internal_removeMaterial(itemContainer, material, allOrNothing, exactAmount, filter));
         }

           (, transactions);
      }) : ListTransaction.getEmptyTransaction();
   }

       {
       (material.getItemId() != ) {
          InternalContainerUtilItemStack.testRemoveItemStackFromItems(container, material.toItemStack(), testQuantityRemaining, filter);
      }  {
          material.getTagIndex() != - ? InternalContainerUtilTag.testRemoveTagFromItems(container, material.getTagIndex(), testQuantityRemaining, filter) : InternalContainerUtilResource.testRemoveResourceFromItems(container, material.toResource(), testQuantityRemaining, filter);
      }
   }

     TestRemoveItemSlotResult  {
       (material.getItemId() != ) {
          InternalContainerUtilItemStack.testRemoveItemStackSlotFromItems(container, material.toItemStack(), testQuantityRemaining, filter, (a, b) -> ItemStack.isEquivalentType(a, b));
      }  {
          material.getTagIndex() != - ? InternalContainerUtilTag.testRemoveTagSlotFromItems(container, material.getTagIndex(), testQuantityRemaining, filter) : InternalContainerUtilResource.testRemoveResourceSlotFromItems(container, material.toResource(), testQuantityRemaining, filter);
      }
   }

     ListTransaction<MaterialSlotTransaction>  {
       (materials !=  && !materials.isEmpty()) {
          offset + materials.size() > itemContainer.getCapacity() ? ListTransaction.getEmptyTransaction() : (ListTransaction)itemContainer.writeAction(() -> {
             (allOrNothing || exactAmount) {
               (   ; i < materials.size(); ++i) {
                     ()(offset + i);
                     (MaterialQuantity)materials.get(i);
                     testRemoveMaterialFromSlot(itemContainer, slot, material, material.getQuantity(), filter);
                   (testQuantityRemaining > ) {
                     List<MaterialSlotTransaction> list =  <MaterialSlotTransaction>();

                     (   ; i1 < materials.size(); ++i1) {
                           ()(offset + i1);
                        list.add( (material, material.getQuantity(),  (, ActionType.REMOVE, islot, (ItemStack), (ItemStack), (ItemStack), allOrNothing, exactAmount, filter)));
                     }

                       (, list);
                  }

                   (exactAmount && testQuantityRemaining < ) {
                     List<MaterialSlotTransaction> list =  <MaterialSlotTransaction>();

                     (   ; i1 < materials.size(); ++i1) {
                           ()(offset + i1);
                        list.add( (material, material.getQuantity(),  (, ActionType.REMOVE, islot, (ItemStack), (ItemStack), (ItemStack), allOrNothing, exactAmount, filter)));
                     }

                       (, list);
                  }
               }
            }

            List<MaterialSlotTransaction> transactions =  <MaterialSlotTransaction>();

            (   ; i < materials.size(); ++i) {
                  ()(offset + i);
                  (MaterialQuantity)materials.get(i);
               transactions.add(internal_removeMaterialFromSlot(itemContainer, slot, material, allOrNothing, filter));
            }

              (, transactions);
         });
      }  {
          ListTransaction.<MaterialSlotTransaction>getEmptyTransaction();
      }
   }

       {
       (material.getItemId() != ) {
          InternalContainerUtilItemStack.testRemoveItemStackFromSlot(container, slot, material.toItemStack(), testQuantityRemaining, filter, (a, b) -> ItemStack.isEquivalentType(a, b));
      }  {
          material.getTagIndex() != - ? InternalContainerUtilTag.testRemoveTagFromSlot(container, slot, material.getTagIndex(), testQuantityRemaining, filter) : InternalContainerUtilResource.testRemoveResourceFromSlot(container, slot, material.toResource(), testQuantityRemaining, filter);
      }
   }
}

com/hypixel/hytale/server/core/inventory/container/InternalContainerUtilResource.java

package com.hypixel.hytale.server.core.inventory.container;

import com.hypixel.hytale.math.util.MathUtil;
import com.hypixel.hytale.protocol.ItemResourceType;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.ResourceQuantity;
import com.hypixel.hytale.server.core.inventory.transaction.ActionType;
import com.hypixel.hytale.server.core.inventory.transaction.ListTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ResourceSlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ResourceTransaction;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class InternalContainerUtilResource {
   public InternalContainerUtilResource() {
   }

   protected static ResourceSlotTransaction internal_removeResourceFromSlot(@Nonnull ItemContainer itemContainer, short slot, @Nonnull ResourceQuantity resource, boolean allOrNothing, boolean filter) {
      ItemContainer.validateSlotIndex(slot, itemContainer.getCapacity());
      ItemContainer.validateQuantity(resource.getQuantity());
      return (ResourceSlotTransaction)itemContainer.writeAction(() -> {
         if (filter && itemContainer.cantRemoveFromSlot(slot)) {
               itemContainer.internal_getSlot(slot);
              (, ActionType.REMOVE, slot, itemStack, itemStack, (ItemStack), allOrNothing, , filter, resource, resource.getQuantity(), );
         }  {
               itemContainer.internal_getSlot(slot);
             (slotItemStack == ) {
                 (, ActionType.REMOVE, slot, (ItemStack), (ItemStack), (ItemStack), allOrNothing, , filter, resource, resource.getQuantity(), );
            }  {
                  slotItemStack.getItem();
                  slotItemStack.getQuantity();
                  resource.getResourceType(slotItem);
                (resourceType == ) {
                    (, ActionType.REMOVE, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, resource, resource.getQuantity(), );
               }  {
                     resourceType.quantity;
                     resource.getQuantity();
                     MathUtil.ceil(()quantityRemaining / ()resourceTypeQuantity);
                     Math.min(quantityInItems, quantityInItemsRemaining);
                     Math.max(quantityInItems - quantityInItemsAdjustment, );
                     quantityInItemsAdjustment * resourceTypeQuantity;
                  quantityRemaining -= quantityAdjustment;
                   (allOrNothing && quantityRemaining > ) {
                       (, ActionType.REMOVE, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, resource, resource.getQuantity(), );
                  }   (quantityAdjustment <= ) {
                       (, ActionType.REMOVE, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, resource, resource.getQuantity(), );
                  }  {
                        slotItemStack.withQuantity(newItemStackQuantity);
                     itemContainer.internal_setSlot(slot, slotNewItemStack);
                        slotItemStack.withQuantity(quantityInItemsAdjustment);
                       (, ActionType.REMOVE, slot, slotItemStack, slotNewItemStack, newStack, allOrNothing, , filter, resource, quantityRemaining, quantityAdjustment);
                  }
               }
            }
         }
      });
   }

     ResourceTransaction  {
       (ResourceTransaction)itemContainer.writeAction(() -> {
          (allOrNothing || exactAmount) {
               testRemoveResourceFromItems(itemContainer, resource, resource.getQuantity(), filter);
             (testQuantityRemaining > ) {
                 (, ActionType.REMOVE, resource, resource.getQuantity(), , allOrNothing, exactAmount, filter, Collections.emptyList());
            }

             (exactAmount && testQuantityRemaining < ) {
                 (, ActionType.REMOVE, resource, resource.getQuantity(), , allOrNothing, exactAmount, filter, Collections.emptyList());
            }
         }

         List<ResourceSlotTransaction> list =  <ResourceSlotTransaction>();
            ;
            resource.getQuantity();

         (   ; i < itemContainer.getCapacity() && quantityRemaining > ; ++i) {
               resource.clone(quantityRemaining);
               internal_removeResourceFromSlot(itemContainer, i, clone, , filter);
             (transaction.succeeded()) {
               list.add(transaction);
               quantityRemaining = transaction.getRemainder();
               consumed += transaction.getConsumed();
            }
         }

           (quantityRemaining != resource.getQuantity(), ActionType.REMOVE, resource, quantityRemaining, consumed, allOrNothing, exactAmount, filter, list);
      });
   }

     ListTransaction<ResourceTransaction>  {
       resources !=  && !resources.isEmpty() ? (ListTransaction)itemContainer.writeAction(() -> {
          (allOrNothing || exactAmount) {
            (ResourceQuantity resource : resources) {
                  testRemoveResourceFromItems(itemContainer, resource, resource.getQuantity(), filter);
                (testQuantityRemaining > ) {
                    (, (List)resources.stream().map((remainder) ->  (, ActionType.REMOVE, resource, resource.getQuantity(), , allOrNothing, exactAmount, filter, Collections.emptyList())).collect(Collectors.toList()));
               }

                (exactAmount && testQuantityRemaining < ) {
                    (, (List)resources.stream().map((remainder) ->  (, ActionType.REMOVE, resource, resource.getQuantity(), , allOrNothing, exactAmount, filter, Collections.emptyList())).collect(Collectors.toList()));
               }
            }
         }

         List<ResourceTransaction> transactions =  <ResourceTransaction>();

         (ResourceQuantity resource : resources) {
            transactions.add(internal_removeResource(itemContainer, resource, allOrNothing, exactAmount, filter));
         }

           (, transactions);
      }) : ListTransaction.getEmptyTransaction();
   }

       {
      (   ; i < container.getCapacity() && testQuantityRemaining > ; ++i) {
         testQuantityRemaining = testRemoveResourceFromSlot(container, i, resource, testQuantityRemaining, filter);
      }

       testQuantityRemaining;
   }

     TestRemoveItemSlotResult  {
          (testQuantityRemaining);

      (   ; i < container.getCapacity() && result.quantityRemaining > ; ++i) {
            testRemoveResourceFromSlot(container, i, resource, result.quantityRemaining, filter);
          (newValue != result.quantityRemaining) {
               result.quantityRemaining - newValue;
            result.quantityRemaining = newValue;
            result.picked.put(i, diff);
         }
      }

       result;
   }

       {
       (filter && container.cantRemoveFromSlot(slot)) {
          testQuantityRemaining;
      }  {
            container.internal_getSlot(slot);
          (ItemStack.isEmpty(slotItemStack)) {
             testQuantityRemaining;
         }  {
               slotItemStack.getItem();
               resource.getResourceType(slotItem);
             (resourceType == ) {
                testQuantityRemaining;
            }  {
                  resourceType.quantity;
                  MathUtil.ceil(()testQuantityRemaining / ()resourceTypeQuantity);
                  slotItemStack.getQuantity();
                  Math.min(quantityInItems, quantityInItemsRemaining);
                  quantityInItemsAdjustment * resourceTypeQuantity;
               testQuantityRemaining -= quantityAdjustment;
                testQuantityRemaining;
            }
         }
      }
   }
}

com/hypixel/hytale/server/core/inventory/container/InternalContainerUtilTag.java

package com.hypixel.hytale.server.core.inventory.container;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.transaction.ActionType;
import com.hypixel.hytale.server.core.inventory.transaction.TagSlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.TagTransaction;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.Collections;
import java.util.List;
import javax.annotation.Nonnull;

public class InternalContainerUtilTag {
   public InternalContainerUtilTag() {
   }

   protected static TagSlotTransaction internal_removeTagFromSlot(@Nonnull ItemContainer itemContainer, short slot, int tagIndex, int quantity, boolean allOrNothing, boolean filter) {
      ItemContainer.validateSlotIndex(slot, itemContainer.getCapacity());
      ItemContainer.validateQuantity(quantity);
      return (TagSlotTransaction)itemContainer.writeAction(() -> {
         if (filter && itemContainer.cantRemoveFromSlot(slot)) {
            ItemStack itemStack = itemContainer.internal_getSlot(slot);
            return new TagSlotTransaction(false, ActionType.REMOVE, slot, itemStack, itemStack, (ItemStack), allOrNothing, , filter, tagIndex, quantity);
         }  {
               itemContainer.internal_getSlot(slot);
             (slotItemStack == ) {
                 (, ActionType.REMOVE, slot, (ItemStack), (ItemStack), (ItemStack), allOrNothing, , filter, tagIndex, quantity);
            }  {
                  slotItemStack.getItem();
                  slotItemStack.getQuantity();
                (slotItem.getData() !=  && slotItem.getData().getExpandedTagIndexes().contains(tagIndex)) {
                     Math.min(quantityInItems, quantity);
                     quantityInItems - quantityInItemsAdjustment;
                     quantity - quantityInItemsAdjustment;
                   (allOrNothing && quantityRemaining > ) {
                       (, ActionType.REMOVE, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, tagIndex, quantity);
                  }  {
                        slotItemStack.withQuantity(newItemStackQuantity);
                     itemContainer.internal_setSlot(slot, slotNewItemStack);
                        slotItemStack.withQuantity(quantityInItemsAdjustment);
                       (, ActionType.REMOVE, slot, slotItemStack, slotNewItemStack, newStack, allOrNothing, , filter, tagIndex, quantityRemaining);
                  }
               }  {
                    (, ActionType.REMOVE, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, tagIndex, quantity);
               }
            }
         }
      });
   }

     TagTransaction  {
       (TagTransaction)itemContainer.writeAction(() -> {
          (allOrNothing || exactAmount) {
               testRemoveTagFromItems(itemContainer, tagIndex, quantity, filter);
             (testQuantityRemaining > ) {
                 (, ActionType.REMOVE, tagIndex, quantity, allOrNothing, exactAmount, filter, Collections.emptyList());
            }

             (exactAmount && testQuantityRemaining < ) {
                 (, ActionType.REMOVE, tagIndex, quantity, allOrNothing, exactAmount, filter, Collections.emptyList());
            }
         }

         List<TagSlotTransaction> list =  <TagSlotTransaction>();
            quantity;

         (   ; i < itemContainer.getCapacity() && quantityRemaining > ; ++i) {
               internal_removeTagFromSlot(itemContainer, i, tagIndex, quantityRemaining, allOrNothing, filter);
            list.add(transaction);
            quantityRemaining = transaction.getRemainder();
         }

           (, ActionType.REMOVE, tagIndex, quantityRemaining, allOrNothing, exactAmount, filter, list);
      });
   }

       {
      (   ; i < container.getCapacity() && testQuantityRemaining > ; ++i) {
          (!filter || !container.cantRemoveFromSlot(i)) {
               container.internal_getSlot(i);
             (!ItemStack.isEmpty(slotItemStack)) {
               AssetExtraInfo.   slotItemStack.getItem().getData();
                (slotItemData !=  && slotItemData.getExpandedTagIndexes().contains(tagIndex)) {
                     slotItemStack.getQuantity();
                  testQuantityRemaining -= Math.min(quantityInItems, testQuantityRemaining);
               }
            }
         }
      }

       testQuantityRemaining;
   }

     TestRemoveItemSlotResult  {
          (testQuantityRemaining);

      (   ; i < container.getCapacity() && result.quantityRemaining > ; ++i) {
          (!filter || !container.cantRemoveFromSlot(i)) {
               container.internal_getSlot(i);
             (!ItemStack.isEmpty(slotItemStack)) {
               AssetExtraInfo.   slotItemStack.getItem().getData();
                (slotItemData !=  && slotItemData.getExpandedTagIndexes().contains(tagIndex)) {
                     slotItemStack.getQuantity();
                  result.quantityRemaining -= Math.min(quantityInItems, result.quantityRemaining);
               }
            }
         }
      }

       result;
   }

       {
       (filter && container.cantRemoveFromSlot(slot)) {
          testQuantityRemaining;
      }  {
            container.internal_getSlot(slot);
          (ItemStack.isEmpty(slotItemStack)) {
             testQuantityRemaining;
         }  {
               slotItemStack.getItem();
             (!slotItem.getData().getExpandedTagIndexes().contains(tagIndex)) {
                testQuantityRemaining;
            }  {
                  slotItemStack.getQuantity();
               testQuantityRemaining -= Math.min(quantityInItems, testQuantityRemaining);
                testQuantityRemaining;
            }
         }
      }
   }
}

com/hypixel/hytale/server/core/inventory/container/ItemContainer.java

package com.hypixel.hytale.server.core.inventory.container;

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

    {
      CodecMapCodec<ItemContainer> CODEC =  <ItemContainer>();
         ;
         ;
         ;
         ;
         ;
         HytaleLogger.forEnclosingClass();
     SyncEventBusRegistry<Void, ItemContainerChangeEvent> externalChangeEventRegistry;
     SyncEventBusRegistry<Void, ItemContainerChangeEvent> internalChangeEventRegistry;

     {
      .externalChangeEventRegistry =  <Void, ItemContainerChangeEvent>(LOGGER, ItemContainerChangeEvent.class);
      .internalChangeEventRegistry =  <Void, ItemContainerChangeEvent>(LOGGER, ItemContainerChangeEvent.class);
   }

      ;

      ;

      ;

     ItemContainer ;

     <V> V ;

     <X, V> V ;

     <V> V ;

     <X, V> V ;

     ClearTransaction ;

   
     ItemStack ;

   
     ItemStack ;

   
     ItemStack ;

      ;

      ;

      ;

      ;

   
    InventorySection  {
          ();
      packet.capacity = .getCapacity();
      packet.items = .toProtocolMap();
       packet;
   }

   
    Map<Integer, ItemWithAllMetadata>  {
      Map<Integer, ItemWithAllMetadata> map =  ();
      .forEachWithMeta((slot, itemStack, _map) -> {
          (!ItemStack.isEmpty(itemStack) && itemStack.isValid()) {
            _map.put(Integer.valueOf(slot), itemStack.toPacket());
         }
      }, map);
       map;
   }

    EventRegistration  {
       .registerChangeEvent((), consumer);
   }

    EventRegistration  {
       .registerChangeEvent(priority.getValue(), consumer);
   }

    EventRegistration  {
       .externalChangeEventRegistry.register(priority, (Object), consumer);
   }

    ClearTransaction  {
         (ClearTransaction).writeAction(::internal_clear);
      .sendUpdate(transaction);
       transaction;
   }

      {
      validateSlotIndex(slot, .getCapacity());
       (Boolean).writeAction(() -> {
            itemStack.getQuantity();
            .internal_getSlot(slot);
          (filter && .cantAddToSlot(slot, itemStack, slotItemStack)) {
             ;
         }   (slotItemStack == ) {
             ;
         }   (!itemStack.isStackableWith(slotItemStack)) {
             ;
         }  {
               slotItemStack.getQuantity();
               Math.min(slotItemStack.getItem().getMaxStack() - quantity, quantityRemaining);
               quantityRemaining - quantityAdjustment;
             allOrNothing ? quantityRemaining <=  : quantityRemaining != newQuantityRemaining;
         }
      });
   }

   
    ItemStackSlotTransaction  {
       .addItemStackToSlot(slot, itemStack, , );
   }

   
    ItemStackSlotTransaction  {
         InternalContainerUtilItemStack.internal_addItemStackToSlot(, slot, itemStack, allOrNothing, filter);
      .sendUpdate(transaction);
       transaction;
   }

   
    ItemStackSlotTransaction  {
       .setItemStackForSlot(slot, itemStack, );
   }

   
    ItemStackSlotTransaction  {
         InternalContainerUtilItemStack.internal_setItemStackForSlot(, slot, itemStack, filter);
      .sendUpdate(transaction);
       transaction;
   }

   
    ItemStack  {
      validateSlotIndex(slot, .getCapacity());
       (ItemStack).readAction(() -> .internal_getSlot(slot));
   }

   
    ItemStackSlotTransaction  {
         .internal_replaceItemStack(slot, itemStackToRemove, itemStack);
      .sendUpdate(transaction);
       transaction;
   }

    ListTransaction<ItemStackSlotTransaction>  {
       .replaceAll(func, );
   }

    ListTransaction<ItemStackSlotTransaction>  {
      ListTransaction<ItemStackSlotTransaction> transaction = (ListTransaction).writeAction(() -> {
            .getCapacity();
         ObjectArrayList<ItemStackSlotTransaction> transactionsList =  <ItemStackSlotTransaction>(capacity);

         (   ; slot < capacity; ++slot) {
               .internal_getSlot(slot);
             (!ignoreEmpty || !ItemStack.isEmpty(existing)) {
                  func.replace(slot, existing);
               .internal_setSlot(slot, replacement);
               transactionsList.add( (, ActionType.REPLACE, slot, existing, replacement, existing, , , , , replacement, replacement));
            }
         }

           (, transactionsList);
      });
      .sendUpdate(transaction);
       transaction;
   }

    ItemStackSlotTransaction  {
      validateSlotIndex(slot, .getCapacity());
       (ItemStackSlotTransaction).writeAction(() -> {
            .internal_getSlot(slot);
          ((slotItemStack !=  || itemStackToRemove == ) && (slotItemStack ==  || itemStackToRemove != ) && (slotItemStack ==  || itemStackToRemove.isStackableWith(slotItemStack))) {
            .internal_setSlot(slot, itemStack);
              (, ActionType.REPLACE, slot, slotItemStack, itemStack, slotItemStack, , , , , itemStack, (ItemStack));
         }  {
              (, ActionType.REPLACE, slot, slotItemStack, slotItemStack, (ItemStack), , , , , itemStack, itemStack);
         }
      });
   }

   
    SlotTransaction  {
       .removeItemStackFromSlot(slot, );
   }

   
    SlotTransaction  {
         InternalContainerUtilItemStack.internal_removeItemStackFromSlot(, slot, filter);
      .sendUpdate(transaction);
       transaction;
   }

   
    ItemStackSlotTransaction  {
       .removeItemStackFromSlot(slot, quantityToRemove, , );
   }

   
    ItemStackSlotTransaction  {
         InternalContainerUtilItemStack.internal_removeItemStackFromSlot(, slot, quantityToRemove, allOrNothing, filter);
      .sendUpdate(transaction);
       transaction;
   }

   
   
    ItemStackSlotTransaction  {
       InternalContainerUtilItemStack.internal_removeItemStackFromSlot(, slot, quantityToRemove, , );
   }

   
    ItemStackSlotTransaction  {
       .removeItemStackFromSlot(slot, itemStackToRemove, quantityToRemove, , );
   }

   
    ItemStackSlotTransaction  {
         InternalContainerUtilItemStack.internal_removeItemStackFromSlot(, slot, itemStackToRemove, quantityToRemove, allOrNothing, filter);
      .sendUpdate(transaction);
       transaction;
   }

   
    MaterialSlotTransaction  {
       .removeMaterialFromSlot(slot, material, , , );
   }

   
    MaterialSlotTransaction  {
         InternalContainerUtilMaterial.internal_removeMaterialFromSlot(, slot, material, allOrNothing, filter);
      .sendUpdate(transaction);
       transaction;
   }

   
    ResourceSlotTransaction  {
       .removeResourceFromSlot(slot, resource, , , );
   }

   
    ResourceSlotTransaction  {
         InternalContainerUtilResource.internal_removeResourceFromSlot(, slot, resource, allOrNothing, filter);
      .sendUpdate(transaction);
       transaction;
   }

   
    TagSlotTransaction  {
       .removeTagFromSlot(slot, tagIndex, quantity, , );
   }

   
    TagSlotTransaction  {
         InternalContainerUtilTag.internal_removeTagFromSlot(, slot, tagIndex, quantity, allOrNothing, filter);
      .sendUpdate(transaction);
       transaction;
   }

   
    MoveTransaction<ItemStackTransaction>  {
       .moveItemStackFromSlot(slot, containerTo, );
   }

   
    MoveTransaction<ItemStackTransaction>  {
       .moveItemStackFromSlot(slot, containerTo, , filter);
   }

   
    MoveTransaction<ItemStackTransaction>  {
      MoveTransaction<ItemStackTransaction> transaction = .internal_moveItemStackFromSlot(slot, containerTo, allOrNothing, filter);
      .sendUpdate(transaction);
      containerTo.sendUpdate(transaction.toInverted());
       transaction;
   }

    MoveTransaction<ItemStackTransaction>  {
      validateSlotIndex(slot, .getCapacity());
       (MoveTransaction).writeAction(() -> (MoveTransaction)containerTo.writeAction(() -> {
             (filter && .cantRemoveFromSlot(slot)) {
                ;
            }  {
                  .internal_removeSlot(slot);
                (ItemStack.isEmpty(itemFrom)) {
                      (, ActionType.REMOVE, slot, (ItemStack), (ItemStack), (ItemStack), , , filter);
                    (, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, ItemStackTransaction.FAILED_ADD);
               }  {
                      (, ActionType.REMOVE, slot, itemFrom, (ItemStack), (ItemStack), , , filter);
                     InternalContainerUtilItemStack.internal_addItemStack(containerTo, itemFrom, allOrNothing, , filter);
                     addTransaction.getRemainder();
                   (!ItemStack.isEmpty(remainder)) {
                     InternalContainerUtilItemStack.internal_addItemStackToSlot(, slot, remainder, allOrNothing, );
                  }

                    (addTransaction.succeeded(), fromTransaction, MoveType.MOVE_FROM_SELF, containerTo, addTransaction);
               }
            }
         }));
   }

   
    MoveTransaction<ItemStackTransaction>  {
       .moveItemStackFromSlot(slot, quantity, containerTo, , );
   }

   
    MoveTransaction<ItemStackTransaction>  {
      MoveTransaction<ItemStackTransaction> transaction = .internal_moveItemStackFromSlot(slot, quantity, containerTo, allOrNothing, filter);
      .sendUpdate(transaction);
      containerTo.sendUpdate(transaction.toInverted());
       transaction;
   }

    MoveTransaction<ItemStackTransaction>  {
      validateSlotIndex(slot, .getCapacity());
      validateQuantity(quantity);
       (MoveTransaction).writeAction(() -> (MoveTransaction)containerTo.writeAction(() -> {
             (filter && .cantRemoveFromSlot(slot)) {
                ;
            }   (filter && containerTo.cantMoveToSlot(, slot)) {
                  .internal_getSlot(slot);
                   (, ActionType.REMOVE, slot, itemStack, itemStack, (ItemStack), , , filter);
                 (, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, ItemStackTransaction.FAILED_ADD);
            }  {
                  .internal_removeItemStack(slot, quantity);
                (!fromTransaction.succeeded()) {
                      (, ActionType.REMOVE, slot, (ItemStack), (ItemStack), (ItemStack), , , filter);
                    (, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, ItemStackTransaction.FAILED_ADD);
               }  {
                     fromTransaction.getOutput();
                   (ItemStack.isEmpty(itemFrom)) {
                         (, ActionType.REMOVE, slot, (ItemStack), (ItemStack), (ItemStack), , , filter);
                       (, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, ItemStackTransaction.FAILED_ADD);
                  }  {
                        InternalContainerUtilItemStack.internal_addItemStack(containerTo, itemFrom, allOrNothing, , filter);
                        addTransaction.getRemainder();
                      (!ItemStack.isEmpty(remainder)) {
                        InternalContainerUtilItemStack.internal_addItemStackToSlot(, slot, remainder, allOrNothing, );
                     }

                       (addTransaction.succeeded(), fromTransaction, MoveType.MOVE_FROM_SELF, containerTo, addTransaction);
                  }
               }
            }
         }));
   }

   
    ListTransaction<MoveTransaction<ItemStackTransaction>>  {
       .moveItemStackFromSlot(slot, , , containerTo);
   }

   
    ListTransaction<MoveTransaction<ItemStackTransaction>>  {
      ListTransaction<MoveTransaction<ItemStackTransaction>> transaction = .internal_moveItemStackFromSlot(slot, allOrNothing, filter, containerTo);
      .sendUpdate(transaction);

      (MoveTransaction<ItemStackTransaction> moveItemStackTransaction : transaction.getList()) {
         moveItemStackTransaction.getOtherContainer().sendUpdate(moveItemStackTransaction.toInverted());
      }

       transaction;
   }

   
    ListTransaction<MoveTransaction<ItemStackTransaction>>  {
      List<MoveTransaction<ItemStackTransaction>> transactions =  <MoveTransaction<ItemStackTransaction>>();

      (ItemContainer itemContainer : containerTo) {
         MoveTransaction<ItemStackTransaction> transaction = .internal_moveItemStackFromSlot(slot, itemContainer, allOrNothing, filter);
         transactions.add(transaction);
          (transaction.succeeded()) {
               transaction.getAddTransaction();
             (ItemStack.isEmpty(addTransaction.getRemainder())) {
               ;
            }
         }
      }

        <MoveTransaction<ItemStackTransaction>>(!transactions.isEmpty(), transactions);
   }

   
    ListTransaction<MoveTransaction<ItemStackTransaction>>  {
       .moveItemStackFromSlot(slot, quantity, , , containerTo);
   }

   
    ListTransaction<MoveTransaction<ItemStackTransaction>>  {
      ListTransaction<MoveTransaction<ItemStackTransaction>> transaction = .internal_moveItemStackFromSlot(slot, quantity, allOrNothing, filter, containerTo);
      .sendUpdate(transaction);

      (MoveTransaction<ItemStackTransaction> moveItemStackTransaction : transaction.getList()) {
         moveItemStackTransaction.getOtherContainer().sendUpdate(moveItemStackTransaction.toInverted());
      }

       transaction;
   }

   
    ListTransaction<MoveTransaction<ItemStackTransaction>>  {
      List<MoveTransaction<ItemStackTransaction>> transactions =  <MoveTransaction<ItemStackTransaction>>();

      (ItemContainer itemContainer : containerTo) {
         MoveTransaction<ItemStackTransaction> transaction = .internal_moveItemStackFromSlot(slot, quantity, itemContainer, allOrNothing, filter);
         transactions.add(transaction);
          (transaction.succeeded()) {
               transaction.getAddTransaction();
             (ItemStack.isEmpty(addTransaction.getRemainder())) {
               ;
            }
         }
      }

        <MoveTransaction<ItemStackTransaction>>(!transactions.isEmpty(), transactions);
   }

   
    MoveTransaction<SlotTransaction>  {
       .moveItemStackFromSlotToSlot(slot, quantity, containerTo, slotTo, );
   }

   
    MoveTransaction<SlotTransaction>  {
      MoveTransaction<SlotTransaction> transaction = .internal_moveItemStackFromSlot(slot, quantity, containerTo, slotTo, filter);
      .sendUpdate(transaction);
      containerTo.sendUpdate(transaction.toInverted());
       transaction;
   }

    MoveTransaction<SlotTransaction>  {
      validateSlotIndex(slot, .getCapacity());
      validateSlotIndex(slotTo, containerTo.getCapacity());
      validateQuantity(quantity);
       (MoveTransaction).writeAction(() -> (MoveTransaction)containerTo.writeAction(() -> {
             (filter && .cantRemoveFromSlot(slot)) {
                  .internal_getSlot(slot);
                   (, ActionType.REMOVE, slot, itemStack, itemStack, (ItemStack), , , filter);
                 (, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, SlotTransaction.FAILED_ADD);
            }   (filter && containerTo.cantMoveToSlot(, slot)) {
                  .internal_getSlot(slot);
                   (, ActionType.REMOVE, slot, itemStack, itemStack, (ItemStack), , , filter);
                 (, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, SlotTransaction.FAILED_ADD);
            }  {
                  .internal_removeItemStack(slot, quantity);
                (!fromTransaction.succeeded()) {
                    (, fromTransaction, MoveType.MOVE_FROM_SELF, containerTo, SlotTransaction.FAILED_ADD);
               }  {
                     fromTransaction.getOutput();
                   (ItemStack.isEmpty(itemFrom)) {
                       (, fromTransaction, MoveType.MOVE_FROM_SELF, containerTo, SlotTransaction.FAILED_ADD);
                  }  {
                        containerTo.getItemStack(slotTo);
                      (filter && containerTo.cantAddToSlot(slotTo, itemFrom, itemTo)) {
                        .internal_setSlot(slot, fromTransaction.getSlotBefore());
                            (, ActionType.REMOVE, slot, fromTransaction.getSlotBefore(), fromTransaction.getSlotAfter(), (ItemStack), , , filter);
                            (, ActionType.ADD, slotTo, itemTo, itemTo, (ItemStack), , , filter);
                          (, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, addTransaction);
                     }   (ItemStack.isEmpty(itemTo)) {
                           InternalContainerUtilItemStack.internal_setItemStackForSlot(containerTo, slotTo, itemFrom, filter);
                          (, fromTransaction, MoveType.MOVE_FROM_SELF, containerTo, addTransaction);
                     }   (!itemFrom.isStackableWith(itemTo)) {
                         (ItemStack.isEmpty(fromTransaction.getSlotAfter())) {
                            (filter && .cantAddToSlot(slot, itemTo, itemFrom)) {
                              .internal_setSlot(slot, fromTransaction.getSlotBefore());
                                  (, ActionType.REMOVE, slot, fromTransaction.getSlotBefore(), fromTransaction.getSlotAfter(), (ItemStack), , , filter);
                                  (, ActionType.ADD, slotTo, itemTo, itemTo, (ItemStack), , , filter);
                                (, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, addTransaction);
                           }  {
                              .internal_setSlot(slot, itemTo);
                              containerTo.internal_setSlot(slotTo, itemFrom);
                                  (, ActionType.REPLACE, slot, itemFrom, itemTo, (ItemStack), , , filter);
                                  (, ActionType.REPLACE, slotTo, itemTo, itemFrom, (ItemStack), , , filter);
                                (, from, MoveType.MOVE_FROM_SELF, containerTo, to);
                           }
                        }  {
                           .internal_setSlot(slot, fromTransaction.getSlotBefore());
                               (, ActionType.REMOVE, slot, fromTransaction.getSlotBefore(), fromTransaction.getSlotAfter(), (ItemStack), , , filter);
                               (, ActionType.ADD, slotTo, itemTo, itemTo, (ItemStack), , , filter);
                             (, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, addTransaction);
                        }
                     }  {
                           itemFrom.getItem().getMaxStack();
                           itemFrom.getQuantity() + itemTo.getQuantity();
                         (newQuantity <= maxStack) {
                              InternalContainerUtilItemStack.internal_setItemStackForSlot(containerTo, slotTo, itemTo.withQuantity(newQuantity), filter);
                             (, fromTransaction, MoveType.MOVE_FROM_SELF, containerTo, addTransaction);
                        }  {
                              InternalContainerUtilItemStack.internal_setItemStackForSlot(containerTo, slotTo, itemTo.withQuantity(maxStack), filter);
                              newQuantity - maxStack;
                              !ItemStack.isEmpty(fromTransaction.getSlotAfter()) ? fromTransaction.getSlotAfter().getQuantity() : ;
                           .internal_setSlot(slot, itemFrom.withQuantity(remainder + quantityLeft));
                             (, fromTransaction, MoveType.MOVE_FROM_SELF, containerTo, addTransaction);
                        }
                     }
                  }
               }
            }
         }));
   }

   
    ListTransaction<MoveTransaction<ItemStackTransaction>>  {
       .moveAllItemStacksTo((Predicate), containerTo);
   }

   
    ListTransaction<MoveTransaction<ItemStackTransaction>>  {
      ListTransaction<MoveTransaction<ItemStackTransaction>> transaction = .internal_moveAllItemStacksTo(itemPredicate, containerTo);
      .sendUpdate(transaction);

      (MoveTransaction<ItemStackTransaction> moveItemStackTransaction : transaction.getList()) {
         moveItemStackTransaction.getOtherContainer().sendUpdate(moveItemStackTransaction.toInverted());
      }

       transaction;
   }

   
    ListTransaction<MoveTransaction<ItemStackTransaction>>  {
       (ListTransaction).writeAction(() -> {
         List<MoveTransaction<ItemStackTransaction>> transactions =  <MoveTransaction<ItemStackTransaction>>();

         (   ; i < .getCapacity(); ++i) {
             (!.cantRemoveFromSlot(i)) {
                  .internal_getSlot(i);
                (!ItemStack.isEmpty(checkedItem) && (itemPredicate ==  || itemPredicate.test(checkedItem))) {
                  transactions.addAll(.moveItemStackFromSlot(i, containerTo).getList());
               }
            }
         }

           (, transactions);
      });
   }

   
    ListTransaction<MoveTransaction<ItemStackTransaction>>  {
       .moveAllItemStacksTo((itemStack) -> {
         (ItemContainer itemContainer : containerTo) {
             (itemContainer.containsItemStacksStackableWith(itemStack)) {
                ;
            }
         }

          ;
      }, containerTo);
   }

   
    ListTransaction<MoveTransaction<SlotTransaction>>  {
      ListTransaction<MoveTransaction<SlotTransaction>> transaction = .internal_combineItemStacksIntoSlot(containerTo, slotTo);
      .sendUpdate(transaction);

      (MoveTransaction<SlotTransaction> moveSlotTransaction : transaction.getList()) {
         moveSlotTransaction.getOtherContainer().sendUpdate(moveSlotTransaction.toInverted());
      }

       transaction;
   }

   
    ListTransaction<MoveTransaction<SlotTransaction>>  {
      validateSlotIndex(slotTo, containerTo.getCapacity());
       (ListTransaction).writeAction(() -> {
            containerTo.internal_getSlot(slotTo);
            itemStack.getItem();
            item.getMaxStack();
          (!ItemStack.isEmpty(itemStack) && itemStack.getQuantity() < maxStack) {
               ;
            [] quantities =  [.getCapacity()];
            [] indexes =  [.getCapacity()];

            (   ; i < .getCapacity(); ++i) {
                (!.cantRemoveFromSlot(i)) {
                     .internal_getSlot(i);
                   (itemStack != itemFrom && !ItemStack.isEmpty(itemFrom) && itemFrom.isStackableWith(itemStack)) {
                     indexes[count] = i;
                     quantities[count] = itemFrom.getQuantity();
                     ++count;
                  }
               }
            }

            IntArrays.quickSort(quantities, indexes, , count);
               itemStack.getQuantity();
            List<MoveTransaction<SlotTransaction>> list =  <MoveTransaction<SlotTransaction>>();

            (   ; ai < count && quantity < maxStack; ++ai) {
                  ()indexes[ai];
                  .internal_getSlot(i);
               MoveTransaction<SlotTransaction> transaction = .internal_moveItemStackFromSlot(i, itemFrom.getQuantity(), containerTo, slotTo, );
               list.add(transaction);
               quantity = !ItemStack.isEmpty(((SlotTransaction)transaction.getAddTransaction()).getSlotAfter()) ? ((SlotTransaction)transaction.getAddTransaction()).getSlotAfter().getQuantity() : ;
            }

              (, list);
         }  {
              (, Collections.emptyList());
         }
      });
   }

   
    ListTransaction<MoveTransaction<SlotTransaction>>  {
      ListTransaction<MoveTransaction<SlotTransaction>> transaction = .internal_swapItems(srcPos, containerTo, destPos, length);
      .sendUpdate(transaction);

      (MoveTransaction<SlotTransaction> moveItemStackTransaction : transaction.getList()) {
         moveItemStackTransaction.getOtherContainer().sendUpdate(moveItemStackTransaction.toInverted());
      }

       transaction;
   }

   
    ListTransaction<MoveTransaction<SlotTransaction>>  {
       (srcPos < ) {
           ();
      }   (srcPos + length > .getCapacity()) {
           ();
      }   (destPos < ) {
           ();
      }   (destPos + length > containerTo.getCapacity()) {
           ();
      }  {
          (ListTransaction).writeAction(() -> (ListTransaction)containerTo.writeAction(() -> {
               List<MoveTransaction<SlotTransaction>> list =  <MoveTransaction<SlotTransaction>>(length);

               (   ; slot < length; ++slot) {
                  list.add(.internal_swapItems(containerTo, ()(srcPos + slot), ()(destPos + slot)));
               }

                 (, list);
            }));
      }
   }

   
    MoveTransaction<SlotTransaction>  {
         .internal_removeSlot(slotFrom);
         containerTo.internal_removeSlot(slotTo);
       (itemTo !=  && !itemTo.isEmpty()) {
         .internal_setSlot(slotFrom, itemTo);
      }

       (itemFrom !=  && !itemFrom.isEmpty()) {
         containerTo.internal_setSlot(slotTo, itemFrom);
      }

          (, ActionType.REPLACE, slotFrom, itemFrom, itemTo, (ItemStack), , , );
          (, ActionType.REPLACE, slotTo, itemTo, itemFrom, (ItemStack), , , );
        <SlotTransaction>(, from, MoveType.MOVE_FROM_SELF, containerTo, to);
   }

      {
       .canAddItemStack(itemStack, , );
   }

      {
         itemStack.getItem();
       (item == ) {
           (itemStack.getItemId() + );
      }  {
            item.getMaxStack();
          (Boolean).readAction(() -> {
               itemStack.getQuantity();
             (!fullStacks) {
               testQuantityRemaining = InternalContainerUtilItemStack.testAddToExistingItemStacks(, itemStack, itemMaxStack, testQuantityRemaining, filter);
            }

            testQuantityRemaining = InternalContainerUtilItemStack.testAddToEmptySlots(, itemStack, itemMaxStack, testQuantityRemaining, filter);
             testQuantityRemaining <= ;
         });
      }
   }

   
    ItemStackTransaction  {
       .addItemStack(itemStack, , , );
   }

   
    ItemStackTransaction  {
         InternalContainerUtilItemStack.internal_addItemStack(, itemStack, allOrNothing, fullStacks, filter);
      .sendUpdate(transaction);
       transaction;
   }

      {
       .canAddItemStacks(itemStacks, , );
   }

      {
       (itemStacks !=  && !itemStacks.isEmpty()) {
         List<TempItemData> tempItemDataList =  <TempItemData>(itemStacks.size());

         (ItemStack itemStack : itemStacks) {
               itemStack.getItem();
             (item == ) {
                 (itemStack.getItemId() + );
            }

            tempItemDataList.add( (itemStack, item));
         }

          (Boolean).readAction(() -> {
            (TempItemData tempItemData : tempItemDataList) {
                  tempItemData.item().getMaxStack();
                  tempItemData.itemStack();
                  itemStack.getQuantity();
                (!fullStacks) {
                  testQuantityRemaining = InternalContainerUtilItemStack.testAddToExistingItemStacks(, itemStack, itemMaxStack, testQuantityRemaining, filter);
               }

               testQuantityRemaining = InternalContainerUtilItemStack.testAddToEmptySlots(, itemStack, itemMaxStack, testQuantityRemaining, filter);
                (testQuantityRemaining > ) {
                   ;
               }
            }

             ;
         });
      }  {
          ;
      }
   }

    ListTransaction<ItemStackTransaction>  {
       .addItemStacks(itemStacks, , , );
   }

    ListTransaction<ItemStackTransaction>  {
       (itemStacks !=  && !itemStacks.isEmpty()) {
         ListTransaction<ItemStackTransaction> transaction = InternalContainerUtilItemStack.internal_addItemStacks(, itemStacks, allOrNothing, fullStacks, filter);
         .sendUpdate(transaction);
          transaction;
      }  {
          ListTransaction.<ItemStackTransaction>getEmptyTransaction();
      }
   }

    ListTransaction<ItemStackSlotTransaction>  {
       .addItemStacksOrdered(itemStacks, , );
   }

    ListTransaction<ItemStackSlotTransaction>  {
       .addItemStacksOrdered(offset, itemStacks, , );
   }

    ListTransaction<ItemStackSlotTransaction>  {
       .addItemStacksOrdered((), itemStacks, allOrNothing, filter);
   }

    ListTransaction<ItemStackSlotTransaction>  {
       (itemStacks !=  && !itemStacks.isEmpty()) {
         ListTransaction<ItemStackSlotTransaction> transaction = InternalContainerUtilItemStack.internal_addItemStacksOrdered(, offset, itemStacks, allOrNothing, filter);
         .sendUpdate(transaction);
          transaction;
      }  {
          ListTransaction.<ItemStackSlotTransaction>getEmptyTransaction();
      }
   }

      {
       .canRemoveItemStack(itemStack, , );
   }

      {
       itemStack ==  ?  : (Boolean).readAction(() -> {
            InternalContainerUtilItemStack.testRemoveItemStackFromItems(, itemStack, itemStack.getQuantity(), filter);
          testQuantityRemaining >  ?  : !exactAmount || testQuantityRemaining >= ;
      });
   }

   
    ItemStackTransaction  {
       .removeItemStack(itemStack, , );
   }

   
    ItemStackTransaction  {
         InternalContainerUtilItemStack.internal_removeItemStack(, itemStack, allOrNothing, filter);
      .sendUpdate(transaction);
       transaction;
   }

      {
       .canRemoveItemStacks(itemStacks, , );
   }

      {
       itemStacks !=  && !itemStacks.isEmpty() ? (Boolean).readAction(() -> {
         (ItemStack itemStack : itemStacks) {
               InternalContainerUtilItemStack.testRemoveItemStackFromItems(, itemStack, itemStack.getQuantity(), filter);
             (testQuantityRemaining > ) {
                ;
            }

             (exactAmount && testQuantityRemaining < ) {
                ;
            }
         }

          ;
      }) : ;
   }

    ListTransaction<ItemStackTransaction>  {
       .removeItemStacks(itemStacks, , );
   }

    ListTransaction<ItemStackTransaction>  {
       (itemStacks !=  && !itemStacks.isEmpty()) {
         ListTransaction<ItemStackTransaction> transaction = InternalContainerUtilItemStack.internal_removeItemStacks(, itemStacks, allOrNothing, filter);
         .sendUpdate(transaction);
          transaction;
      }  {
          ListTransaction.<ItemStackTransaction>getEmptyTransaction();
      }
   }

      {
       .canRemoveTag(tagIndex, quantity, , );
   }

      {
       (Boolean).readAction(() -> {
            InternalContainerUtilTag.testRemoveTagFromItems(, tagIndex, quantity, filter);
          testQuantityRemaining >  ?  : !exactAmount || testQuantityRemaining >= ;
      });
   }

   
    TagTransaction  {
       .removeTag(tagIndex, quantity, , , );
   }

   
    TagTransaction  {
         InternalContainerUtilTag.internal_removeTag(, tagIndex, quantity, allOrNothing, exactAmount, filter);
      .sendUpdate(transaction);
       transaction;
   }

      {
       .canRemoveResource(resource, , );
   }

      {
       resource ==  ?  : (Boolean).readAction(() -> {
            InternalContainerUtilResource.testRemoveResourceFromItems(, resource, resource.getQuantity(), filter);
          testQuantityRemaining >  ?  : !exactAmount || testQuantityRemaining >= ;
      });
   }

   
    ResourceTransaction  {
       .removeResource(resource, , , );
   }

   
    ResourceTransaction  {
         InternalContainerUtilResource.internal_removeResource(, resource, allOrNothing, exactAmount, filter);
      .sendUpdate(transaction);
       transaction;
   }

      {
       .canRemoveResources(resources, , );
   }

      {
       resources !=  && !resources.isEmpty() ? (Boolean).readAction(() -> {
         (ResourceQuantity resource : resources) {
               InternalContainerUtilResource.testRemoveResourceFromItems(, resource, resource.getQuantity(), filter);
             (testQuantityRemaining > ) {
                ;
            }

             (exactAmount && testQuantityRemaining < ) {
                ;
            }
         }

          ;
      }) : ;
   }

    ListTransaction<ResourceTransaction>  {
       .removeResources(resources, , , );
   }

    ListTransaction<ResourceTransaction>  {
       (resources !=  && !resources.isEmpty()) {
         ListTransaction<ResourceTransaction> transaction = InternalContainerUtilResource.internal_removeResources(, resources, allOrNothing, exactAmount, filter);
         .sendUpdate(transaction);
          transaction;
      }  {
          ListTransaction.<ResourceTransaction>getEmptyTransaction();
      }
   }

      {
       .canRemoveMaterial(material, , );
   }

      {
       material ==  ?  : (Boolean).readAction(() -> {
            InternalContainerUtilMaterial.testRemoveMaterialFromItems(, material, material.getQuantity(), filter);
          testQuantityRemaining >  ?  : !exactAmount || testQuantityRemaining >= ;
      });
   }

   
    MaterialTransaction  {
       .removeMaterial(material, , , );
   }

   
    MaterialTransaction  {
         InternalContainerUtilMaterial.internal_removeMaterial(, material, allOrNothing, exactAmount, filter);
      .sendUpdate(transaction);
       transaction;
   }

      {
       .canRemoveMaterials(materials, , );
   }

      {
       materials !=  && !materials.isEmpty() ? (Boolean).readAction(() -> {
         (MaterialQuantity material : materials) {
               InternalContainerUtilMaterial.testRemoveMaterialFromItems(, material, material.getQuantity(), filter);
             (testQuantityRemaining > ) {
                ;
            }

             (exactAmount && testQuantityRemaining < ) {
                ;
            }
         }

          ;
      }) : ;
   }

    List<TestRemoveItemSlotResult>  {
      List<TestRemoveItemSlotResult> slotMaterials =  <TestRemoveItemSlotResult>();
       materials !=  && !materials.isEmpty() ? (List).readAction(() -> {
         (MaterialQuantity material : materials) {
               InternalContainerUtilMaterial.getTestRemoveMaterialFromItems(, material, material.getQuantity(), filter);
             (testResult.quantityRemaining > ) {
               slotMaterials.clear();
                slotMaterials;
            }

             (exactAmount && testResult.quantityRemaining < ) {
               slotMaterials.clear();
                slotMaterials;
            }

            slotMaterials.add(testResult);
         }

          slotMaterials;
      }) : slotMaterials;
   }

    ListTransaction<MaterialTransaction>  {
       .removeMaterials(materials, , , );
   }

    ListTransaction<MaterialTransaction>  {
       (materials !=  && !materials.isEmpty()) {
         ListTransaction<MaterialTransaction> transaction = InternalContainerUtilMaterial.internal_removeMaterials(, materials, allOrNothing, exactAmount, filter);
         .sendUpdate(transaction);
          transaction;
      }  {
          ListTransaction.<MaterialTransaction>getEmptyTransaction();
      }
   }

    ListTransaction<MaterialSlotTransaction>  {
       .removeMaterialsOrdered(offset, materials, , , );
   }

    ListTransaction<MaterialSlotTransaction>  {
       .removeMaterialsOrdered((), materials, allOrNothing, exactAmount, filter);
   }

    ListTransaction<MaterialSlotTransaction>  {
       (materials !=  && !materials.isEmpty()) {
          (offset + materials.size() > .getCapacity()) {
             ListTransaction.<MaterialSlotTransaction>getEmptyTransaction();
         }  {
            ListTransaction<MaterialSlotTransaction> transaction = InternalContainerUtilMaterial.internal_removeMaterialsOrdered(, offset, materials, allOrNothing, exactAmount, filter);
            .sendUpdate(transaction);
             transaction;
         }
      }  {
          ListTransaction.<MaterialSlotTransaction>getEmptyTransaction();
      }
   }

      {
       (Boolean).readAction(() -> {
         (   ; i < .getCapacity(); ++i) {
               .internal_getSlot(i);
             (itemStack !=  && !itemStack.isEmpty()) {
                ;
            }
         }

          ;
      });
   }

      {
       (Integer).readAction(() -> {
            ;

         (   ; i < .getCapacity(); ++i) {
               .internal_getSlot(i);
             (!ItemStack.isEmpty(itemStack) && itemPredicate.test(itemStack)) {
               count += itemStack.getQuantity();
            }
         }

          count;
      });
   }

      {
       (Boolean).readAction(() -> {
         (   ; i < .getCapacity(); ++i) {
               .internal_getSlot(i);
             (!ItemStack.isEmpty(checked) && itemStack.isStackableWith(checked)) {
                ;
            }
         }

          ;
      });
   }

      {
      (   ; i < .getCapacity(); ++i) {
            .getItemStack(i);
          (!ItemStack.isEmpty(itemStack)) {
            action.accept(i, itemStack);
         }
      }

   }

    <T>   {
      (   ; i < .getCapacity(); ++i) {
            .getItemStack(i);
          (!ItemStack.isEmpty(itemStack)) {
            consumer.accept(i, itemStack, meta);
         }
      }

   }

   
    List<ItemStack>  {
      List<ItemStack> items =  <ItemStack>();
      ListTransaction<SlotTransaction> transaction = (ListTransaction).writeAction(() -> {
         List<SlotTransaction> transactions =  <SlotTransaction>();

         (   ; i < .getCapacity(); ++i) {
             (!.cantRemoveFromSlot(i)) {
                  .internal_removeSlot(i);
                (!ItemStack.isEmpty(itemStack)) {
                  items.add(itemStack);
                  transactions.add( (, ActionType.REMOVE, i, itemStack, (ItemStack), itemStack, , , ));
               }
            }
         }

           (, transactions);
      });
      .sendUpdate(transaction);
       items;
   }

   
    List<ItemStack>  {
       .dropAllItemStacks();
   }

   
    List<ItemStack>  {
      List<ItemStack> items =  <ItemStack>();
      ListTransaction<SlotTransaction> transaction = (ListTransaction).writeAction(() -> {
         List<SlotTransaction> transactions =  <SlotTransaction>();

         (   ; i < .getCapacity(); ++i) {
             (!filter || !.cantDropFromSlot(i)) {
                  .internal_removeSlot(i);
                (!ItemStack.isEmpty(itemStack)) {
                  items.add(itemStack);
                  transactions.add( (, ActionType.REMOVE, i, itemStack, (ItemStack), itemStack, , , ));
               }
            }
         }

           (, transactions);
      });
      .sendUpdate(transaction);
       items;
   }

   
    ListTransaction<SlotTransaction>  {
      ListTransaction<SlotTransaction> transaction = .internal_sortItems(sort);
      .sendUpdate(transaction);
       transaction;
   }

    ListTransaction<SlotTransaction>  {
       (ListTransaction).writeAction(() -> {
         ItemStack[] stacks =  [.getCapacity()];
            ;

         (   ; i < stacks.length; ++i) {
             (!.cantRemoveFromSlot(i)) {
                  .internal_getSlot(i);
                (slot != ) {
                     slot.getItem();
                     item.getMaxStack();
                     slot.getQuantity();
                   (maxStack > ) {
                     (   ; j < stackOffset && slotQuantity > ; ++j) {
                           stacks[j];
                         (slot.isStackableWith(stack)) {
                              stack.getQuantity();
                            (stackQuantity < maxStack) {
                                 Math.min(slotQuantity, maxStack - stackQuantity);
                              slotQuantity -= adjust;
                              stacks[j] = stack.withQuantity(stackQuantity + adjust);
                           }
                        }
                     }
                  }

                   (slotQuantity > ) {
                     stacks[stackOffset++] = slotQuantity != slot.getQuantity() ? slot.withQuantity(slotQuantity) : slot;
                  }
               }
            }
         }

         Arrays.sort(stacks, sort.getComparator());
         List<SlotTransaction> transactions =  <SlotTransaction>(stacks.length);
         stackOffset = ;

         (   ; i < stacks.length; ++i) {
             (!.cantRemoveFromSlot(i)) {
                  .internal_getSlot(i);
                  stacks[stackOffset];
                (!.cantAddToSlot(i, replacement, existing)) {
                  ++stackOffset;
                   (existing != replacement) {
                     .internal_setSlot(i, replacement);
                     transactions.add( (, ActionType.REMOVE, i, existing, (ItemStack), replacement, , , ));
                  }
               }
            }
         }

         (   stackOffset; i < stacks.length; ++i) {
             (stacks[i] != ) {
                 ();
            }
         }

           (, transactions);
      });
   }

      {
       (transaction.succeeded()) {
             (, transaction);
         .externalChangeEventRegistry.dispatchFor((Object)).dispatch(event);
         .internalChangeEventRegistry.dispatchFor((Object)).dispatch(event);
      }
   }

      {
       itemContainer == ;
   }

      {
      Objects.requireNonNull(blockMigration);
      .writeAction((_blockMigration) -> {
         (   ; i < .getCapacity(); ++i) {
               .internal_getSlot(i);
             (!ItemStack.isEmpty(slot)) {
                  slot.getItemId();
                  (String)_blockMigration.apply(slot.getItemId());
                (!oldItemId.equals(newItemId)) {
                  .internal_setSlot(i,  (newItemId, slot.getQuantity(), slot.getMetadata()));
               }
            }
         }

          ;
      }, blockMigration);
   }

   
     ItemResourceType  {
      ItemResourceType[] resourceTypes = item.getResourceTypes();
       (resourceTypes == ) {
          ;
      }  {
         (ItemResourceType resourceType : resourceTypes) {
             (resourceId.equals(resourceType.id)) {
                resourceType;
            }
         }

          ;
      }
   }

       {
       (quantity < ) {
           ( + quantity + );
      }
   }

       {
       (slot < ) {
           ( + slot + );
      }   (slot >= capacity) {
           ( + slot +  + capacity);
      }
   }

   
     <T  > T  {
      from.forEach((slot, itemStack) -> {
          (slot >= to.getCapacity()) {
             (remainder != ) {
               remainder.add(itemStack);
            }

         }   (!ItemStack.isEmpty(itemStack)) {
            to.setItemStackForSlot(slot, itemStack);
         }
      });
       to;
   }

     <T  > T  {
       (inputContainer == ) {
          newContainerSupplier.apply(capacity);
      }  {
          (T)(inputContainer.getCapacity() == capacity ? inputContainer : copy(inputContainer, newContainerSupplier.apply(capacity), remainder));
      }
   }

     ItemContainer  {
       (ItemContainer)(capacity >  ? (ItemContainer)supplier.apply(capacity) : EmptyItemContainer.INSTANCE);
   }

       {
   }

        <Void> {
      
       String  {
            String.valueOf(.container);
           + var10000 +  + String.valueOf(.transaction) + ;
      }
   }
}

com/hypixel/hytale/server/core/inventory/container/ItemContainerUtil.java

package com.hypixel.hytale.server.core.inventory.container;

import com.hypixel.hytale.protocol.ItemArmorSlot;
import com.hypixel.hytale.server.core.inventory.container.filter.ArmorSlotAddFilter;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterActionType;
import com.hypixel.hytale.server.core.inventory.container.filter.NoDuplicateFilter;
import com.hypixel.hytale.server.core.inventory.container.filter.SlotFilter;

public class ItemContainerUtil {
   public ItemContainerUtil() {
   }

   public static <T extends ItemContainer> T trySetArmorFilters(T container) {
      if (container instanceof SimpleItemContainer itemContainer) {
         ItemArmorSlot[] itemArmorSlots = ItemArmorSlot.VALUES;

         for(short i = 0; i < itemContainer.getCapacity(); ++i) {
            if (i < itemArmorSlots.length) {
               if (i < 5) {
                  itemContainer.setSlotFilter(FilterActionType.ADD, i, new ArmorSlotAddFilter(itemArmorSlots[i]));
               } else {
                  itemContainer.setSlotFilter(FilterActionType.ADD, i, new NoDuplicateFilter(itemContainer));
               }
            } else {
               itemContainer.setSlotFilter(FilterActionType.ADD, i, SlotFilter.DENY);
            }
         }
      }

      return container;
   }

     <T  > T  {
       (container  SimpleItemContainer itemContainer) {
         (   ; i < itemContainer.getCapacity(); ++i) {
            itemContainer.setSlotFilter(FilterActionType.ADD, i, filter);
         }
      }

       container;
   }
}

com/hypixel/hytale/server/core/inventory/container/ItemStackItemContainer.java

package com.hypixel.hytale.server.core.inventory.container;

import com.hypixel.fastutil.ints.Int2ObjectConcurrentHashMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.EmptyExtraInfo;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemStackContainerConfig;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterActionType;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterType;
import com.hypixel.hytale.server.core.inventory.container.filter.SlotFilter;
import com.hypixel.hytale.server.core.inventory.container.filter.TagFilter;
import com.hypixel.hytale.server.core.inventory.transaction.ClearTransaction;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.function.Function;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;

public class ItemStackItemContainer extends ItemContainer {
   @Nonnull
   public static KeyedCodec<BsonDocument> CONTAINER_CODEC;
   @Nonnull
   public static KeyedCodec<Short> CAPACITY_CODEC;
   
     KeyedCodec<ItemStack[]> ITEMS_CODEC;
         ();
     ItemContainer parentContainer;
      itemStackSlot;
     ItemStack originalItemStack;
      capacity;
    ItemStack[] items;
     Map<FilterActionType, Int2ObjectConcurrentHashMap<SlotFilter>> slotFilters =  ();
   
    FilterType globalFilter;

     {
      .globalFilter = FilterType.ALLOW_ALL;
      .parentContainer = parentContainer;
      .itemStackSlot = itemStackSlot;
      .originalItemStack = originalItemStack;
      .capacity = capacity;
      .items = items;
   }

    ItemContainer  {
       .parentContainer;
   }

      {
       .itemStackSlot;
   }

    ItemStack  {
       .originalItemStack;
   }

      {
         .parentContainer.getItemStack(.itemStackSlot);
       ItemStack.isEmpty(itemStack) ?  : ItemStack.isSameItemType(itemStack, .originalItemStack);
   }

      {
       .capacity;
   }

      {
      .globalFilter = globalFilter;
   }

      {
      validateSlotIndex(slot, .getCapacity());
       (filter != ) {
         ((Int2ObjectConcurrentHashMap).slotFilters.computeIfAbsent(actionType, (k) ->  ())).put(slot, filter);
      }  {
         .slotFilters.computeIfPresent(actionType, (k, map) -> {
            map.remove(slot);
             map.isEmpty() ?  : map;
         });
      }

   }

    ItemContainer  {
        ();
   }

    <V> V  {
      .lock.readLock().lock();

      Object var2;
       {
         var2 = action.get();
      }  {
         .lock.readLock().unlock();
      }

       (V)var2;
   }

    <X, V> V  {
      .lock.readLock().lock();

      Object var3;
       {
         var3 = action.apply(x);
      }  {
         .lock.readLock().unlock();
      }

       (V)var3;
   }

    <V> V  {
      .lock.writeLock().lock();

      Object var2;
       {
         var2 = action.get();
      }  {
         .lock.writeLock().unlock();
      }

       (V)var2;
   }

    <X, V> V  {
      .lock.writeLock().lock();

      Object var3;
       {
         var3 = action.apply(x);
      }  {
         .lock.writeLock().unlock();
      }

       (V)var3;
   }

      {
      .lock.readLock().lock();

       i;
       {
          (.items != ) {
            (   ; i < .items.length; ++i) {
                (!ItemStack.isEmpty(.items[i])) {
                     ;
                   var2;
               }
            }

            i = ;
             i;
         }

         i = ;
      }  {
         .lock.readLock().unlock();
      }

       i;
   }

   
    ClearTransaction  {
       (.items == ) {
           (, (), ItemStack.EMPTY_ARRAY);
      }  {
         ItemStack[] oldItems = .items;
         .items =  [oldItems.length];
         writeToItemStack(.parentContainer, .itemStackSlot, .originalItemStack, .items);
           (, (), oldItems);
      }
   }

   
    ItemStack  {
       .items !=  ? .items[slot] : ;
   }

   
    ItemStack  {
       (.items == ) {
          ;
      }   (ItemStack.isEmpty(itemStack)) {
          .internal_removeSlot(slot);
      }  {
            .items[slot];
         .items[slot] = itemStack;
         writeToItemStack(.parentContainer, .itemStackSlot, .originalItemStack, .items);
          old;
      }
   }

   
    ItemStack  {
       (.items == ) {
          ;
      }  {
            .items[slot];
         .items[slot] = ;
         writeToItemStack(.parentContainer, .itemStackSlot, .originalItemStack, .items);
          old;
      }
   }

      {
       !.globalFilter.allowInput() ?  : .testFilter(FilterActionType.ADD, slot, itemStack);
   }

      {
       !.globalFilter.allowOutput() ?  : .testFilter(FilterActionType.REMOVE, slot, (ItemStack));
   }

      {
       .testFilter(FilterActionType.DROP, slot, (ItemStack));
   }

      {
       fromContainer == .parentContainer && slotFrom == .itemStackSlot;
   }

      {
      Int2ObjectConcurrentHashMap<SlotFilter> map = (Int2ObjectConcurrentHashMap).slotFilters.get(actionType);
       (map == ) {
          ;
      }  {
            map.get(slot);
          (filter == ) {
             ;
         }  {
             !filter.test(actionType, , slot, itemStack);
         }
      }
   }

   
    ItemStack  {
      validateSlotIndex(slot, .getCapacity());
      .lock.readLock().lock();

      ItemStack var2;
       {
         var2 = .internal_getSlot(slot);
      }  {
         .lock.readLock().unlock();
      }

       var2;
   }

       {
       (ItemStack.isEmpty(originalItemStack)) {
           ();
      }  {
            itemContainer.getItemStack(slot);
          (!ItemStack.isSameItemType(itemStack, originalItemStack)) {
              ();
         }  {
               itemStack.getMetadata();
               CONTAINER_CODEC.getOrNull(newMetadata, EmptyExtraInfo.EMPTY);
             (containerDocument == ) {
                 ();
            }  {
               ITEMS_CODEC.put(containerDocument, items, EmptyExtraInfo.EMPTY);
               itemContainer.setItemStackForSlot(slot, itemStack.withMetadata(newMetadata));
            }
         }
      }
   }

   
     ItemStackItemContainer  {
         itemContainer.getItemStack(slot);
       (ItemStack.isEmpty(itemStack)) {
          ;
      }  {
            (BsonDocument)itemStack.getFromMetadataOrNull(CONTAINER_CODEC);
          (containerDocument == ) {
             ;
         }  {
               CAPACITY_CODEC.getOrNull(containerDocument, EmptyExtraInfo.EMPTY);
             (capacity !=  && capacity > ) {
               ItemStack[] items = ITEMS_CODEC.getOrNull(containerDocument, EmptyExtraInfo.EMPTY);
                (items == ) {
                  items =  [capacity];
               }

                 (itemContainer, slot, itemStack, capacity, items);
            }  {
                ;
            }
         }
      }
   }

   
     ItemStackItemContainer  {
       (capacity <= ) {
           ();
      }  {
            itemContainer.getItemStack(slot);
          (ItemStack.isEmpty(itemStack)) {
              ();
         }  {
               getContainer(itemContainer, slot);
             (itemStackItemContainer !=  && itemStackItemContainer.getCapacity() != ) {
                 ();
            }  {
                  itemStack.getMetadata();
                (newMetadata == ) {
                  newMetadata =  ();
               }

                  CONTAINER_CODEC.getOrNull(newMetadata, EmptyExtraInfo.EMPTY);
                (containerDocument == ) {
                  containerDocument =  ();
                  CONTAINER_CODEC.put(newMetadata, containerDocument, EmptyExtraInfo.EMPTY);
               }

               CAPACITY_CODEC.put(containerDocument, capacity, EmptyExtraInfo.EMPTY);
               itemContainer.setItemStackForSlot(slot, itemStack.withMetadata(newMetadata));
                 (itemContainer, slot, itemStack, capacity,  [capacity]);
            }
         }
      }
   }

   
     ItemStackItemContainer  {
       (capacity <= ) {
           ();
      }  {
            itemContainer.getItemStack(slot);
          (ItemStack.isEmpty(itemStack)) {
             ;
         }  {
               getContainer(itemContainer, slot);
             (itemStackItemContainer !=  && itemStackItemContainer.getCapacity() != ) {
                itemStackItemContainer;
            }  {
                  itemStack.getMetadata();
                (newMetadata == ) {
                  newMetadata =  ();
               }

                  CONTAINER_CODEC.getOrNull(newMetadata, EmptyExtraInfo.EMPTY);
                (containerDocument == ) {
                  containerDocument =  ();
                  CONTAINER_CODEC.put(newMetadata, containerDocument, EmptyExtraInfo.EMPTY);
               }

               CAPACITY_CODEC.put(containerDocument, capacity, EmptyExtraInfo.EMPTY);
               itemContainer.setItemStackForSlot(slot, itemStack.withMetadata(newMetadata));
                 (itemContainer, slot, itemStack, capacity,  [capacity]);
            }
         }
      }
   }

   
     ItemStackItemContainer  {
         ensureContainer(itemContainer, slot, config.getCapacity());
       (itemStackItemContainer == ) {
          ;
      }  {
         itemStackItemContainer.setGlobalFilter(config.getGlobalFilter());
            config.getTagIndex();
          (tagIndex != -) {
            (   ; i < itemStackItemContainer.getCapacity(); ++i) {
               itemStackItemContainer.setSlotFilter(FilterActionType.ADD, i,  (tagIndex));
            }
         }

          itemStackItemContainer;
      }
   }

    {
      CONTAINER_CODEC =  <BsonDocument>(, Codec.BSON_DOCUMENT);
      CAPACITY_CODEC =  <Short>(, Codec.SHORT);
      ITEMS_CODEC =  <ItemStack[]>(,  (ItemStack.CODEC, (x$) ->  [x$]));
   }
}

com/hypixel/hytale/server/core/inventory/container/SimpleItemContainer.java

package com.hypixel.hytale.server.core.inventory.container;

import com.hypixel.fastutil.ints.Int2ObjectConcurrentHashMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.map.Short2ObjectMapCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.component.ComponentAccessor;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.server.core.entity.ItemUtils;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterActionType;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterType;
import com.hypixel.hytale.server.core.inventory.container.filter.SlotFilter;
import com.hypixel.hytale.server.core.inventory.transaction.ClearTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ItemStackSlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ItemStackTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ListTransaction;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import it.unimi.dsi.fastutil.shorts.Short2ObjectMap;
import it.unimi.dsi.fastutil.shorts.Short2ObjectOpenHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.function.Function;
 java.util.function.Supplier;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;

     {
      BuilderCodec<SimpleItemContainer> CODEC;
     capacity;
         ();
    Short2ObjectMap<ItemStack> items;
     Map<FilterActionType, Int2ObjectConcurrentHashMap<SlotFilter>> slotFilters =  ();
    FilterType globalFilter;

     {
      .globalFilter = FilterType.ALLOW_ALL;
   }

     {
      .globalFilter = FilterType.ALLOW_ALL;
       (capacity <= ) {
           ( + capacity + );
      }  {
         .capacity = capacity;
         .items =  <ItemStack>(capacity);
      }
   }

     {
      .globalFilter = FilterType.ALLOW_ALL;
      .capacity = other.capacity;
      other.lock.readLock().lock();

       {
         .items =  <ItemStack>(other.items);
      }  {
         other.lock.readLock().unlock();
      }

      .slotFilters.putAll(other.slotFilters);
      .globalFilter = other.globalFilter;
   }

    <V> V  {
      .lock.readLock().lock();

      Object var2;
       {
         var2 = action.get();
      }  {
         .lock.readLock().unlock();
      }

       (V)var2;
   }

    <X, V> V  {
      .lock.readLock().lock();

      Object var3;
       {
         var3 = action.apply(x);
      }  {
         .lock.readLock().unlock();
      }

       (V)var3;
   }

    <V> V  {
      .lock.writeLock().lock();

      Object var2;
       {
         var2 = action.get();
      }  {
         .lock.writeLock().unlock();
      }

       (V)var2;
   }

    <X, V> V  {
      .lock.writeLock().lock();

      Object var3;
       {
         var3 = action.apply(x);
      }  {
         .lock.writeLock().unlock();
      }

       (V)var3;
   }

    ItemStack  {
       (ItemStack).items.get(slot);
   }

    ItemStack  {
       ItemStack.isEmpty(itemStack) ? .internal_removeSlot(slot) : (ItemStack).items.put(slot, itemStack);
   }

    ItemStack  {
       (ItemStack).items.remove(slot);
   }

      {
       !.globalFilter.allowInput() ?  : .testFilter(FilterActionType.ADD, slot, itemStack);
   }

      {
       !.globalFilter.allowOutput() ?  : .testFilter(FilterActionType.REMOVE, slot, (ItemStack));
   }

      {
       .testFilter(FilterActionType.DROP, slot, (ItemStack));
   }

      {
       ;
   }

      {
      Int2ObjectConcurrentHashMap<SlotFilter> map = (Int2ObjectConcurrentHashMap).slotFilters.get(actionType);
       (map == ) {
          ;
      }  {
            map.get(slot);
          (filter == ) {
             ;
         }  {
             !filter.test(actionType, , slot, itemStack);
         }
      }
   }

      {
       .capacity;
   }

   
    ClearTransaction  {
      ItemStack[] itemStacks =  [.getCapacity()];

      (   ; i < itemStacks.length; ++i) {
         itemStacks[i] = (ItemStack).items.get(i);
      }

      .items.clear();
        (, (), itemStacks);
   }

   
    SimpleItemContainer  {
        ();
   }

      {
      .lock.readLock().lock();

       var1;
       {
          (!.items.isEmpty()) {
             .isEmpty();
         }

         var1 = ;
      }  {
         .lock.readLock().unlock();
      }

       var1;
   }

      {
      .globalFilter = (FilterType)Objects.requireNonNull(globalFilter);
   }

      {
      validateSlotIndex(slot, .getCapacity());
       (filter != ) {
         ((Int2ObjectConcurrentHashMap).slotFilters.computeIfAbsent(actionType, (k) ->  ())).put(slot, filter);
      }  {
         .slotFilters.computeIfPresent(actionType, (k, map) -> {
            map.remove(slot);
             map.isEmpty() ?  : map;
         });
      }

   }

   
    ItemStack  {
      validateSlotIndex(slot, .getCapacity());
      .lock.readLock().lock();

      ItemStack var2;
       {
         var2 = .internal_getSlot(slot);
      }  {
         .lock.readLock().unlock();
      }

       var2;
   }

      {
       ( == o) {
          ;
      }   (o  SimpleItemContainer) {
            (SimpleItemContainer)o;
          (.capacity != that.capacity) {
             ;
         }  {
            .lock.readLock().lock();

             var3;
             {
               var3 = .items.equals(that.items);
            }  {
               .lock.readLock().unlock();
            }

             var3;
         }
      }  {
          ;
      }
   }

      {
      .lock.readLock().lock();

       result;
       {
         result = .items.hashCode();
      }  {
         .lock.readLock().unlock();
      }

      result =  * result + .capacity;
       result;
   }

     ItemContainer  {
       ItemContainer.getNewContainer(capacity, SimpleItemContainer::);
   }

       {
         itemContainer.addItemStack(itemStack);
         transaction.getRemainder();
       (!ItemStack.isEmpty(remainder)) {
         ItemUtils.dropItem(ref, remainder, store);
          ;
      }  {
          ;
      }
   }

       {
         itemContainer.addItemStackToSlot(slot, itemStack);
         transaction.getRemainder();
       !ItemStack.isEmpty(remainder) ? addOrDropItemStack(store, ref, itemContainer, itemStack) : ;
   }

       {
      ListTransaction<ItemStackTransaction> transaction = itemContainer.addItemStacks(itemStacks);
         ;

      (ItemStackTransaction stackTransaction : transaction.getList()) {
            stackTransaction.getRemainder();
          (!ItemStack.isEmpty(remainder)) {
            ItemUtils.dropItem(ref, remainder, store);
            droppedItem = ;
         }
      }

       droppedItem;
   }

       {
      ListTransaction<ItemStackSlotTransaction> transaction = itemContainer.addItemStacksOrdered(itemStacks);
      List<ItemStack> remainderItemStacks = ;

      (ItemStackSlotTransaction stackTransaction : transaction.getList()) {
            stackTransaction.getRemainder();
          (!ItemStack.isEmpty(remainder)) {
             (remainderItemStacks == ) {
               remainderItemStacks =  <ItemStack>();
            }

            remainderItemStacks.add(remainder);
         }
      }

       addOrDropItemStacks(store, ref, itemContainer, remainderItemStacks);
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(SimpleItemContainer.class, SimpleItemContainer::).append( (, Codec.SHORT), (o, i) -> o.capacity = i, (o) -> o.capacity).addValidator(Validators.greaterThanOrEqual(Short.valueOf(()))).add()).append( (,  (ItemStack.CODEC, Short2ObjectOpenHashMap::, )), (o, i) -> o.items = i, (o) -> o.items).add()).afterDecode((i) -> {
          (i.items == ) {
            i.items =  <ItemStack>(i.capacity);
         }

         i.items.short2ObjectEntrySet().removeIf((e) -> e.getShortKey() <  || e.getShortKey() >= i.capacity || ItemStack.isEmpty((ItemStack)e.getValue()));
      })).build();
   }
}

com/hypixel/hytale/server/core/inventory/container/SlotReplacementFunction.java

package com.hypixel.hytale.server.core.inventory.container;

import com.hypixel.hytale.server.core.inventory.ItemStack;

public interface SlotReplacementFunction {
   ItemStack replace(short var1, ItemStack var2);
}

com/hypixel/hytale/server/core/inventory/container/SortType.java

package com.hypixel.hytale.server.core.inventory.container;

import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemQuality;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import java.util.Comparator;
import java.util.function.Function;
import javax.annotation.Nonnull;

public enum SortType {
   NAME((i) -> i.getItem().getTranslationKey(), false, false),
   TYPE((i) -> SortType.Dummy.ItemType.getType(i.getItem()), false, true),
   RARITY((i) -> {
      int qualityIndex = i.getItem().getQualityIndex();
      ItemQuality itemQuality = (ItemQuality)ItemQuality.getAssetMap().getAsset(qualityIndex);
      int itemQualityValue = (itemQuality != null ? itemQuality : ItemQuality.DEFAULT_ITEM_QUALITY).getQualityValue();
      return itemQualityValue;
   }, true, true);

   @Nonnull
   public static SortType[] VALUES = values();
   @Nonnull
   private final Comparator<ItemStack> comparator;

   private <U extends Comparable<U>> SortType(@Nonnull final Function<ItemStack, U> key, final boolean inverted,   thenName) {
      Comparator<ItemStack> comp = comparatorFor(key);
       (inverted) {
         comp = comp.reversed();
      }

       (thenName) {
         comp = comp.thenComparing(comparatorFor((i) -> i.getItem().getTranslationKey()));
      }

      .comparator = Comparator.nullsLast(comp);
   }

   
    Comparator<ItemStack>  {
       .comparator;
   }

   
    com.hypixel.hytale.protocol.SortType  {
      com.hypixel.hytale.protocol.SortType var10000;
       (.ordinal()) {
           -> var10000 = com.hypixel.hytale.protocol.SortType.Name;
           -> var10000 = com.hypixel.hytale.protocol.SortType.Type;
           -> var10000 = com.hypixel.hytale.protocol.SortType.Rarity;
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
     SortType  {
      SortType var10000;
       (sortType_) {
          Type -> var10000 = TYPE;
          Rarity -> var10000 = RARITY;
          Name -> var10000 = NAME;
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
     <U  <U>> Comparator<ItemStack>  {
       (a, b) -> {
            (U)((Comparable)key.apply(a));
            (U)((Comparable)key.apply(b));
          (akey == bkey) {
             ;
         }   (akey == ) {
             ;
         }  {
             bkey ==  ? - : akey.compareTo(bkey);
         }
      };
   }

      {
      Dummy() {
      }

         {
         WEAPON,
         ARMOR,
         TOOL,
         ITEM,
         SPECIAL;

           {
         }

         
           ItemType  {
             (item.getWeapon() != ) {
                WEAPON;
            }   (item.getArmor() != ) {
                ARMOR;
            }   (item.getTool() != ) {
                TOOL;
            }  {
                item.getBuilderToolData() !=  ? SPECIAL : ITEM;
            }
         }
      }
   }
}

com/hypixel/hytale/server/core/inventory/container/TestRemoveItemSlotResult.java

package com.hypixel.hytale.server.core.inventory.container;

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
import java.util.Map;
import java.util.Set;

public class TestRemoveItemSlotResult {
   Map<Short, Integer> picked = new Object2IntOpenHashMap();
   int quantityRemaining;

   public TestRemoveItemSlotResult(int testQuantityRemaining) {
      this.quantityRemaining = testQuantityRemaining;
   }

   public boolean hasResult() {
      return !this.picked.isEmpty();
   }

   public Set<Short> getPickedSlots() {
      return this.picked.keySet();
   }
}

com/hypixel/hytale/server/core/inventory/container/filter/ArmorSlotAddFilter.java

package com.hypixel.hytale.server.core.inventory.container.filter;

import com.hypixel.hytale.protocol.ItemArmorSlot;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import javax.annotation.Nullable;

public class ArmorSlotAddFilter implements ItemSlotFilter {
   private final ItemArmorSlot itemArmorSlot;

   public ArmorSlotAddFilter(ItemArmorSlot itemArmorSlot) {
      this.itemArmorSlot = itemArmorSlot;
   }

   public boolean test(@Nullable Item item) {
      return item == null || item.getArmor() != null && item.getArmor().getArmorSlot() == this.itemArmorSlot;
   }

   public ItemArmorSlot getItemArmorSlot() {
      return this.itemArmorSlot;
   }
}

com/hypixel/hytale/server/core/inventory/container/filter/FilterActionType.java

package com.hypixel.hytale.server.core.inventory.container.filter;

public enum FilterActionType {
   ADD,
   REMOVE,
   DROP;

   private FilterActionType() {
   }
}

com/hypixel/hytale/server/core/inventory/container/filter/FilterType.java

package com.hypixel.hytale.server.core.inventory.container.filter;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.codecs.EnumCodec;

public enum FilterType {
   ALLOW_INPUT_ONLY(true, false),
   ALLOW_OUTPUT_ONLY(false, true),
   ALLOW_ALL(true, true),
   DENY_ALL(false, false);

   public static final Codec<FilterType> CODEC = new EnumCodec<FilterType>(FilterType.class);
   private final boolean input;
   private final boolean output;

   private FilterType(boolean input, boolean output) {
      this.input = input;
      this.output = output;
   }

   public boolean allowInput() {
      return this.input;
   }

   public boolean allowOutput() {
      return this.output;
   }
}

com/hypixel/hytale/server/core/inventory/container/filter/ItemSlotFilter.java

package com.hypixel.hytale.server.core.inventory.container.filter;

import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public interface ItemSlotFilter extends SlotFilter {
   default boolean test(@Nonnull FilterActionType actionType, @Nonnull ItemContainer container, short slot, @Nullable ItemStack itemStack) {
      boolean var10000;
      switch (actionType) {
         case ADD:
            var10000 = this.test(itemStack != null ? itemStack.getItem() : null);
            break;
         case REMOVE:
         case DROP:
            itemStack = container.getItemStack(slot);
            var10000 = this.test(itemStack != null ? itemStack.getItem() : null);
            break;
         default:
            throw new MatchException((String)null, (Throwable)null);
      }

      return var10000;
   }

   boolean test;
}

com/hypixel/hytale/server/core/inventory/container/filter/NoDuplicateFilter.java

package com.hypixel.hytale.server.core.inventory.container.filter;

import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.SimpleItemContainer;
import javax.annotation.Nullable;

public class NoDuplicateFilter implements ItemSlotFilter {
   private final SimpleItemContainer container;

   public NoDuplicateFilter(SimpleItemContainer container) {
      this.container = container;
   }

   public boolean test(@Nullable Item item) {
      if (item != null && item.getId() != null) {
         for(short i = 0; i < this.container.getCapacity(); ++i) {
            ItemStack itemStack = this.container.getItemStack(i);
            if (itemStack != null && itemStack.getItemId().equals(item.getId())) {
               return false;
            }
         }

         return true;
      } else {
         return false;
      }
   }
}

com/hypixel/hytale/server/core/inventory/container/filter/ResourceFilter.java

package com.hypixel.hytale.server.core.inventory.container.filter;

import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.inventory.ResourceQuantity;
import javax.annotation.Nullable;

public class ResourceFilter implements ItemSlotFilter {
   private final ResourceQuantity resource;

   public ResourceFilter(ResourceQuantity resource) {
      this.resource = resource;
   }

   public boolean test(@Nullable Item item) {
      return item == null || this.resource.getResourceType(item) != null;
   }

   public ResourceQuantity getResource() {
      return this.resource;
   }
}

com/hypixel/hytale/server/core/inventory/container/filter/SlotFilter.java

package com.hypixel.hytale.server.core.inventory.container.filter;

import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nullable;

public interface SlotFilter {
   SlotFilter ALLOW = (actionType, container, slot, itemStack) -> true;
   SlotFilter DENY = (actionType, container, slot, itemStack) -> false;

   boolean test(FilterActionType var1, ItemContainer var2, short var3, @Nullable ItemStack var4);
}

com/hypixel/hytale/server/core/inventory/container/filter/TagFilter.java

package com.hypixel.hytale.server.core.inventory.container.filter;

import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import javax.annotation.Nullable;

public class TagFilter implements ItemSlotFilter {
   private final int tagIndex;

   public TagFilter(int tagIndex) {
      this.tagIndex = tagIndex;
   }

   public boolean test(@Nullable Item item) {
      return item == null || item.getData().getExpandedTagIndexes().contains(this.tagIndex);
   }
}

com/hypixel/hytale/server/core/inventory/transaction/ActionType.java

package com.hypixel.hytale.server.core.inventory.transaction;

public enum ActionType {
   SET(true, false, true),
   ADD(true, false, false),
   REMOVE(false, true, false),
   REPLACE(true, true, false);

   private final boolean add;
   private final boolean remove;
   private final boolean destroy;

   private ActionType(boolean add, boolean remove, boolean destroy) {
      this.add = add;
      this.remove = remove;
      this.destroy = destroy;
   }

   public boolean isAdd() {
      return this.add;
   }

   public boolean isRemove() {
      return this.remove;
   }

   public boolean isDestroy() {
       .destroy;
   }
}

com/hypixel/hytale/server/core/inventory/transaction/ClearTransaction.java

package com.hypixel.hytale.server.core.inventory.transaction;

import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import java.util.Arrays;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ClearTransaction implements Transaction {
   public static final ClearTransaction EMPTY;
   private final boolean succeeded;
   private final short start;
   @Nonnull
   private final ItemStack[] items;

   public ClearTransaction(boolean succeeded, short start, @Nonnull ItemStack[] items) {
      this.succeeded = succeeded;
      this.start = start;
      this.items = items;
   }

   public boolean succeeded() {
      return this.succeeded;
   }

   public boolean wasSlotModified(short slot) {
      if (!this.succeeded) {
          ;
      }  {
         slot = ()(slot - .start);
          slot >=  && slot < .items.length && .items[slot] !=  && !.items[slot].isEmpty();
      }
   }

   
    ItemStack[] getItems() {
       .items;
   }

   
    ClearTransaction  {
         ()(start + .start);
        (.succeeded, newStart, .items);
   }

   
    ClearTransaction  {
         ()(.start - start);
         container.getCapacity();
       (newStart < ) {
            -newStart;
          .items.length + newStart > capacity ?  (.succeeded, (), (ItemStack[])Arrays.copyOfRange(.items, from, from + capacity)) :  (.succeeded, (), (ItemStack[])Arrays.copyOfRange(.items, from, .items.length));
      }  {
          .items.length > capacity ?  (.succeeded, newStart, (ItemStack[])Arrays.copyOf(.items, capacity)) :  (.succeeded, newStart, .items);
      }
   }

   
    String  {
        + Arrays.toString(.items) + ;
   }

    {
      EMPTY =  (, (), ItemStack.EMPTY_ARRAY);
   }
}

com/hypixel/hytale/server/core/inventory/transaction/ItemStackSlotTransaction.java

package com.hypixel.hytale.server.core.inventory.transaction;

import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ItemStackSlotTransaction extends SlotTransaction {
   private final boolean addToExistingSlot;
   @Nullable
   private final ItemStack query;
   @Nullable
   private final ItemStack remainder;

   public ItemStackSlotTransaction(boolean succeeded, @Nonnull ActionType action, short slot, @Nullable ItemStack slotBefore, @Nullable ItemStack slotAfter, @Nullable ItemStack output, boolean allOrNothing, boolean exactAmount, boolean filter, boolean addToExistingSlot, @Nullable ItemStack query, @Nullable ItemStack remainder) {
      super(succeeded, action, slot, slotBefore, slotAfter, output, allOrNothing, exactAmount, filter);
      this.addToExistingSlot = addToExistingSlot;
      this.query = query;
      this.remainder = remainder;
   }

   public boolean isAddToExistingSlot {
       .addToExistingSlot;
   }

   
    ItemStack  {
       .query;
   }

   
    ItemStack  {
       .remainder;
   }

   
    ItemStackSlotTransaction  {
         ()(start + .getSlot());
        (.succeeded(), .getAction(), newSlot, .getSlotBefore(), .getSlotAfter(), .getOutput(), .isAllOrNothing(), .isExactAmount(), .isFilter(), .addToExistingSlot, .query, .remainder);
   }

   
    ItemStackSlotTransaction  {
         ()(.getSlot() - start);
       newSlot >=  && newSlot < container.getCapacity() ?  (.succeeded(), .getAction(), newSlot, .getSlotBefore(), .getSlotAfter(), .getOutput(), .isAllOrNothing(), .isExactAmount(), .isFilter(), .addToExistingSlot, .query, .remainder) : ;
   }

   
    String  {
         .addToExistingSlot;
        + var10000 +  + String.valueOf(.query) +  + String.valueOf(.remainder) +  + .toString();
   }
}

com/hypixel/hytale/server/core/inventory/transaction/ItemStackTransaction.java

package com.hypixel.hytale.server.core.inventory.transaction;

import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ItemStackTransaction implements Transaction {
   public static final ItemStackTransaction FAILED_ADD;
   private final boolean succeeded;
   @Nullable
   private final ActionType action;
   @Nullable
   private final ItemStack query;
   @Nullable
   private final ItemStack remainder;
   private final boolean allOrNothing;
   private final boolean filter;
   @Nonnull
   private final List<ItemStackSlotTransaction> slotTransactions;

   public ItemStackTransaction(boolean succeeded, @Nullable ActionType action, @Nullable ItemStack query,  ItemStack remainder,  allOrNothing,  filter,  List<ItemStackSlotTransaction> slotTransactions) {
      .succeeded = succeeded;
      .action = action;
      .query = query;
      .remainder = remainder;
      .allOrNothing = allOrNothing;
      .filter = filter;
      .slotTransactions = slotTransactions;
   }

      {
       .succeeded;
   }

      {
       (!.succeeded) {
          ;
      }  {
         (ItemStackSlotTransaction t : .slotTransactions) {
             (t.succeeded() && t.wasSlotModified(slot)) {
                ;
            }
         }

          ;
      }
   }

   
    ActionType  {
       .action;
   }

   
    ItemStack  {
       .query;
   }

   
    ItemStack  {
       .remainder;
   }

      {
       .allOrNothing;
   }

      {
       .filter;
   }

   
    List<ItemStackSlotTransaction>  {
       .slotTransactions;
   }

   
    ItemStackTransaction  {
      List<ItemStackSlotTransaction> slotTransactions = (List).slotTransactions.stream().map((transaction) -> transaction.toParent(parent, start, container)).collect(Collectors.toList());
        (.succeeded, .action, .query, .remainder, .allOrNothing, .filter, slotTransactions);
   }

   
    ItemStackTransaction  {
      List<ItemStackSlotTransaction> slotTransactions = (List).slotTransactions.stream().map((transactionx) -> transactionx.fromParent(parent, start, container)).filter(Objects::nonNull).collect(Collectors.toList());
       (slotTransactions.isEmpty()) {
          ;
      }  {
            ;

         (ItemStackSlotTransaction transaction : slotTransactions) {
             (transaction.succeeded()) {
               succeeded = ;
               ;
            }
         }

           (succeeded, .action, .query, .remainder, .allOrNothing, .filter, slotTransactions);
      }
   }

   
    String  {
         .succeeded;
        + var10000 +  + String.valueOf(.action) +  + String.valueOf(.query) +  + String.valueOf(.remainder) +  + .allOrNothing +  + .filter +  + String.valueOf(.slotTransactions) + ;
   }

    {
      FAILED_ADD =  (, ActionType.ADD, (ItemStack), (ItemStack), , , Collections.emptyList());
   }
}

com/hypixel/hytale/server/core/inventory/transaction/ListTransaction.java

package com.hypixel.hytale.server.core.inventory.transaction;

import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ListTransaction<T extends Transaction> implements Transaction {
   public static final ListTransaction<?> EMPTY_SUCCESSFUL_TRANSACTION = new ListTransaction(true);
   public static final ListTransaction<?> EMPTY_FAILED_TRANSACTION = new ListTransaction(false);
   private final boolean succeeded;
   @Nonnull
   private final List<T> list;

   public static <T extends Transaction> ListTransaction<T> getEmptyTransaction(boolean succeeded) {
      return succeeded ? EMPTY_SUCCESSFUL_TRANSACTION : EMPTY_FAILED_TRANSACTION;
   }

   private ListTransaction( succeeded) {
      .succeeded = succeeded;
      .list = Collections.emptyList();
   }

     {
      .succeeded = succeeded;
      .list = Collections.unmodifiableList(list);
   }

      {
       .succeeded;
   }

      {
       (!.succeeded) {
          ;
      }  {
         (T t : .list) {
             (t.succeeded() && t.wasSlotModified(slot)) {
                ;
            }
         }

          ;
      }
   }

   
    List<T>  {
       .list;
   }

      {
       .list.size();
   }

   
    ListTransaction<T>  {
      List<T> list = (List).list.stream().map((transaction) -> transaction.toParent(parent, start, container)).collect(Collectors.toList());
        <T>(.succeeded, list);
   }

   
    ListTransaction<T>  {
      List<T> list = (List).list.stream().map((transactionx) -> transactionx.fromParent(parent, start, container)).filter(Objects::nonNull).collect(Collectors.toList());
       (list.isEmpty()) {
          ;
      }  {
            ;

         (T transaction : list) {
             (transaction.succeeded()) {
               succeeded = ;
               ;
            }
         }

           <T>(succeeded, list);
      }
   }

   
    String  {
         .succeeded;
        + var10000 +  + String.valueOf(.list) + ;
   }
}

com/hypixel/hytale/server/core/inventory/transaction/MaterialSlotTransaction.java

package com.hypixel.hytale.server.core.inventory.transaction;

import com.hypixel.hytale.server.core.inventory.MaterialQuantity;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class MaterialSlotTransaction extends SlotTransaction {
   @Nonnull
   private final MaterialQuantity query;
   private final int remainder;
   @Nonnull
   private final SlotTransaction transaction;

   public MaterialSlotTransaction(@Nonnull MaterialQuantity query, int remainder, @Nonnull SlotTransaction transaction) {
      super(transaction.succeeded(), transaction.getAction(), transaction.getSlot(), transaction.getSlotBefore(), transaction.getSlotAfter(), transaction.getOutput(), transaction.isAllOrNothing(), transaction.isExactAmount(), transaction.isFilter());
      this.query = query;
      this.remainder = remainder;
      this.transaction = transaction;
   }

   @Nonnull
   public MaterialQuantity getQuery() {
      return this.query;
   }

   public int getRemainder() {
      return .remainder;
   }

   
    SlotTransaction  {
       .transaction;
   }

   
    MaterialSlotTransaction  {
        (.query, .remainder, .transaction.toParent(parent, start, container));
   }

   
    MaterialSlotTransaction  {
         .transaction.fromParent(parent, start, container);
       newTransaction ==  ?  :  (.query, .remainder, newTransaction);
   }

   
    String  {
         String.valueOf(.query);
        + var10000 +  + .remainder +  + String.valueOf(.transaction) +  + .toString();
   }
}

com/hypixel/hytale/server/core/inventory/transaction/MaterialTransaction.java

package com.hypixel.hytale.server.core.inventory.transaction;

import com.hypixel.hytale.server.core.inventory.MaterialQuantity;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class MaterialTransaction extends ListTransaction<MaterialSlotTransaction> {
   @Nonnull
   private final ActionType action;
   @Nonnull
   private final MaterialQuantity material;
   private final int remainder;
   private final boolean allOrNothing;
   private final boolean exactAmount;
   private final boolean filter;

   public MaterialTransaction(boolean succeeded, @Nonnull ActionType action, @Nonnull MaterialQuantity material, int remainder, boolean allOrNothing, boolean exactAmount, boolean filter, @Nonnull List<MaterialSlotTransaction> slotTransactions) {
      super(succeeded, slotTransactions);
      .action = action;
      .material = material;
      .remainder = remainder;
      .allOrNothing = allOrNothing;
      .exactAmount = exactAmount;
      .filter = filter;
   }

   
    ActionType  {
       .action;
   }

   
    MaterialQuantity  {
       .material;
   }

      {
       .remainder;
   }

      {
       .allOrNothing;
   }

      {
       .exactAmount;
   }

      {
       .filter;
   }

   
    MaterialTransaction  {
      List<MaterialSlotTransaction> slotTransactions = (List).getList().stream().map((transaction) -> transaction.toParent(parent, start, container)).collect(Collectors.toList());
        (.succeeded(), .action, .material, .remainder, .allOrNothing, .exactAmount, .filter, slotTransactions);
   }

   
    MaterialTransaction  {
      List<MaterialSlotTransaction> slotTransactions = (List).getList().stream().map((transactionx) -> transactionx.fromParent(parent, start, container)).filter(Objects::nonNull).collect(Collectors.toList());
       (slotTransactions.isEmpty()) {
          ;
      }  {
            ;

         (MaterialSlotTransaction transaction : slotTransactions) {
             (transaction.succeeded()) {
               succeeded = ;
               ;
            }
         }

           (succeeded, .action, .material, .remainder, .allOrNothing, .exactAmount, .filter, slotTransactions);
      }
   }

   
    String  {
         String.valueOf(.action);
        + var10000 +  + String.valueOf(.material) +  + .remainder +  + .allOrNothing +  + .exactAmount +  + .filter +  + .toString();
   }
}

com/hypixel/hytale/server/core/inventory/transaction/MoveTransaction.java

package com.hypixel.hytale.server.core.inventory.transaction;

import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class MoveTransaction<T extends Transaction> implements Transaction {
   private final boolean succeeded;
   @Nonnull
   private final SlotTransaction removeTransaction;
   @Nonnull
   private final MoveType moveType;
   @Nonnull
   private final ItemContainer otherContainer;
   private final T addTransaction;

   public MoveTransaction(boolean succeeded, @Nonnull SlotTransaction removeTransaction, @Nonnull MoveType moveType, @Nonnull ItemContainer otherContainer, T addTransaction) {
      this.succeeded = succeeded;
      this.removeTransaction = removeTransaction;
      this.moveType = moveType;
      this.otherContainer = otherContainer;
      this.addTransaction = addTransaction;
   }

   public boolean succeeded() {
      return this.succeeded;
   }

   
    SlotTransaction  {
       .removeTransaction;
   }

   
    MoveType  {
       .moveType;
   }

   
    ItemContainer  {
       .otherContainer;
   }

    T  {
       .addTransaction;
   }

   
    MoveTransaction<T>  {
        <T>(.succeeded(), .removeTransaction, MoveType.MOVE_TO_SELF, itemContainer, .addTransaction);
   }

      {
       (!.succeeded) {
          ;
      }  {
          .addTransaction.succeeded() && .addTransaction.wasSlotModified(slot) || .removeTransaction.succeeded() && .removeTransaction.wasSlotModified(slot);
      }
   }

   
    MoveTransaction<T>  {
         .getMoveType();
      MoveTransaction var10000;
       (moveType) {
          MOVE_TO_SELF -> var10000 =  (.succeeded(), .removeTransaction, moveType, .getOtherContainer(), .addTransaction.toParent(parent, start, container));
          MOVE_FROM_SELF -> var10000 =  (.succeeded(), .removeTransaction.toParent(parent, start, container), moveType, .getOtherContainer(), .addTransaction);
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
    MoveTransaction<T>  {
         .getMoveType();
       (moveType) {
          MOVE_TO_SELF:
               .addTransaction.fromParent(parent, start, container);
             (newAddTransaction == ) {
                ;
            }

              <T>(.succeeded(), .getRemoveTransaction(), .getMoveType(), .getOtherContainer(), newAddTransaction);
          MOVE_FROM_SELF:
               .getRemoveTransaction().fromParent(parent, start, container);
             (newRemoveTransaction == ) {
                ;
            }

              <T>(.succeeded(), newRemoveTransaction, .getMoveType(), .getOtherContainer(), .addTransaction);
         :
              ( + String.valueOf(moveType));
      }
   }

   
    String  {
         .succeeded;
        + var10000 +  + String.valueOf(.removeTransaction) +  + String.valueOf(.moveType) +  + String.valueOf(.otherContainer) +  + String.valueOf(.addTransaction) + ;
   }
}

com/hypixel/hytale/server/core/inventory/transaction/MoveType.java

package com.hypixel.hytale.server.core.inventory.transaction;

public enum MoveType {
   MOVE_TO_SELF,
   MOVE_FROM_SELF;

   private MoveType() {
   }
}

com/hypixel/hytale/server/core/inventory/transaction/ResourceSlotTransaction.java

package com.hypixel.hytale.server.core.inventory.transaction;

import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.ResourceQuantity;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ResourceSlotTransaction extends SlotTransaction {
   @Nonnull
   private final ResourceQuantity query;
   private final int remainder;
   private final int consumed;

   public ResourceSlotTransaction(boolean succeeded, @Nonnull ActionType action, short slot, @Nullable ItemStack slotBefore, @Nullable ItemStack slotAfter, @Nullable ItemStack output, boolean allOrNothing, boolean exactAmount, boolean filter, @Nonnull ResourceQuantity query, int remainder, int consumed) {
      super(succeeded, action, slot, slotBefore, slotAfter, output, allOrNothing, exactAmount, filter);
      this.query = query;
      this.remainder = remainder;
      this.consumed = consumed;
   }

   @Nonnull
   public ResourceQuantity getQuery {
       .query;
   }

      {
       .remainder;
   }

      {
       .consumed;
   }

   
    ResourceSlotTransaction  {
         ()(start + .getSlot());
        (.succeeded(), .getAction(), newSlot, .getSlotBefore(), .getSlotAfter(), .getOutput(), .isAllOrNothing(), .isExactAmount(), .isFilter(), .query, .remainder, .consumed);
   }

   
    ResourceSlotTransaction  {
         ()(.getSlot() - start);
       newSlot >=  && newSlot < container.getCapacity() ?  (.succeeded(), .getAction(), newSlot, .getSlotBefore(), .getSlotAfter(), .getOutput(), .isAllOrNothing(), .isExactAmount(), .isFilter(), .query, .remainder, .consumed) : ;
   }

   
    String  {
         String.valueOf(.query);
        + var10000 +  + .remainder +  + .consumed +  + .toString();
   }
}

com/hypixel/hytale/server/core/inventory/transaction/ResourceTransaction.java

package com.hypixel.hytale.server.core.inventory.transaction;

import com.hypixel.hytale.server.core.inventory.ResourceQuantity;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ResourceTransaction extends ListTransaction<ResourceSlotTransaction> {
   @Nonnull
   private final ActionType action;
   @Nonnull
   private final ResourceQuantity resource;
   private final int remainder;
   private final int consumed;
   private final boolean allOrNothing;
   private final boolean exactAmount;
   private final boolean filter;

   public ResourceTransaction(boolean succeeded, @Nonnull ActionType action, @Nonnull ResourceQuantity resource, int remainder, int consumed, boolean allOrNothing, boolean exactAmount, boolean filter,  List<ResourceSlotTransaction> slotTransactions) {
      (succeeded, slotTransactions);
      .action = action;
      .resource = resource;
      .remainder = remainder;
      .consumed = consumed;
      .allOrNothing = allOrNothing;
      .exactAmount = exactAmount;
      .filter = filter;
   }

   
    ActionType  {
       .action;
   }

   
    ResourceQuantity  {
       .resource;
   }

      {
       .remainder;
   }

      {
       .consumed;
   }

      {
       .allOrNothing;
   }

      {
       .exactAmount;
   }

      {
       .filter;
   }

   
    ResourceTransaction  {
      List<ResourceSlotTransaction> slotTransactions = (List).getList().stream().map((transaction) -> transaction.toParent(parent, start, container)).collect(Collectors.toList());
        (.succeeded(), .action, .resource, .remainder, .consumed, .allOrNothing, .exactAmount, .filter, slotTransactions);
   }

   
    ResourceTransaction  {
      List<ResourceSlotTransaction> slotTransactions = (List).getList().stream().map((transactionx) -> transactionx.fromParent(parent, start, container)).filter(Objects::nonNull).collect(Collectors.toList());
       (slotTransactions.isEmpty()) {
          ;
      }  {
            ;

         (ResourceSlotTransaction transaction : slotTransactions) {
             (transaction.succeeded()) {
               succeeded = ;
               ;
            }
         }

           (succeeded, .action, .resource, .remainder, .consumed, .allOrNothing, .exactAmount, .filter, slotTransactions);
      }
   }

   
    String  {
         String.valueOf(.action);
        + var10000 +  + String.valueOf(.resource) +  + .remainder +  + .consumed +  + .allOrNothing +  + .exactAmount +  + .filter +  + .toString();
   }
}

com/hypixel/hytale/server/core/inventory/transaction/SlotTransaction.java

package com.hypixel.hytale.server.core.inventory.transaction;

import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class SlotTransaction implements Transaction {
   public static final SlotTransaction FAILED_ADD;
   private final boolean succeeded;
   @Nonnull
   private final ActionType action;
   private final short slot;
   @Nullable
   private final ItemStack slotBefore;
   @Nullable
   private final ItemStack slotAfter;
   @Nullable
   private final ItemStack output;
   private final boolean allOrNothing;
   private final boolean exactAmount;
   private final boolean filter;

   public SlotTransaction(boolean succeeded, @Nonnull ActionType action, short slot,  ItemStack slotBefore,  ItemStack slotAfter,  ItemStack output,  allOrNothing,  exactAmount,  filter) {
      .succeeded = succeeded;
      .action = action;
      .slot = slot;
      .slotBefore = slotBefore;
      .slotAfter = slotAfter;
      .output = output;
      .allOrNothing = allOrNothing;
      .exactAmount = exactAmount;
      .filter = filter;
   }

      {
       .succeeded;
   }

      {
       (!.succeeded) {
          ;
      }  {
          .slot == slot;
      }
   }

   
    ActionType  {
       .action;
   }

      {
       .slot;
   }

   
    ItemStack  {
       .slotBefore;
   }

   
    ItemStack  {
       .slotAfter;
   }

   
    ItemStack  {
       .output;
   }

      {
       .allOrNothing;
   }

      {
       .exactAmount;
   }

      {
       .filter;
   }

   
    SlotTransaction  {
         ()(start + .slot);
        (.succeeded, .action, newSlot, .slotBefore, .slotAfter, .output, .allOrNothing, .exactAmount, .filter);
   }

   
    SlotTransaction  {
         ()(.slot - start);
       newSlot >=  && newSlot < container.getCapacity() ?  (.succeeded, .action, newSlot, .slotBefore, .slotAfter, .output, .allOrNothing, .exactAmount, .filter) : ;
   }

   
    String  {
         .succeeded;
        + var10000 +  + String.valueOf(.action) +  + .slot +  + String.valueOf(.slotBefore) +  + String.valueOf(.slotAfter) +  + .allOrNothing +  + .exactAmount +  + .filter + ;
   }

    {
      FAILED_ADD =  (, ActionType.ADD, ()-, (ItemStack), (ItemStack), (ItemStack), , , );
   }
}

com/hypixel/hytale/server/core/inventory/transaction/TagSlotTransaction.java

package com.hypixel.hytale.server.core.inventory.transaction;

import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class TagSlotTransaction extends SlotTransaction {
   private final int query;
   private final int remainder;

   public TagSlotTransaction(boolean succeeded, @Nonnull ActionType action, short slot, @Nullable ItemStack slotBefore, @Nullable ItemStack slotAfter, @Nullable ItemStack output, boolean allOrNothing, boolean exactAmount, boolean filter, @Nonnull int query, int remainder) {
      super(succeeded, action, slot, slotBefore, slotAfter, output, allOrNothing, exactAmount, filter);
      this.query = query;
      this.remainder = remainder;
   }

   public int getQuery() {
      return this.query;
   }

   public int getRemainder() {
       .remainder;
   }

   
    TagSlotTransaction  {
         ()(start + .getSlot());
        (.succeeded(), .getAction(), newSlot, .getSlotBefore(), .getSlotAfter(), .getOutput(), .isAllOrNothing(), .isExactAmount(), .isFilter(), .query, .remainder);
   }

   
    TagSlotTransaction  {
         ()(.getSlot() - start);
       newSlot >=  && newSlot < container.getCapacity() ?  (.succeeded(), .getAction(), newSlot, .getSlotBefore(), .getSlotAfter(), .getOutput(), .isAllOrNothing(), .isExactAmount(), .isFilter(), .query, .remainder) : ;
   }

   
    String  {
         .query;
        + var10000 +  + .remainder +  + .toString();
   }
}

com/hypixel/hytale/server/core/inventory/transaction/TagTransaction.java

package com.hypixel.hytale.server.core.inventory.transaction;

import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class TagTransaction extends ListTransaction<TagSlotTransaction> {
   @Nonnull
   private final ActionType action;
   private final int tagIndex;
   private final int remainder;
   private final boolean allOrNothing;
   private final boolean exactAmount;
   private final boolean filter;

   public TagTransaction(boolean succeeded, @Nonnull ActionType action, int tagIndex, int remainder, boolean allOrNothing, boolean exactAmount, boolean filter, @Nonnull List<TagSlotTransaction> slotTransactions) {
      super(succeeded, slotTransactions);
      this.action = action;
      this.tagIndex = tagIndex;
      this.remainder = remainder;
      .allOrNothing = allOrNothing;
      .exactAmount = exactAmount;
      .filter = filter;
   }

   
    ActionType  {
       .action;
   }

   
      {
       .tagIndex;
   }

      {
       .remainder;
   }

      {
       .allOrNothing;
   }

      {
       .exactAmount;
   }

      {
       .filter;
   }

   
    TagTransaction  {
      List<TagSlotTransaction> slotTransactions = (List).getList().stream().map((transaction) -> transaction.toParent(parent, start, container)).collect(Collectors.toList());
        (.succeeded(), .action, .tagIndex, .remainder, .allOrNothing, .exactAmount, .filter, slotTransactions);
   }

   
    TagTransaction  {
      List<TagSlotTransaction> slotTransactions = (List).getList().stream().map((transactionx) -> transactionx.fromParent(parent, start, container)).filter(Objects::nonNull).collect(Collectors.toList());
       (slotTransactions.isEmpty()) {
          ;
      }  {
            ;

         (TagSlotTransaction transaction : slotTransactions) {
             (transaction.succeeded()) {
               succeeded = ;
               ;
            }
         }

           (succeeded, .action, .tagIndex, .remainder, .allOrNothing, .exactAmount, .filter, slotTransactions);
      }
   }

   
    String  {
         String.valueOf(.action);
        + var10000 +  + .tagIndex +  + .remainder +  + .allOrNothing +  + .exactAmount +  + .filter +  + .toString();
   }
}

com/hypixel/hytale/server/core/inventory/transaction/Transaction.java

package com.hypixel.hytale.server.core.inventory.transaction;

import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public interface Transaction {
   boolean succeeded();

   boolean wasSlotModified(short var1);

   @Nonnull
   Transaction toParent(ItemContainer var1, short var2, ItemContainer var3);

   @Nullable
   Transaction fromParent(ItemContainer var1, short var2, ItemContainer var3);
}