protected int doHash(Object o) {
  return System.identityHashCode(o); // <-----
}

public final int hash(@Nullable T t) {
  if (t == null) {
    return 0;
  }
  return doHash(t); // <-----
}

int hash(Object key) {
  int h = this.keyEquivalence.hash(key);
  return rehash(h); // <-----
}

public V get(@Nullable Object key) {
  if (key == null) {
    return null;
  }
  int hash = hash(key); // <-----
  return (V)segmentFor(hash).get(key, hash);
}

@Override
public NetworkMarker getMarker(Object packet) {
    return packetMarker.get(packet); // <-----
}

/**
 * Process a given message on the packet listeners.
 * @param message - the message/packet.
 * @return The resulting message/packet.
 */
private PacketEvent processSending(Object message) {
    return channelListener.onPacketSending(ChannelInjector.this, message, getMarker(message)); // <-----
}

protected PacketEvent handleScheduled(Object instance, FieldAccessor accessor) {
    // Let the filters handle this packet
    Object original = accessor.get(instance);

    // See if we've been instructed not to process packets
    if (!scheduleProcessPackets.get()) {
        NetworkMarker marker = getMarker(original);

        if (marker != null)    {
            PacketEvent result = new PacketEvent(ChannelInjector.class);
            result.setNetworkMarker(marker);
            return result;
        } else {
            return BYPASSED_PACKET;
        }
    }
    PacketEvent event = processSending(original); // <-----

    if (event != null && !event.isCancelled()) {
        Object changed = event.getPacket().getHandle();

        // Change packet to be scheduled
        if (original != changed)
            accessor.set(instance, changed);
    };
    return event != null ? event : BYPASSED_PACKET;
}

@Override
protected Runnable onMessageScheduled(final Runnable runnable, FieldAccessor packetAccessor) {
    final PacketEvent event = handleScheduled(runnable, packetAccessor); // <-----

    // Handle cancelled events
    if (event != null && event.isCancelled())
        return null;

    return new Runnable() {
        @Override
        public void run() {
            currentEvent = event;
            runnable.run();
            currentEvent = null;
        }
    };
}

@Override
protected Runnable schedulingRunnable(final Runnable runnable) {
    final FieldAccessor accessor = getMessageAccessor(runnable);

    if (accessor != null) {
        Runnable result = onMessageScheduled(runnable, accessor);; // <-----
        return result != null ? result : getEmptyRunnable();
    }
    return runnable;
}

@Override
public void execute(Runnable command) {
    getDelegate().execute(schedulingRunnable(command)); // <-----
}

private void a(final Packet<?> packet, @Nullable final GenericFutureListener<? extends Future<? super Void>>[] agenericfuturelistener)
{
  final EnumProtocol enumprotocol = EnumProtocol.a(packet);
  final EnumProtocol enumprotocol1 = (EnumProtocol)this.channel.attr(c).get();
  if (enumprotocol1 != enumprotocol)
  {
    g.debug("Disabled auto read");
    this.channel.config().setAutoRead(false);
  }
  if (this.channel.eventLoop().inEventLoop())
  {
    if (enumprotocol != enumprotocol1) {
      setProtocol(enumprotocol);
    }
    ChannelFuture channelfuture = this.channel.writeAndFlush(packet);
    if (agenericfuturelistener != null) {
      channelfuture.addListeners(agenericfuturelistener);
    }
    channelfuture.addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE);
  }
  else
  {
    this.channel.eventLoop().execute(new Runnable() // <-----
    {
      public void run()
      {
        if (enumprotocol != enumprotocol1) {
          NetworkManager.this.setProtocol(enumprotocol);
        }
        ChannelFuture channelfuture = NetworkManager.this.channel.writeAndFlush(packet);
        if (agenericfuturelistener != null) {
          channelfuture.addListeners(agenericfuturelistener);
        }
        channelfuture.addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE);
      }
    });
  }
}

public void sendPacket(Packet<?> packet) {
  if (isConnected()) {
    m();
    a(packet, null); // <-----
  } else {
    j.writeLock().lock();
    try
    {
      i.add(new QueuedPacket(packet, new GenericFutureListener[0]));
    } finally {
      j.writeLock().unlock();
    }
  }
}

