diff --git a/src/main/java/net/minecraft/item/crafting/FurnaceRecipes.java b/src/main/java/net/minecraft/item/crafting/FurnaceRecipes.java
index 8d54f65..a9e92a5 100644
--- a/src/main/java/net/minecraft/item/crafting/FurnaceRecipes.java
+++ b/src/main/java/net/minecraft/item/crafting/FurnaceRecipes.java
@@ -1,13 +1,12 @@
 package net.minecraft.item.crafting;
 
-import gnu.trove.map.TIntObjectMap;
-import gnu.trove.map.hash.TIntObjectHashMap;
-
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Map.Entry;
 
+import org.ultramine.server.util.ItemStackHashMap;
+
 import net.minecraft.block.Block;
 import net.minecraft.init.Blocks;
 import net.minecraft.init.Items;
@@ -18,18 +17,8 @@
 public class FurnaceRecipes
 {
 	private static final FurnaceRecipes smeltingBase = new FurnaceRecipes();
-	private Map smeltingList = new HashMap()
-	{
-		public Object put(Object o1, Object o2)
-		{
-			ItemStack input = (ItemStack) o1;
-			ItemStack output = (ItemStack) o2;
-			fastMap.put((Item.getIdFromItem(input.getItem()) << 16) | (input.getItemDamage() & 0xFFFF), output);
-			return super.put(o1, o2);
-		}
-	};
+	private Map smeltingList = new ItemStackHashMap<Object>(false);
 	private Map experienceList = new HashMap();
-	private TIntObjectMap<ItemStack> fastMap = new TIntObjectHashMap<ItemStack>();
 	private static final String __OBFID = "CL_00000085";
 
 	public static FurnaceRecipes smelting()
@@ -92,11 +81,7 @@
 
 	public ItemStack getSmeltingResult(ItemStack p_151395_1_)
 	{
-		int idPart = Item.getIdFromItem(p_151395_1_.getItem()) << 16;
-		ItemStack ret = fastMap.get(idPart | (p_151395_1_.getItemDamage() & 0xFFFF));
-		if(ret == null)
-			ret = fastMap.get(idPart | 32767);
-		return ret;
+		return (ItemStack)smeltingList.get(p_151395_1_);//It's ItemStackHashMap
 		/*
 		Iterator iterator = this.smeltingList.entrySet().iterator();
 		Entry entry;
@@ -150,11 +135,6 @@
 	
 	public void remap()
 	{
-		Map<ItemStack, ItemStack> map = (Map<ItemStack, ItemStack>)smeltingList;
-		for(Entry<ItemStack, ItemStack> ent : map.entrySet())
-		{
-			ItemStack input = ent.getKey();
-			fastMap.put((Item.getIdFromItem(input.getItem()) << 16) | (input.getItemDamage() & 0xFFFF), ent.getValue());
-		}
+		((ItemStackHashMap<Object>)smeltingList).remap();
 	}
 }
\ No newline at end of file
diff --git a/src/main/java/org/ultramine/server/UltramineServerModContainer.java b/src/main/java/org/ultramine/server/UltramineServerModContainer.java
index 0a8b052..fce1631 100644
--- a/src/main/java/org/ultramine/server/UltramineServerModContainer.java
+++ b/src/main/java/org/ultramine/server/UltramineServerModContainer.java
@@ -24,6 +24,7 @@
 import org.ultramine.server.data.Databases;
 import org.ultramine.server.data.ServerDataLoader;
 import org.ultramine.server.data.player.PlayerCoreData;
+import org.ultramine.server.event.ForgeModIdMappingEvent;
 import org.ultramine.server.tools.ButtonCommand;
 import org.ultramine.server.tools.ItemBlocker;
 import org.ultramine.server.tools.WarpProtection;
@@ -200,6 +201,7 @@
 	@Subscribe
 	public void remap(FMLModIdMappingEvent e)
 	{
+		MinecraftForge.EVENT_BUS.post(new ForgeModIdMappingEvent(e));
 		FurnaceRecipes.smelting().remap();
 	}
 	
@@ -220,7 +222,8 @@
 	{
 		return ImmutableList.of(
 			"org.ultramine.server",
-			"org.ultramine.commands"
+			"org.ultramine.commands",
+			"org.ultramine.server.util"
 		);
 	}
 
diff --git a/src/main/java/org/ultramine/server/event/ForgeModIdMappingEvent.java b/src/main/java/org/ultramine/server/event/ForgeModIdMappingEvent.java
new file mode 100644
index 0000000..72447d1
--- /dev/null
+++ b/src/main/java/org/ultramine/server/event/ForgeModIdMappingEvent.java
@@ -0,0 +1,14 @@
+package org.ultramine.server.event;
+
+import cpw.mods.fml.common.event.FMLModIdMappingEvent;
+import cpw.mods.fml.common.eventhandler.Event;
+
+public class ForgeModIdMappingEvent extends Event
+{
+	public final FMLModIdMappingEvent e;
+	
+	public ForgeModIdMappingEvent(FMLModIdMappingEvent e)
+	{
+		this.e = e;
+	}
+}
diff --git a/src/main/java/org/ultramine/server/util/ItemStackComparator.java b/src/main/java/org/ultramine/server/util/ItemStackComparator.java
new file mode 100644
index 0000000..93c1cd2
--- /dev/null
+++ b/src/main/java/org/ultramine/server/util/ItemStackComparator.java
@@ -0,0 +1,17 @@
+package org.ultramine.server.util;
+
+import java.util.Comparator;
+
+import net.minecraft.item.ItemStack;
+
+public class ItemStackComparator implements Comparator<ItemStack>
+{
+	public static final ItemStackComparator INSTANCE = new ItemStackComparator();
+	
+	@Override
+	public int compare(ItemStack is1, ItemStack is2)
+	{
+		int c1 = is1.getItem().delegate.name().compareTo(is2.getItem().delegate.name());
+		return c1 != 0 ? c1 : Integer.compare(is1.getItemDamage(), is2.getItemDamage());
+	}
+}
diff --git a/src/main/java/org/ultramine/server/util/ItemStackHashMap.java b/src/main/java/org/ultramine/server/util/ItemStackHashMap.java
new file mode 100644
index 0000000..0f31993
--- /dev/null
+++ b/src/main/java/org/ultramine/server/util/ItemStackHashMap.java
@@ -0,0 +1,178 @@
+package org.ultramine.server.util;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+import org.ultramine.server.event.ForgeModIdMappingEvent;
+
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import gnu.trove.map.TIntObjectMap;
+import gnu.trove.map.hash.TIntObjectHashMap;
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.MinecraftForge;
+
+public class ItemStackHashMap<V> implements Map<ItemStack, V>
+{
+	private final Map<ItemStack, V> map = new TreeMap<ItemStack, V>(ItemStackComparator.INSTANCE);
+	private final TIntObjectMap<V> fastMap = new TIntObjectHashMap<V>();
+	private boolean hasWildcard = false;
+	
+	public ItemStackHashMap()
+	{
+		this(true);
+	}
+	
+	public ItemStackHashMap(boolean register)
+	{
+		if(register)
+			MinecraftForge.EVENT_BUS.register(this);
+	}
+	
+	public void remap()
+	{
+		fastMap.clear();
+		for(Map.Entry<ItemStack, V> ent : map.entrySet())
+			putToFastMap(ent.getKey(), ent.getValue());
+	}
+	
+	@SubscribeEvent
+	public void onForgeModIdMapping(ForgeModIdMappingEvent e)
+	{
+		remap();
+	}
+	
+	public void unregister()
+	{
+		MinecraftForge.EVENT_BUS.unregister(this);
+	}
+	
+	private V putToFastMap(ItemStack key, V value)
+	{
+		if(key.getItemDamage() == 32767)
+			hasWildcard = true;
+		return fastMap.put(Item.getIdFromItem(key.getItem()) | (key.getItemDamage() << 16), value);
+	}
+	
+	private V removeFastMap(ItemStack key)
+	{
+		return fastMap.remove(Item.getIdFromItem(key.getItem()) | (key.getItemDamage() << 16));
+	}
+	
+	public V get(int id, int meta)
+	{
+		V ret = fastMap.get(id | (meta << 16));
+		if(ret == null && hasWildcard)
+			ret = fastMap.get(id | (32767 << 16));
+		return ret;
+	}
+	
+	public V get(ItemStack key)
+	{
+		return get(Item.getIdFromItem(key.getItem()), key.getItemDamage());
+	}
+	
+	@Override
+	public V put(ItemStack key, V value)
+	{
+		map.put(key, value);
+		return putToFastMap(key, value);
+	}
+	
+	
+	
+	public V get(Item item, int meta)
+	{
+		return get(Item.getIdFromItem(item), meta);
+	}
+	
+	public V get(Block block, int meta)
+	{
+		return get(Block.getIdFromBlock(block), meta);
+	}
+	
+	public V put(Item item, int meta, V value)
+	{
+		return put(new ItemStack(item, 1, meta), value);
+	}
+	
+	public V put(Block block, int meta, V value)
+	{
+		return put(new ItemStack(block, 1, meta), value);
+	}
+	
+	@Override
+	public V get(Object key)
+	{
+		return get((ItemStack)key);
+	}
+	
+	@Override
+	public int size()
+	{
+		return map.size();
+	}
+	
+	@Override
+	public boolean isEmpty()
+	{
+		return map.isEmpty();
+	}
+	
+	@Override
+	public boolean containsKey(Object key)
+	{
+		return get(key) != null;
+	}
+	
+	@Override
+	public boolean containsValue(Object value)
+	{
+		return fastMap.containsValue(value);
+	}
+	
+	@Override
+	public V remove(Object key)
+	{
+		V val = removeFastMap((ItemStack)key);
+		if(val != null)
+			map.remove(key);
+		return val;
+	}
+	
+	@Override
+	public void putAll(Map<? extends ItemStack, ? extends V> m)
+	{
+		map.putAll(m);
+		for(Map.Entry<? extends ItemStack, ? extends V> ent : m.entrySet())
+			putToFastMap(ent.getKey(), ent.getValue());
+	}
+	
+	@Override
+	public void clear()
+	{
+		map.clear();
+		fastMap.clear();
+	}
+	
+	@Override
+	public Set<ItemStack> keySet()
+	{
+		return map.keySet();
+	}
+	
+	@Override
+	public Collection<V> values()
+	{
+		return map.values();
+	}
+	
+	@Override
+	public Set<java.util.Map.Entry<ItemStack, V>> entrySet()
+	{
+		return map.entrySet();
+	}
+}
diff --git a/src/main/java/org/ultramine/server/util/ItemStackHashSet.java b/src/main/java/org/ultramine/server/util/ItemStackHashSet.java
new file mode 100644
index 0000000..2760a6a
--- /dev/null
+++ b/src/main/java/org/ultramine/server/util/ItemStackHashSet.java
@@ -0,0 +1,194 @@
+package org.ultramine.server.util;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import org.ultramine.server.event.ForgeModIdMappingEvent;
+
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import gnu.trove.set.TIntSet;
+import gnu.trove.set.hash.TIntHashSet;
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.MinecraftForge;
+
+public class ItemStackHashSet implements Set<ItemStack>
+{
+	private final List<ItemStack> list = new ArrayList<ItemStack>();
+	private final TIntSet fastSet = new TIntHashSet();
+	private boolean hasWildcard = false;
+	
+	public ItemStackHashSet()
+	{
+		this(true);
+	}
+	
+	public ItemStackHashSet(boolean register)
+	{
+		if(register)
+			MinecraftForge.EVENT_BUS.register(this);
+	}
+	
+	public void remap()
+	{
+		fastSet.clear();
+		for(ItemStack is : list)
+			addToFastMap(is);
+	}
+	
+	@SubscribeEvent
+	public void onForgeModIdMapping(ForgeModIdMappingEvent e)
+	{
+		remap();
+	}
+	
+	public void unregister()
+	{
+		MinecraftForge.EVENT_BUS.unregister(this);
+	}
+	
+	private boolean addToFastMap(ItemStack is)
+	{
+		if(is.getItemDamage() == 32767)
+			hasWildcard = true;
+		return fastSet.add(Item.getIdFromItem(is.getItem()) | (is.getItemDamage() << 16));
+	}
+	
+	private boolean removeFastMap(ItemStack is)
+	{
+		return fastSet.remove(Item.getIdFromItem(is.getItem()) | (is.getItemDamage() << 16));
+	}
+	
+	public boolean contains(int id, int meta)
+	{
+		boolean ret = fastSet.contains(id | (meta << 16));
+		if(!ret && hasWildcard)
+			ret = fastSet.contains(id | (32767 << 16));
+		return ret;
+	}
+	
+	public boolean contains(ItemStack is)
+	{
+		return contains(Item.getIdFromItem(is.getItem()), is.getItemDamage());
+	}
+	
+	public boolean contains(Block block, int meta)
+	{
+		return contains(Block.getIdFromBlock(block));
+	}
+	
+	public boolean contains(Item item, int meta)
+	{
+		return contains(Item.getIdFromItem(item));
+	}
+	
+	@Override
+	public boolean add(ItemStack is)
+	{
+		boolean added = addToFastMap(is);
+		if(added)
+			list.add(is);
+		return added;
+	}
+	
+	public boolean add(Block block, int meta)
+	{
+		return add(new ItemStack(block, 1, meta));
+	}
+	
+	public boolean add(Item item, int meta)
+	{
+		return add(new ItemStack(item, 1, meta));
+	}
+	
+	@Override
+	public int size()
+	{
+		return list.size();
+	}
+
+	@Override
+	public boolean isEmpty()
+	{
+		return list.isEmpty();
+	}
+
+	@Override
+	public boolean contains(Object o)
+	{
+		return contains((ItemStack)o);
+	}
+
+	@Override
+	public Iterator<ItemStack> iterator()
+	{
+		return list.iterator();
+	}
+
+	@Override
+	public Object[] toArray()
+	{
+		return list.toArray();
+	}
+
+	@Override
+	public <T> T[] toArray(T[] a)
+	{
+		return list.toArray(a);
+	}
+
+	@Override
+	public boolean remove(Object o)
+	{
+		boolean removed = removeFastMap((ItemStack)o);
+		if(removed)
+			list.remove(o);
+		return removed;
+	}
+
+	@Override
+	public boolean containsAll(Collection<?> c)
+	{
+		if(c instanceof ItemStackHashSet)
+			return fastSet.containsAll(((ItemStackHashSet)c).fastSet);
+		for(Object o : c)
+			if(!contains(o))
+				return false;
+		return true;
+	}
+
+	@Override
+	public boolean addAll(Collection<? extends ItemStack> c)
+	{
+		boolean ret = false;
+		for(ItemStack is : c)
+			ret |= add(is);
+		return ret;
+	}
+
+	@Override
+	public boolean retainAll(Collection<?> c)
+	{
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	public boolean removeAll(Collection<?> c)
+	{
+		boolean ret = false;
+		for(Object is : c)
+			ret |= remove(is);
+		return ret;
+	}
+
+	@Override
+	public void clear()
+	{
+		list.clear();
+		fastSet.clear();
+	}
+}