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

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

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

   class="kw">protected class="kw">static int testAddToExistingSlot(@Nonnull ItemContainer var0, short var1, ItemStack var2, int var3, int var4, boolean var5) {
      ItemStack var6 = var0.internal_getSlot(var1);
      if (ItemStack.isEmpty(var6)) {
         class="kw">return var4;
      }

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

      if (var5 && var0.cantAddToSlot(var1, var2, var6)) {
         class="kw">return var4;
      }

      int var7 = var6.getQuantity();
      int var8 = Math.min(var3 - var7, var4);
      class="kw">return var4 - var8;
   }

   @Nonnull
   class="kw">protected class="kw">static ItemStackSlotTransaction internal_addToExistingSlot(
      @Nonnull ItemContainer var0, short var1, @Nonnull ItemStack var2, int var3, boolean var4
   ) {
      ItemStack var5 = var0.internal_getSlot(var1);
      if (ItemStack.isEmpty(var5)) {
         class="kw">return new ItemStackSlotTransaction(false, ActionType.ADD, var1, var5, var5, null, false, false, var4, true, var2, var2);
      }

      if (!var5.isStackableWith(var2)) {
         class="kw">return new ItemStackSlotTransaction(false, ActionType.ADD, var1, var5, var5, null, false, false, var4, true, var2, var2);
      }

      if (var4 && var0.cantAddToSlot(var1, var2, var5)) {
         class="kw">return new ItemStackSlotTransaction(false, ActionType.ADD, var1, var5, var5, null, false, false, var4, true, var2, var2);
      }

      int var6 = var2.getQuantity();
      int var7 = var5.getQuantity();
      int var8 = Math.min(var3 - var7, var6);
      int var9 = var7 + var8;
      var6 -= var8;
      if (var8 <= 0) {
         class="kw">return new ItemStackSlotTransaction(false, ActionType.ADD, var1, var5, var5, null, false, false, var4, true, var2, var2);
      }

      ItemStack var10 = var5.withQuantity(var9);
      if (var9 > 0) {
         var0.internal_setSlot(var1, var10);
      } else {
         var0.internal_removeSlot(var1);
      }

      ItemStack var11 = var6 != var2.getQuantity() ? var2.withQuantity(var6) : var2;
      class="kw">return new ItemStackSlotTransaction(true, ActionType.ADD, var1, var5, var10, null, false, false, var4, true, var2, var11);
   }

   @Nonnull
   class="kw">protected class="kw">static ItemStackSlotTransaction internal_addToEmptySlot(@Nonnull ItemContainer var0, short var1, @Nonnull ItemStack var2, int var3, boolean var4) {
      ItemStack var5 = var0.internal_getSlot(var1);
      if (var5 != null && !var5.isEmpty()) {
         class="kw">return new ItemStackSlotTransaction(false, ActionType.ADD, var1, var5, var5, null, false, false, var4, false, var2, var2);
      }

      if (var4 && var0.cantAddToSlot(var1, var2, var5)) {
         class="kw">return new ItemStackSlotTransaction(false, ActionType.ADD, var1, var5, var5, null, false, false, var4, false, var2, var2);
      }

      int var6 = var2.getQuantity();
      int var7 = Math.min(var3, var6);
      var6 -= var7;
      ItemStack var8 = var2.withQuantity(var7);
      var0.internal_setSlot(var1, var8);
      ItemStack var9 = var2.getQuantity() != var6 ? var2.withQuantity(var6) : var2;
      class="kw">return new ItemStackSlotTransaction(true, ActionType.ADD, var1, var5, var8, null, false, false, var4, false, var2, var9);
   }

   class="kw">protected class="kw">static int testAddToEmptySlots(@Nonnull ItemContainer var0, ItemStack var1, int var2, int var3, boolean var4) {
      for (short var5 = 0; var5 < var0.getCapacity() && var3 > 0; var5++) {
         ItemStack var6 = var0.internal_getSlot(var5);
         if ((var6 == null || var6.isEmpty()) && (!var4 || !var0.cantAddToSlot(var5, var1, var6))) {
            int var7 = Math.min(var2, var3);
            var3 -= var7;
         }
      }

      class="kw">return var3;
   }

   class="kw">protected class="kw">static ItemStackSlotTransaction internal_addItemStackToSlot(
      @Nonnull ItemContainer var0, short var1, @Nonnull ItemStack var2, boolean var3, boolean var4
   ) {
      ItemContainer.validateSlotIndex(var1, var0.getCapacity());
      class="kw">return var0.writeAction(() -> {
         int var5 = var2.getQuantity();
         ItemStack var6 = var0.internal_getSlot(var1);
         if (var4 && var0.cantAddToSlot(var1, var2, var6)) {
            class="kw">return new ItemStackSlotTransaction(false, ActionType.ADD, var1, var6, var6, null, var3, false, var4, false, var2, var2);
         }

         if (var6 == null) {
            var0.internal_setSlot(var1, var2);
            class="kw">return new ItemStackSlotTransaction(true, ActionType.ADD, var1, null, var2, null, var3, false, var4, false, var2, null);
         }

         int var7 = var6.getQuantity();
         if (!var2.isStackableWith(var6)) {
            class="kw">return new ItemStackSlotTransaction(false, ActionType.ADD, var1, var6, var6, null, var3, false, var4, false, var2, var2);
         }

         int var8 = Math.min(var6.getItem().getMaxStack() - var7, var5);
         int var9 = var7 + var8;
         var5 -= var8;
         if (var3 && var5 > 0) {
            class="kw">return new ItemStackSlotTransaction(false, ActionType.ADD, var1, var6, var6, null, var3, false, var4, false, var2, var2);
         }

         if (var8 <= 0) {
            class="kw">return new ItemStackSlotTransaction(false, ActionType.ADD, var1, var6, var6, null, var3, false, var4, false, var2, var2);
         }

         ItemStack var10 = var6.withQuantity(var9);
         var0.internal_setSlot(var1, var10);
         ItemStack var11 = var2.withQuantity(var5);
         class="kw">return new ItemStackSlotTransaction(true, ActionType.ADD, var1, var6, var10, null, var3, false, var4, false, var2, var11);
      });
   }

   @Nonnull
   class="kw">protected class="kw">static ItemStackSlotTransaction internal_setItemStackForSlot(@Nonnull ItemContainer var0, short var1, ItemStack var2, boolean var3) {
      ItemContainer.validateSlotIndex(var1, var0.getCapacity());
      class="kw">return var0.writeAction(() -> {
         ItemStack var4 = var0.internal_getSlot(var1);
         if (var3 && var0.cantAddToSlot(var1, var2, var4)) {
            class="kw">return new ItemStackSlotTransaction(false, ActionType.SET, var1, var4, var4, null, false, false, var3, false, var2, var2);
         }

         ItemStack var5 = var0.internal_setSlot(var1, var2);
         class="kw">return new ItemStackSlotTransaction(true, ActionType.SET, var1, var5, var2, null, false, false, var3, false, var2, null);
      });
   }

   @Nonnull
   class="kw">protected class="kw">static SlotTransaction internal_removeItemStackFromSlot(@Nonnull ItemContainer var0, short var1, boolean var2) {
      ItemContainer.validateSlotIndex(var1, var0.getCapacity());
      class="kw">return var0.writeAction(() -> {
         if (var2 && var0.cantRemoveFromSlot(var1)) {
            ItemStack var4 = var0.internal_getSlot(var1);
            class="kw">return new ItemStackSlotTransaction(false, ActionType.REMOVE, var1, var4, var4, null, false, false, var2, false, null, var4);
         } else {
            ItemStack var3 = var0.internal_removeSlot(var1);
            class="kw">return new SlotTransaction(true, ActionType.REMOVE, var1, var3, null, var3, false, false, false);
         }
      });
   }

   class="kw">protected class="kw">static ItemStackSlotTransaction internal_removeItemStackFromSlot(@Nonnull ItemContainer var0, short var1, int var2, boolean var3, boolean var4) {
      ItemContainer.validateSlotIndex(var1, var0.getCapacity());
      ItemContainer.validateQuantity(var2);
      class="kw">return var0.writeAction(() -> {
         int var5 = var2;
         if (var4 && var0.cantRemoveFromSlot(var1)) {
            ItemStack var14 = var0.internal_getSlot(var1);
            class="kw">return new ItemStackSlotTransaction(false, ActionType.REMOVE, var1, var14, var14, null, var3, false, var4, false, null, var14.withQuantity(var5));
         }

         ItemStack var6 = var0.internal_getSlot(var1);
         if (var6 == null) {
            class="kw">return new ItemStackSlotTransaction(false, ActionType.REMOVE, var1, null, null, null, var3, false, var4, false, null, null);
         }

         int var7 = var6.getQuantity();
         int var8 = Math.min(var7, var5);
         int var9 = var7 - var8;
         var5 -= var8;
         if (var3 && var5 > 0) {
            class="kw">return new ItemStackSlotTransaction(false, ActionType.REMOVE, var1, var6, var6, null, var3, false, var4, false, null, var6.withQuantity(var5));
         }

         ItemStack var10 = var6.withQuantity(var9);
         var0.internal_setSlot(var1, var10);
         ItemStack var11 = var6.withQuantity(var8);
         ItemStack var12 = var6.withQuantity(var5);
         class="kw">return new ItemStackSlotTransaction(true, ActionType.REMOVE, var1, var6, var10, var11, var3, false, var4, false, null, var12);
      });
   }

   class="kw">protected class="kw">static ItemStackSlotTransaction internal_removeItemStackFromSlot(
      @Nonnull ItemContainer var0, short var1, @Nullable ItemStack var2, int var3, boolean var4, boolean var5
   ) {
      class="kw">return internal_removeItemStackFromSlot(var0, var1, var2, var3, var4, var5, (var0x, var1x) -> ItemStack.isStackableWith(var0x, var1x));
   }

   class="kw">protected class="kw">static ItemStackSlotTransaction internal_removeItemStackFromSlot(
      @Nonnull ItemContainer var0, short var1, @Nullable ItemStack var2, int var3, boolean var4, boolean var5, BiPredicate<ItemStack, ItemStack> var6
   ) {
      ItemContainer.validateSlotIndex(var1, var0.getCapacity());
      ItemContainer.validateQuantity(var3);
      class="kw">return var0.writeAction(() -> {
         int var7 = var3;
         if (var5 && var0.cantRemoveFromSlot(var1)) {
            ItemStack var16 = var0.internal_getSlot(var1);
            class="kw">return new ItemStackSlotTransaction(false, ActionType.REMOVE, var1, var16, var16, null, var4, false, var5, false, var2, var2);
         }

         ItemStack var8 = var0.internal_getSlot(var1);
         if ((var8 != null || var2 == null) && (var8 == null || var2 != null) && (var8 == null || var6.test(var8, var2))) {
            if (var8 == null) {
               class="kw">return new ItemStackSlotTransaction(true, ActionType.REMOVE, var1, null, null, null, var4, false, var5, false, var2, var2);
            }

            int var9 = var8.getQuantity();
            int var10 = Math.min(var9, var7);
            int var11 = var9 - var10;
            var7 -= var10;
            if (var4 && var7 > 0) {
               class="kw">return new ItemStackSlotTransaction(false, ActionType.REMOVE, var1, var8, var8, null, var4, false, var5, false, var2, var2);
            }

            ItemStack var12 = var8.withQuantity(var11);
            var0.internal_setSlot(var1, var12);
            ItemStack var13 = var8.withQuantity(var10);
            ItemStack var14 = var2.withQuantity(var7);
            class="kw">return new ItemStackSlotTransaction(true, ActionType.REMOVE, var1, var8, var12, var13, var4, false, var5, false, var2, var14);
         } else {
            class="kw">return new ItemStackSlotTransaction(false, ActionType.REMOVE, var1, var8, var8, null, var4, false, var5, false, var2, var2);
         }
      });
   }

   class="kw">protected class="kw">static int testRemoveItemStackFromSlot(
      @Nonnull ItemContainer var0, short var1, ItemStack var2, int var3, boolean var4, BiPredicate<ItemStack, ItemStack> var5
   ) {
      if (var4 && var0.cantRemoveFromSlot(var1)) {
         class="kw">return var3;
      }

      ItemStack var6 = var0.internal_getSlot(var1);
      if (ItemStack.isEmpty(var6)) {
         class="kw">return var3;
      }

      if (!var5.test(var6, var2)) {
         class="kw">return var3;
      }

      int var7 = var6.getQuantity();
      int var8 = Math.min(var7, var3);
      class="kw">return var3 - var8;
   }

   class="kw">protected class="kw">static int countItemStackFromSlot(@Nonnull ItemContainer var0, short var1, ItemStack var2, boolean var3, BiPredicate<ItemStack, ItemStack> var4) {
      if (var3 && var0.cantRemoveFromSlot(var1)) {
         class="kw">return 0;
      } else {
         ItemStack var5 = var0.internal_getSlot(var1);
         if (ItemStack.isEmpty(var5)) {
            class="kw">return 0;
         } else {
            class="kw">return !var4.test(var5, var2) ? 0 : var5.getQuantity();
         }
      }
   }

   class="kw">protected class="kw">static ItemStackTransaction internal_addItemStack(@Nonnull ItemContainer var0, @Nonnull ItemStack var1, boolean var2, boolean var3, boolean var4) {
      Item var5 = var1.getItem();
      if (var5 == null) {
         throw new IllegalArgumentException(var1.getItemId() + " is an invalid item!");
      }

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

            var6 = testAddToEmptySlots(var0, var1, var6, var6, var4);
            if (var6 > 0) {
               class="kw">return new ItemStackTransaction(false, ActionType.ADD, var1, var1, var2, var4, Collections.emptyList());
            }
         }

         List var11 = new ObjectArrayList();
         ItemStack var7 = var1;
         if (!var3) {
            for (short var8 = 0; var8 < var0.getCapacity() && !ItemStack.isEmpty(var7); var8++) {
               ItemStackSlotTransaction var9 = internal_addToExistingSlot(var0, var8, var7, var6, var4);
               var11.add(var9);
               var7 = var9.getRemainder();
            }
         }

         for (short var12 = 0; var12 < var0.getCapacity() && !ItemStack.isEmpty(var7); var12++) {
            ItemStackSlotTransaction var14 = internal_addToEmptySlot(var0, var12, var7, var6, var4);
            var11.add(var14);
            var7 = var14.getRemainder();
         }

         boolean var13 = ItemStack.isEmpty(var7) || var7.getQuantity() != var1.getQuantity();
         class="kw">return new ItemStackTransaction(var13, ActionType.ADD, var1, var7, var2, var4, var11);
      });
   }

   class="kw">protected class="kw">static ListTransaction<ItemStackTransaction> internal_addItemStacks(
      @Nonnull ItemContainer var0, @Nullable List<ItemStack> var1, boolean var2, boolean var3, boolean var4
   ) {
      class="kw">return var1 != null && !var1.isEmpty()
         ? var0.writeAction(
            () -> {
               if (var2) {
                  for (ItemStack var6 : var1) {
                     int var7 = var6.getItem().getMaxStack();
                     int var8 = var6.getQuantity();
                     if (!var3) {
                        var8 = testAddToExistingItemStacks(var0, var6, var7, var8, var4);
                     }

                     var8 = testAddToEmptySlots(var0, var6, var7, var8, var4);
                     if (var8 > 0) {
                        class="kw">return new ListTransaction<>(
                           false,
                           var1.stream()
                              .map(var3x -> new ItemStackTransaction(false, ActionType.ADD, var6, var6, var2, var4, Collections.emptyList()))
                              .collect(Collectors.toList())
                        );
                     }
                  }
               }

               List var10 = new ObjectArrayList();
               boolean var11 = false;

               for (ItemStack var14 : var1) {
                  ItemStackTransaction var9 = internal_addItemStack(var0, var14, var2, var3, var4);
                  var10.add(var9);
                  if (var9.succeeded()) {
                     var11 = true;
                  }
               }

               class="kw">return new ListTransaction<>(var11, var10);
            }
         )
         : ListTransaction.getEmptyTransaction(true);
   }

   class="kw">protected class="kw">static ListTransaction<ItemStackSlotTransaction> internal_addItemStacksOrdered(
      @Nonnull ItemContainer var0, short var1, @Nullable List<ItemStack> var2, boolean var3, boolean var4
   ) {
      if (var2 != null && !var2.isEmpty()) {
         ItemContainer.validateSlotIndex(var1, var0.getCapacity());
         ItemContainer.validateSlotIndex((short)(var1 + var2.size()), var0.getCapacity());
         class="kw">return var0.writeAction(() -> {
            if (var3) {
               for (short var5 = 0; var5 < var2.size(); var5++) {
                  short var6 = (short)(var1 + var5);
                  ItemStack var7 = var2.get(var5);
                  int var8 = var7.getItem().getMaxStack();
                  int var9 = var7.getQuantity();
                  var9 = testAddToExistingSlot(var0, var6, var7, var8, var9, var4);
                  if (var9 > 0) {
                     List var10 = new ObjectArrayList();

                     for (short var11 = 0; var11 < var2.size(); var11++) {
                        short var12 = (short)(var1 + var11);
                        var10.add(new ItemStackSlotTransaction(false, ActionType.ADD, var12, null, null, null, var3, false, var4, false, var7, var7));
                     }

                     class="kw">return new ListTransaction<>(false, var10);
                  }
               }
            }

            List var13 = new ObjectArrayList();
            boolean var14 = false;

            for (short var15 = 0; var15 < var2.size(); var15++) {
               short var16 = (short)(var1 + var15);
               ItemStackSlotTransaction var18 = internal_addItemStackToSlot(var0, var16, var2.get(var15), var3, var4);
               var13.add(var18);
               if (var18.succeeded()) {
                  var14 = true;
               }
            }

            class="kw">return new ListTransaction<>(var14, var13);
         });
      } else {
         class="kw">return ListTransaction.getEmptyTransaction(true);
      }
   }

   class="kw">protected class="kw">static int testAddToExistingItemStacks(@Nonnull ItemContainer var0, ItemStack var1, int var2, int var3, boolean var4) {
      for (short var5 = 0; var5 < var0.getCapacity() && var3 > 0; var5++) {
         var3 = testAddToExistingSlot(var0, var5, var1, var2, var3, var4);
      }

      class="kw">return var3;
   }

   class="kw">protected class="kw">static ItemStackTransaction internal_removeItemStack(@Nonnull ItemContainer var0, @Nonnull ItemStack var1, boolean var2, boolean var3) {
      Item var4 = var1.getItem();
      if (var4 == null) {
         throw new IllegalArgumentException(var1.getItemId() + " is an invalid item!");
      } else {
         class="kw">return var0.writeAction(() -> {
            if (var2) {
               int var4 = testRemoveItemStackFromItems(var0, var1, var1.getQuantity(), var3);
               if (var4 > 0) {
                  class="kw">return new ItemStackTransaction(false, ActionType.REMOVE, var1, var1, var2, var3, Collections.emptyList());
               }
            }

            List var9 = new ObjectArrayList();
            int var5 = var1.getQuantity();

            for (short var6 = 0; var6 < var0.getCapacity() && var5 > 0; var6++) {
               ItemStack var7 = var0.internal_getSlot(var6);
               if (!ItemStack.isEmpty(var7) && var7.isStackableWith(var1)) {
                  ItemStackSlotTransaction var8 = internal_removeItemStackFromSlot(var0, var6, var5, false, var3);
                  var9.add(var8);
                  var5 = var8.getRemainder() != null ? var8.getRemainder().getQuantity() : 0;
               }
            }

            ItemStack var10 = var5 > 0 ? var1.withQuantity(var5) : null;
            class="kw">return new ItemStackTransaction(true, ActionType.REMOVE, var1, var10, var2, var3, var9);
         });
      }
   }

   class="kw">protected class="kw">static ListTransaction<ItemStackTransaction> internal_removeItemStacks(
      @Nonnull ItemContainer var0, @Nullable List<ItemStack> var1, boolean var2, boolean var3
   ) {
      if (var1 != null && !var1.isEmpty()) {
         for (ItemStack var5 : var1) {
            Item var6 = var5.getItem();
            if (var6 == null) {
               throw new IllegalArgumentException(var5.getItemId() + " is an invalid item!");
            }
         }

         class="kw">return var0.writeAction(
            () -> {
               if (var2) {
                  for (ItemStack var5 : var1) {
                     int var6 = testRemoveItemStackFromItems(var0, var5, var5.getQuantity(), var3);
                     if (var6 > 0) {
                        class="kw">return new ListTransaction<>(
                           false,
                           var1.stream()
                              .map(var3x -> new ItemStackTransaction(false, ActionType.ADD, var5, var5, var2, var3, Collections.emptyList()))
                              .collect(Collectors.toList())
                        );
                     }
                  }
               }

               List var7 = new ObjectArrayList();

               for (short var8 = 0; var8 < var1.size(); var8++) {
                  var7.add(internal_removeItemStack(var0, var1.get(var8), var2, var3));
               }

               class="kw">return new ListTransaction<>(true, var7);
            }
         );
      } else {
         class="kw">return ListTransaction.getEmptyTransaction(true);
      }
   }

   class="kw">protected class="kw">static int testRemoveItemStackFromItems(@Nonnull ItemContainer var0, ItemStack var1, int var2, boolean var3) {
      class="kw">return testRemoveItemStackFromItems(var0, var1, var2, var3, (var0x, var1x) -> ItemStack.isStackableWith(var0x, var1x));
   }

   class="kw">protected class="kw">static int testRemoveItemStackFromItems(
      @Nonnull ItemContainer var0, ItemStack var1, int var2, boolean var3, BiPredicate<ItemStack, ItemStack> var4
   ) {
      for (short var5 = 0; var5 < var0.getCapacity() && var2 > 0; var5++) {
         if (!var3 || !var0.cantRemoveFromSlot(var5)) {
            ItemStack var6 = var0.internal_getSlot(var5);
            if (!ItemStack.isEmpty(var6) && var4.test(var6, var1)) {
               int var7 = var6.getQuantity();
               int var8 = Math.min(var7, var2);
               var2 -= var8;
            }
         }
      }

      class="kw">return var2;
   }

   class="kw">protected class="kw">static int countItemStackFromItems(@Nonnull ItemContainer var0, ItemStack var1, boolean var2, BiPredicate<ItemStack, ItemStack> var3) {
      long var4 = 0L;

      for (short var6 = 0; var6 < var0.getCapacity(); var6++) {
         var4 += countItemStackFromSlot(var0, var6, var1, var2, var3);
      }

      class="kw">return (int)Math.min(var4, 2147483647L);
   }

   class="kw">protected class="kw">static TestRemoveItemSlotResult testRemoveItemStackSlotFromItems(@Nonnull ItemContainer var0, ItemStack var1, int var2, boolean var3) {
      class="kw">return testRemoveItemStackSlotFromItems(var0, var1, var2, var3, (var0x, var1x) -> ItemStack.isStackableWith(var0x, var1x));
   }

   class="kw">protected class="kw">static TestRemoveItemSlotResult testRemoveItemStackSlotFromItems(
      @Nonnull ItemContainer var0, ItemStack var1, int var2, boolean var3, BiPredicate<ItemStack, ItemStack> var4
   ) {
      TestRemoveItemSlotResult var5 = new TestRemoveItemSlotResult(var2);

      for (short var6 = 0; var6 < var0.getCapacity() && var5.quantityRemaining > 0; var6++) {
         if (!var3 || !var0.cantRemoveFromSlot(var6)) {
            ItemStack var7 = var0.internal_getSlot(var6);
            if (!ItemStack.isEmpty(var7) && var4.test(var7, var1)) {
               int var8 = var7.getQuantity();
               int var9 = Math.min(var8, var5.quantityRemaining);
               var5.quantityRemaining -= var9;
               var5.picked.put(var6, var9);
            }
         }
      }

      class="kw">return var5;
   }
}