content: package net.minecraft.inventory;
  
  import net.minecraft.entity.player.EntityPlayer;
  import net.minecraft.entity.player.InventoryPlayer;
  import net.minecraft.init.Blocks;
  import net.minecraft.init.Items;
  import net.minecraft.item.Item;
  import net.minecraft.item.ItemArmor;
  import net.minecraft.item.ItemStack;
  import net.minecraft.item.crafting.CraftingManager;
  
  public class ContainerPlayer extends Container {
      public InventoryCrafting craftMatrix = new InventoryCrafting(this, 2, 2);
      public IInventory craftResult = new InventoryCraftResult();
      public boolean isLocalWorld;
      private final EntityPlayer thePlayer;
  
      public ContainerPlayer(final InventoryPlayer playerInventory, boolean localWorld, EntityPlayer player) {
          this.isLocalWorld = localWorld;
          this.thePlayer = player;
          this.addSlotToContainer(new SlotCrafting(playerInventory.player, this.craftMatrix, this.craftResult, 0, 144, 36));
  
          for (int i = 0; i < 2; ++i) {
              for (int j = 0; j < 2; ++j) {
                  this.addSlotToContainer(new Slot(this.craftMatrix, j + i * 2, 88 + j * 18, 26 + i * 18));
              }
          }
  
          for (int k = 0; k < 4; ++k) {
              final int k_f = k;
              this.addSlotToContainer(new Slot(playerInventory, playerInventory.getSizeInventory() - 1 - k, 8, 8 + k * 18) {
                  public int getSlotStackLimit() {
                      return 1;
                  }
  
                  public boolean isItemValid(ItemStack stack) {
                      return stack != null && (stack.getItem() instanceof ItemArmor ? ((ItemArmor) stack.getItem()).armorType == k_f : ((stack.getItem() == Item.getItemFromBlock(Blocks.pumpkin) || stack.getItem() == Items.skull) && k_f == 0));
                  }
  
                  public String getSlotTexture() {
                      return ItemArmor.EMPTY_SLOT_NAMES[k_f];
                  }
              });
          }
  
          for (int l = 0; l < 3; ++l) {
              for (int j1 = 0; j1 < 9; ++j1) {
                  this.addSlotToContainer(new Slot(playerInventory, j1 + (l + 1) * 9, 8 + j1 * 18, 84 + l * 18));
              }
          }
  
          for (int i1 = 0; i1 < 9; ++i1) {
              this.addSlotToContainer(new Slot(playerInventory, i1, 8 + i1 * 18, 142));
          }
  
          this.onCraftMatrixChanged(this.craftMatrix);
      }
  
      public void onCraftMatrixChanged(IInventory inventoryIn) {
          this.craftResult.setInventorySlotContents(0, CraftingManager.getInstance().findMatchingRecipe(this.craftMatrix, this.thePlayer.worldObj));
      }
  
      public void onContainerClosed(EntityPlayer playerIn) {
          super.onContainerClosed(playerIn);
  
          for (int i = 0; i < 4; ++i) {
              ItemStack itemstack = this.craftMatrix.removeStackFromSlot(i);
  
              if (itemstack != null) {
                  playerIn.dropPlayerItemWithRandomChoice(itemstack, false);
              }
          }
  
          this.craftResult.setInventorySlotContents(0, null);
      }
  
      public boolean canInteractWith(EntityPlayer playerIn) {
          return true;
      }
  
      public ItemStack transferStackInSlot(EntityPlayer playerIn, int index) {
          ItemStack itemstack = null;
          Slot slot = this.inventorySlots.get(index);
  
          if (slot != null && slot.getHasStack()) {
              ItemStack itemstack1 = slot.getStack();
              itemstack = itemstack1.copy();
  
              if (index == 0) {
                  if (!this.mergeItemStack(itemstack1, 9, 45, true)) {
                      return null;
                  }
  
                  slot.onSlotChange(itemstack1, itemstack);
              } else if (index >= 1 && index < 5) {
                  if (!this.mergeItemStack(itemstack1, 9, 45, false)) {
                      return null;
                  }
              } else if (index >= 5 && index < 9) {
                  if (!this.mergeItemStack(itemstack1, 9, 45, false)) {
                      return null;
                  }
              } else if (itemstack.getItem() instanceof ItemArmor && !this.inventorySlots.get(5 + ((ItemArmor) itemstack.getItem()).armorType).getHasStack()) {
                  int i = 5 + ((ItemArmor) itemstack.getItem()).armorType;
  
                  if (!this.mergeItemStack(itemstack1, i, i + 1, false)) {
                      return null;
                  }
              } else if (index >= 9 && index < 36) {
                  if (!this.mergeItemStack(itemstack1, 36, 45, false)) {
                      return null;
                  }
              } else if (index >= 36 && index < 45) {
                  if (!this.mergeItemStack(itemstack1, 9, 36, false)) {
                      return null;
                  }
              } else if (!this.mergeItemStack(itemstack1, 9, 45, false)) {
                  return null;
              }
  
              if (itemstack1.stackSize == 0) {
                  slot.putStack(null);
              } else {
                  slot.onSlotChanged();
              }
  
              if (itemstack1.stackSize == itemstack.stackSize) {
                  return null;
              }
  
              slot.onPickupFromSlot(playerIn, itemstack1);
          }
  
          return itemstack;
      }
  
      public boolean canMergeSlot(ItemStack stack, Slot slotIn) {
          return slotIn.inventory != this.craftResult && super.canMergeSlot(stack, slotIn);
      }
  }
  