public void sendPacket(final Packet<?> packet)
{
  if ((packet instanceof PacketPlayOutChat))
  {
    PacketPlayOutChat packetplayoutchat = (PacketPlayOutChat)packet;
    EntityHuman.EnumChatVisibility entityhuman_enumchatvisibility = this.player.getChatFlags();
    if ((entityhuman_enumchatvisibility == EntityHuman.EnumChatVisibility.HIDDEN) && (packetplayoutchat.c() != ChatMessageType.GAME_INFO)) {
      return;
    }
    if ((entityhuman_enumchatvisibility == EntityHuman.EnumChatVisibility.SYSTEM) && (!packetplayoutchat.b())) {
      return;
    }
  }
  if (packet == null) {
    return;
  }
  if ((packet instanceof PacketPlayOutSpawnPosition))
  {
    PacketPlayOutSpawnPosition packet6 = (PacketPlayOutSpawnPosition)packet;
    this.player.compassTarget = new Location(getPlayer().getWorld(), packet6.position.getX(), packet6.position.getY(), packet6.position.getZ());
  }
  try
  {
    this.networkManager.sendPacket(packet); // <-----
  }
  catch (Throwable throwable)
  {
    CrashReport crashreport = CrashReport.a(throwable, "Sending packet");
    CrashReportSystemDetails crashreportsystemdetails = crashreport.a("Packet being sent");
    
    crashreportsystemdetails.a("Packet class", new CrashReportCallable()
    {
      public String a()
        throws Exception
      {
        return packet.getClass().getCanonicalName();
      }
      
      public Object call()
        throws Exception
      {
        return a();
      }
    });
    throw new ReportedException(crashreport);
  }
}

public void closeInventory()
{
  CraftEventFactory.handleInventoryCloseEvent(this);
  playerConnection.sendPacket(new PacketPlayOutCloseWindow(activeContainer.windowId)); // <-----
  r();
}

public void closeInventory()
{
  getHandle().closeInventory(); // <-----
}

/**
 * Close the GUI.
 *
 * @param removeFromGuis Whether the GUI should be removed from the server.
 */
private void dispose(boolean removeFromGuis) {
    // Close the GUI for all viewers.
    while (!inv.getViewers().isEmpty()) {
        inv.getViewers().get(0).closeInventory(); // <-----
    }
    if (removeFromGuis) {
        guis.remove(this);
    }
}

/**
 * Close the GUI, and remove it from the server.
 */
public void dispose() {
    dispose(true); // <-----
}

@Override
public void dispose() {
    super.dispose(); // <-----
    guis.remove(player.getUniqueId());
    guis.remove(location);
}

private void blockRemoved(Block b) {
    if (b.getType() != Material.WORKBENCH) return;
    GUIFastCraft gui = guis.get(b.getLocation());
    if (gui != null) {
        gui.dispose(); // <-----
    }
}

@EventHandler(priority = EventPriority.HIGHEST)
public void onBlockBreak(BlockBreakEvent e) {
	if (e.isCancelled()) return;
	blockRemoved(e.getBlock()); // <-----
}

public void execute(Listener listener, Event event)
  throws EventException
{
  try
  {
    if (!eventClass.isAssignableFrom(event.getClass())) {
      return;
    }
    method.invoke(listener, new Object[] { event }); // <-----
  }
  catch (InvocationTargetException ex)
  {
    throw new EventException(ex.getCause());
  }
  catch (Throwable t)
  {
    throw new EventException(t);
  }
}

public void callEvent(Event event)
  throws EventException
{
  if (((event instanceof Cancellable)) && 
    (((Cancellable)event).isCancelled()) && (isIgnoringCancelled())) {
    return;
  }
  this.executor.execute(this.listener, event); // <-----
}

private void fireEvent(Event event)
{
  HandlerList handlers = event.getHandlers();
  RegisteredListener[] listeners = handlers.getRegisteredListeners();
  RegisteredListener[] arrayOfRegisteredListener1;
  int j = (arrayOfRegisteredListener1 = listeners).length;
  for (int i = 0; i < j; i++)
  {
    RegisteredListener registration = arrayOfRegisteredListener1[i];
    if (registration.getPlugin().isEnabled()) {
      try
      {
        registration.callEvent(event); // <-----
      }
      catch (AuthorNagException ex)
      {
        Plugin plugin = registration.getPlugin();
        if (plugin.isNaggable())
        {
          plugin.setNaggable(false);
          
          this.server.getLogger().log(Level.SEVERE, String.format(
            "Nag author(s): '%s' of '%s' about the following: %s", new Object[] {
            plugin.getDescription().getAuthors(), 
            plugin.getDescription().getFullName(), 
            ex.getMessage() }));
        }
      }
      catch (Throwable ex)
      {
        this.server.getLogger().log(Level.SEVERE, "Could not pass event " + event.getEventName() + " to " + registration.getPlugin().getDescription().getFullName(), ex);
      }
    }
  }
}

public void callEvent(Event event)
{
  if (event.isAsynchronous())
  {
    if (Thread.holdsLock(this)) {
      throw new IllegalStateException(event.getEventName() + " cannot be triggered asynchronously from inside synchronized code.");
    }
    if (this.server.isPrimaryThread()) {
      throw new IllegalStateException(event.getEventName() + " cannot be triggered asynchronously from primary server thread.");
    }
    fireEvent(event);
  }
  else
  {
    synchronized (this)
    {
      fireEvent(event); // <-----
    }
  }
}

public boolean breakBlock(BlockPosition blockposition)
{
  BlockBreakEvent event = null;
  TileEntity tileentity;
  if ((this.player instanceof EntityPlayer))
  {
    org.bukkit.block.Block block = this.world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
    
    boolean isSwordNoBreak = (this.gamemode.isCreative()) && (!this.player.getItemInMainHand().isEmpty()) && ((this.player.getItemInMainHand().getItem() instanceof ItemSword));
    if ((this.world.getTileEntity(blockposition) == null) && (!isSwordNoBreak))
    {
      PacketPlayOutBlockChange packet = new PacketPlayOutBlockChange(this.world, blockposition);
      packet.block = Blocks.AIR.getBlockData();
      this.player.playerConnection.sendPacket(packet);
    }
    event = new BlockBreakEvent(block, this.player.getBukkitEntity());
    
    event.setCancelled(isSwordNoBreak);
    
    IBlockData nmsData = this.world.getType(blockposition);
    Block nmsBlock = nmsData.getBlock();
    
    ItemStack itemstack = this.player.getEquipment(EnumItemSlot.MAINHAND);
    if ((nmsBlock != null) && (!event.isCancelled()) && (!isCreative()) && (this.player.hasBlock(nmsBlock.getBlockData()))) {
      if ((!nmsBlock.o()) || (EnchantmentManager.getEnchantmentLevel(Enchantments.SILK_TOUCH, itemstack) <= 0))
      {
        int bonusLevel = EnchantmentManager.getEnchantmentLevel(Enchantments.LOOT_BONUS_BLOCKS, itemstack);
        
        event.setExpToDrop(nmsBlock.getExpDrop(this.world, nmsData, bonusLevel));
      }
    }
    this.world.getServer().getPluginManager().callEvent(event); // <-----
    if (event.isCancelled())
    {
      if (isSwordNoBreak) {
        return false;
      }
      this.player.playerConnection.sendPacket(new PacketPlayOutBlockChange(this.world, blockposition));
      if ((nmsBlock instanceof BlockDoor))
      {
        boolean bottom = nmsData.get(BlockDoor.HALF) == BlockDoor.EnumDoorHalf.LOWER;
        this.player.playerConnection.sendPacket(new PacketPlayOutBlockChange(this.world, bottom ? blockposition.up() : blockposition.down()));
      }
      tileentity = this.world.getTileEntity(blockposition);
      if (tileentity != null) {
        this.player.playerConnection.sendPacket(tileentity.getUpdatePacket());
      }
      return false;
    }
  }
  IBlockData iblockdata = this.world.getType(blockposition);
  if (iblockdata.getBlock() == Blocks.AIR) {
    return false;
  }
  TileEntity tileentity = this.world.getTileEntity(blockposition);
  Block block = iblockdata.getBlock();
  if ((iblockdata.getBlock() == Blocks.SKULL) && (!isCreative()) && (event.isDropItems()))
  {
    iblockdata.getBlock().dropNaturally(this.world, blockposition, iblockdata, 1.0F, 0);
    return c(blockposition);
  }
  if (((iblockdata.getBlock() instanceof BlockShulkerBox)) && (event.isDropItems()))
  {
    iblockdata.getBlock().dropNaturally(this.world, blockposition, iblockdata, 1.0F, 0);
    return c(blockposition);
  }
  if ((((block instanceof BlockCommand)) || ((block instanceof BlockStructure))) && (!this.player.isCreativeAndOp()))
  {
    this.world.notify(blockposition, iblockdata, iblockdata, 3);
    return false;
  }
  if (this.gamemode.c())
  {
    if (this.gamemode == EnumGamemode.SPECTATOR) {
      return false;
    }
    if (!this.player.dk())
    {
      ItemStack itemstack = this.player.getItemInMainHand();
      if (itemstack.isEmpty()) {
        return false;
      }
      if (!itemstack.a(block)) {
        return false;
      }
    }
  }
  this.world.a(this.player, 2001, blockposition, Block.getCombinedId(iblockdata));
  
  this.world.captureDrops = new ArrayList();
  boolean flag = c(blockposition);
  if (event.isDropItems()) {
    for (EntityItem item : this.world.captureDrops) {
      this.world.addEntity(item);
    }
  }
  this.world.captureDrops = null;
  if (isCreative())
  {
    this.player.playerConnection.sendPacket(new PacketPlayOutBlockChange(this.world, blockposition));
  }
  else
  {
    ItemStack itemstack1 = this.player.getItemInMainHand();
    ItemStack itemstack2 = itemstack1.isEmpty() ? ItemStack.a : itemstack1.cloneItemStack();
    boolean flag1 = this.player.hasBlock(iblockdata);
    if (!itemstack1.isEmpty()) {
      itemstack1.a(this.world, iblockdata, blockposition, this.player);
    }
    if ((flag) && (flag1) && (event.isDropItems())) {
      iblockdata.getBlock().a(this.world, this.player, blockposition, iblockdata, tileentity, itemstack2);
    }
  }
  if ((flag) && (event != null)) {
    iblockdata.getBlock().dropExperience(this.world, blockposition, event.getExpToDrop());
  }
  return flag;
}

TODO

TODO

TODO

TODO

TODO

TODO

TODO

TODO

TODO