patches.xml

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<mods>
	<coreMods praeSrg="true" onDemand="true">
		<class id="cpw.mods.fml.common.Loader">
			<addAll fromClass="nallar.patched.forge.PatchLoader"/>
			<replaceMethodCall method="info" index="0" code="{ }">loadMods</replaceMethodCall>
		</class>
		<class id="cpw.mods.fml.common.ModAPIManager">
			<replaceMethodCall method="info" index="0" code="{ }">registerDataTableAndParseAPI</replaceMethodCall>
		</class>
		<class id="cpw.mods.fml.common.LoadController">
			<replaceMethodCall method="log" index="1" code="{ }">buildModList</replaceMethodCall>
		</class>
	</coreMods>
	<theWarOnLogSpam onDemand="true">
		<class id="codechicken.microblock.MicroMaterialRegistry$">
			<replaceMethodCall method="println" index="1" code="{ }">registerMaterial</replaceMethodCall>
		</class>
		<class id="aroma1997.core.Aroma1997Core">
			<replaceMethodCall method="logServer" code="{ }">preInit,init,postInit,serverStartup,serverStartedUp</replaceMethodCall>
		</class>
		<class id="com.dmillerw.remoteIO.core.handler.PacketHandler">
			<replaceMethodCall method="info" code="{ }">sendConfigData</replaceMethodCall>
		</class>
		<class id="magicbees.world.feature.FeatureHive">
			<replaceFieldUsage field="logSpawns" writeCode="logSpawns = false;">^static^</replaceFieldUsage>
		</class>
		<class id="net.bdew.lib.recipes.gencfg.GenericConfigLoader$class">
			<replaceMethodCall method="info" code="{ }">processConfigStatement</replaceMethodCall>
		</class>
		<class id="codechicken.nei.NEIClientConfig">
			<replaceMethodCall method="println" code="{ }">bootNEI</replaceMethodCall>
		</class>
		<class id="codechicken.nei.NEIServerConfig">
			<replaceMethodCall method="println" code="{ }">loadPlayer,unloadPlayer</replaceMethodCall>
		</class>
		<class id="codechicken.nei.NEISPH">
			<replaceMethodCall method="println" code="{ }">sendHasServerSideTo</replaceMethodCall>
		</class>
		<class id="calclavia.components.CalclaviaLoader">
			<replaceMethodCall method="info" code="{ }">requireItem,requireBlock</replaceMethodCall>
		</class>
		<class id="denoflionsx.denLib.Mod.Handlers.NewDictHandler.DenLibDictionaryHandler">
			<replaceMethodCall method="log" code="{ }">doEvent</replaceMethodCall>
		</class>
		<class id="denoflionsx.denLib.Mod.Handlers.NewFluidHandler.DenLibFluidHandler">
			<replaceMethodCall method="log" code="{ }">onEvent</replaceMethodCall>
		</class>
		<class id="tconstruct.plugins.PluginController">
			<replaceMethodCall method="pConsole" code="{ }">^all^</replaceMethodCall>
		</class>
		<class id="mods.natura.plugins.PluginController">
			<replaceMethodCall method="info" code="{ }">^all^</replaceMethodCall>
		</class>
		<class id="Reika.GeoStrata.Guardian.GuardianStoneManager">
			<replaceMethodCall method="log" index="0" code="{ }">save,read</replaceMethodCall>
		</class>
		<class id="Reika.RotaryCraft.Auxiliary.RecipeManagers">
			<replaceMethodCall method="log" code="{ }">addOreRecipes</replaceMethodCall>
		</class>
		<class id="
		Reika.DragonAPI.Base.DragonAPIMod
		Reika.DragonAPI.Base.ModHandlerBase">
			<replaceMethodCall method="pConsole" code="{ }"/>
		</class>
		<class id="Reika.DragonAPI.Libraries.Java.ReikaObfuscationHelper">
			<replaceMethodCall method="pConsole" code="{ }">addField,addMethod</replaceMethodCall>
		</class>
		<class id="Reika.DragonAPI.Base.PlayerTracker">
			<replaceMethodCall method="pConsole" index="0" code="{ }">save,read</replaceMethodCall>
		</class>
		<class id="Reika.DragonAPI.ModList">
			<replaceMethodCall method="pConsole" index="0" code="{ }" silent="true"/>
			<replaceMethodCall method="pConsole" index="1" code="{ }" silent="true"/>
			<replaceMethodCall method="pConsole" index="2" code="{ }" silent="true"/>
		</class>
		<class id="Reika.DragonAPI.Libraries.Java.ReikaJavaLibrary">
			<newField static="" field="logger" class="java.util.logging.Logger" code="none"/>
			<final field="logger"/>
			<addStaticInitializer code="{
				logger = java.util.logging.Logger.getLogger(&quot;Dragon&quot;);
				logger.setParent(java.util.logging.Logger.getLogger(&quot;ForgeModLoader&quot;));
				logger.setUseParentHandlers(true);
			}"/>
			<replaceMethod code="{
				if ($1 == null) {
					logger.info(&quot;null passed to Reika pConsole&quot;);
				} else if ($1 instanceof String || $1 instanceof Integer || $1 instanceof Boolean) {
					logger.info(String.valueOf($1));
				} else {
					logger.info(String.valueOf($1) + &quot; of class &quot; + $1.getClass().getName());
				}
			}">pConsole(Ljava/lang/Object;)V
			</replaceMethod>
		</class>
	</theWarOnLogSpam>
	<tickthreading>
		<class id="nallar.tickthreading.minecraft.tickregion.TileEntityTickRegion">
			<lockToSynchronized>doTick</lockToSynchronized>
		</class>
		<class id="nallar.tickthreading.minecraft.TickManager">
			<lockToSynchronized>unlock,lock</lockToSynchronized>
		</class>
	</tickthreading>
	<minecraftCommon>
		<class id="net.minecraft.tileentity.TileEntityChest">
			<addAll fromClass="nallar.patched.PatchTileEntityNoLock"/>
		</class>
		<class id="net.minecraft.world.SpawnerAnimals" env="forge">
			<addAll fromClass="nallar.patched.PatchSpawnerAnimalsForge"/>
		</class>
		<class id="net.minecraft.world.SpawnerAnimals" env="mcpc">
			<synchronize>findChunksForSpawning</synchronize>
		</class>
		<class id="net.minecraft.world.SpawnerAnimals">
			<addAll fromClass="nallar.patched.PatchSpawnerAnimals"/>
			<profile>findChunksForSpawning</profile>
		</class>
		<class id="net.minecraft.world.storage.MapInfo">
			<synchronize>^all^</synchronize>
		</class>
		<class id="net.minecraft.pathfinding.Path">
			<newInitializer field="pathPoints" class="net.minecraft.pathfinding.PathPoint" arraySize="128"/>
		</class>
		<class id="net.minecraft.server.MinecraftServer">
			<addAll fromClass="nallar.patched.server.PatchMinecraftServer"/>
			<insertBefore code="{
				if (this.^field:MinecraftServer/serverStopped^) {
					return;
				}
				this.^field:MinecraftServer/serverStopped^ = true;
			}">stopServer
			</insertBefore>
			<synchronize>stopServer</synchronize>
			<public field="mcServer"/>
			<volatile field="serverRunning"/>
			<volatile field="serverIsRunning"/>
			<profile>runQueuedTasks</profile>
		</class>
		<class id="net.minecraft.server.MinecraftServer" env="mcpc">
			<replaceInitializer field="worlds" class="nallar.collections.ListSet"/>
			<replaceMethod code="{
						this.server.getScheduler().mainThreadHeartbeat(^field:MinecraftServer/tickCounter^);
					}">spigotTLETick
			</replaceMethod>
			<final field="processQueue"/>
			<replaceInitializer field="processQueue" code="$_ = runQueue;"/>
		</class>
		<class id="net.minecraft.server.MinecraftServer" env="forge">
			<addAll fromClass="nallar.patched.server.PatchMinecraftServerForge"/>
		</class>
		<class id="net.minecraft.profiler.Profiler">
			<addAll fromClass="nallar.patched.PatchProfiler"/>
		</class>
		<class id="net.minecraft.network.NetServerHandler">
			<addAll fromClass="nallar.patched.network.PatchNetServerHandler"/>
			<replaceMethodCall method="^class:ILogAgent^.^method:ILogAgent/logWarning^"
							   code="{ nallar.tickthreading.global.Redirects.notifyAdmins($1); }"
					>handleFlying
			</replaceMethodCall>
			<insertBefore code="if (nallar.tickthreading.global.Redirects.interceptPacket($1, this)) { return; }">
				sendPacketToPlayer
			</insertBefore>
		</class>
		<class id="net.minecraft.network.NetServerHandler" env="mcpc">
			<insertAfter code="handleTeleport($1.getX(), $1.getY(), $1.getZ());">teleport</insertAfter>
			<synchronize>teleport</synchronize>
		</class>
		<class id="net.minecraft.network.NetServerHandler" env="forge">
			<insertAfter code="handleTeleport($1, $2, $3);">setPlayerLocation</insertAfter>
			<synchronize>setPlayerLocation</synchronize>
		</class>
		<class id="net.minecraft.network.packet.Packet10Flying">
			<addAll fromClass="nallar.patched.network.PatchPacket10Flying"/>
		</class>
		<class id="net.minecraft.network.packet.Packet14BlockDig">
			<addAll fromClass="nallar.patched.network.PatchPacketAsync"/>
		</class>
		<class id="net.minecraft.network.packet.Packet51MapChunk">
			<volatile field="chunkData"/>
			<addAll fromClass="nallar.patched.network.PatchPacket51MapChunk"/>
			<threadLocal field="temp" type="byte[]"
						 threadLocalField="nallar.tickthreading.global.ThreadLocals.mapChunkTempByteArray">
				getMapChunkData
			</threadLocal>
			<synchronize field="$1">getMapChunkData</synchronize>
		</class>
		<class id="net.minecraft.network.packet.Packet56MapChunks">
			<volatile field="chunkDataBuffer"/>
		</class>
		<class id="net.minecraft.network.packet.Packet254ServerPing">
			<addAll fromClass="nallar.patched.network.PatchPacketAsync"/>
		</class>
		<class id="net.minecraft.network.NetworkListenThread">
			<synchronize>addPlayer,networkTick</synchronize>
			<profile>networkTick</profile>
		</class>
		<class id="net.minecraft.network.TcpWriterThread">
			<ignoreExceptions type="java.net.SocketException">run</ignoreExceptions>
		</class>
		<class id="net.minecraft.world.World">
			<addAll fromClass="nallar.patched.world.PatchWorld"/>
			<profile>updateEntities</profile>
			<profile>setActivePlayerChunksAndCheckLight</profile>
			<final field="worldAccesses"/>
			<final field="provider"/>
			<final field="theProfiler"/>
			<final field="playerEntities"/>
			<final field="isRemote"/>
			<public field="ambientTickCountdown"/>
			<public field="forcedChunks"/>
			<replaceInitializer field="playerEntities" class="java.util.concurrent.CopyOnWriteArrayList"/>
			<replaceInitializer field="weatherEffects" class="nallar.collections.SynchronizedList"/>
			<insertBefore code="if (preHandleSpawn($1)) { return false; }">spawnEntityInWorld</insertBefore>
		</class>
		<class id="net.minecraft.world.ChunkCache">
			<replaceMethodCall code="$_ = $0.getChunkIfExists($$);"
							   method="^class:World^.^method:World/getChunkFromChunkCoords^"/>
		</class>
		<class id="net.minecraft.world.NextTickListEntry">
			<newField static="" field="nextEntryID_" class="java.util.concurrent.atomic.AtomicLong"/>
			<insertAfter field="tickEntryID" code="this.$field = this.nextEntryID_.getAndIncrement();"/>
		</class>
		<class id="net.minecraft.world.WorldServer" env="forge">
			<removeInitializers field="pendingTickListEntriesHashSet"/>
			<removeInitializers field="pendingTickListEntriesTreeSet"/>
		</class>
		<class id="net.minecraft.world.WorldServer">
			<addAll fromClass="nallar.patched.world.PatchWorldServer"/>
			<profile>tickBlocksAndAmbiance</profile>
			<profile>tick</profile>
			<insertSuper>initialize</insertSuper>
		</class>
		<class id="net.minecraft.world.ServerBlockEventList">
			<public/>
		</class>
		<class id="net.minecraft.world.biome.BiomeDecorator">
			<synchronize>decorate(Lnet/minecraft/world/World;Ljava/util/Random;II)V</synchronize>
		</class>
		<class id="net.minecraft.world.biome.WorldChunkManager">
			<newField field="staticLock" class="java.lang.Object" static=""/>
			<!--<synchronize field="staticLock">getModdedBiomeGenerators</synchronize>-->
		</class>
		<class id="net.minecraft.world.biome.BiomeCache">
			<synchronize>getBiomeCacheBlock,cleanupCache</synchronize>
		</class>
		<class id="net.minecraft.world.gen.layer.IntCache">
			<replace class="nallar.patched.storage.IntCache"/>
		</class>
		<class id="net.minecraft.world.gen.structure.MapGenStructure">
			<replaceInitializer field="structureMap" class="java.util.concurrent.ConcurrentHashMap"/>
		</class>
		<class id="net.minecraft.world.gen.ChunkProviderServer">
			<replace class="nallar.patched.storage.ThreadedChunkProvider"/>
			<lockToSynchronized>getChunkAtInternal</lockToSynchronized>
			<profile>tick</profile>
		</class>
		<class id="net.minecraft.world.gen.ChunkProviderServer" env="mcpc">
			<replaceMethod code="{
				world.getServer().getPluginManager().callEvent(new org.bukkit.event.world.ChunkLoadEvent($1.bukkitChunk, $2));
			}
			">fireBukkitLoadEvent
			</replaceMethod>
			<replaceMethod code="{
				world.getServer().getPluginManager().callEvent(new org.bukkit.event.world.ChunkPopulateEvent($1.bukkitChunk));
			}
			">fireBukkitPopulateEvent
			</replaceMethod>
			<replaceMethod code="{
				org.bukkit.event.world.ChunkUnloadEvent event = new org.bukkit.event.world.ChunkUnloadEvent($1.bukkitChunk);
        world.getServer().getPluginManager().callEvent(event);

        return !event.isCancelled();
			}
			">fireBukkitUnloadEvent
			</replaceMethod>
		</class>
		<class id="org.bukkit.craftbukkit.v1_6_R3.chunkio.ChunkIOExecutor" env="mcpc">
			<replaceInitializer field="instance" code="$_ = null;"/>
			<replaceMethod code="throw new UnsupportedOperationException();">tick</replaceMethod>
			<disable>adjustPoolSize</disable>
			<replaceMethod
					code="return $3.getChunkAt($4, $5, true, false, null);">
				syncChunkLoad
			</replaceMethod>
			<replaceMethod code="$3.getChunkAt($4, $5, true, false, $6);">queueChunkLoad</replaceMethod>
		</class>
		<class id="net.minecraft.world.gen.ChunkProviderServer" env="mcpc">
			<changeFieldType field="chunksToUnload" type="org.bukkit.craftbukkit.v1_6_R3.util.LongHashSet"
							 remove="true"/>
			<insertAfter field="chunksToUnload" code="$field = new org.bukkit.craftbukkit.v1_6_R3.util.LongHashSet();"/>
		</class>
		<class id="net.minecraft.world.chunk.NibbleArray" env="forge">
			<addAll fromClass="nallar.patched.storage.PatchNibbleArrayForge"/>
		</class>
		<class id="net.minecraft.world.chunk.storage.RegionFileCache">
			<replaceMethod code="throw new UnsupportedOperationException();">createOrLoadRegionFile</replaceMethod>
		</class>
		<class id="net.minecraft.world.chunk.storage.AnvilChunkLoader">
			<replace class="nallar.patched.storage.ThreadedChunkLoader"/>
		</class>
		<class id="net.minecraft.world.chunk.storage.AnvilChunkLoaderPending">
			<addAll fromClass="nallar.patched.storage.PatchAnvilChunkLoaderPending"/>
		</class>
		<class id="net.minecraft.world.chunk.Chunk">
			<!-- The entity list could be accessed from multiple threads, as usual causes problems during iteration -->
			<addAll fromClass="nallar.patched.storage.PatchChunk"/>
			<final field="xPosition"/>
			<final field="zPosition"/>
			<final field="entityLists"/>
			<final field="worldObj"/>
			<final field="chunkTileEntityMap"/>
			<volatile field="isTerrainPopulated"/>
			<replaceInitializer field="chunkTileEntityMap" class="java.util.concurrent.ConcurrentHashMap"/>
			<!--
			Used to debug when mods are setting chunk.isModified when they shouldn't - for example, GregTech sets every chunk with a gregtech machine in as modified
			every tick. :(
			<replaceFieldUsage field="isModified" writeCode="$0.^field:Chunk/isModified^ = $1; if ($1 == true) { Thread.dumpStack(); }">^all^</replaceFieldUsage>
			-->
		</class>
		<class id="net.minecraft.world.chunk.EmptyChunk">
			<replaceMethod code="return 1;">getHeightValue</replaceMethod>
			<replaceMethod code="{ if ($2 == 0) { return 7; } return 0; }">getBlockID</replaceMethod>
		</class>
		<class id="net.minecraft.util.MathHelper">
			<final field="SIN_TABLE"/>
		</class>
		<class id="net.minecraft.util.Vec3Pool">
			<!-- This prevents entities in multiple threads using the same Vec3 for collisions. -->
			<replace class="nallar.patched.PatchVec3Pool"/>
		</class>
		<class id="net.minecraft.util.Vec3">
			<addAll fromClass="nallar.patched.PatchVec3"/>
		</class>
		<class id="net.minecraft.util.AABBPool">
			<!-- This prevents entities in multiple threads using the same Vec3 for collisions. -->
			<replace class="nallar.patched.PatchAABBPool"/>
		</class>
		<class id="net.minecraft.util.AxisAlignedBB">
			<!-- Improves performance -->
			<addAll fromClass="nallar.patched.PatchAxisAlignedBB"/>
			<removeFieldAndInitializers field="theAABBLocalPool"/>
			<replaceMethod code="return aabbPool;">getAABBPool</replaceMethod>
		</class>
		<class id="net.minecraft.util.LongHashMap">
			<replace class="nallar.patched.collection.PatchLongHashMap"/>
		</class>
		<class id="net.minecraft.util.IntHashMap">
			<replace class="nallar.patched.collection.PatchIntHashMap"/>
		</class>
		<class id="net.minecraft.entity.DataWatcher">
			<replace class="nallar.patched.entity.PatchDataWatcher"/>
		</class>
		<class id="net.minecraft.entity.passive.EntitySquid" env="forge">
			<!-- This patch is already included in MCPC+ as it's in Spigot -->
			<removeMethod>isInWater</removeMethod>
		</class>
		<class id="net.minecraft.entity.player.EntityPlayerMP">
			<addAll fromClass="nallar.patched.entity.PatchEntityPlayerMP"/>
			<!-- Concurrent access during iteration = boom -->
			<replaceInitializer field="destroyedItemsNetCache" class="nallar.collections.ConcurrentQueueList"/>
			<replaceInitializer field="loadedChunks" class="nallar.collections.ConcurrentQueueList"/>
		</class>
		<class id="net.minecraft.entity.player.EntityPlayerMP" env="forge">
			<addAll fromClass="nallar.patched.entity.PatchEntityPlayerMPForge"/>
		</class>
		<class id="net.minecraft.nbt.CompressedStreamTools">
			<addAll fromClass="nallar.patched.nbt.PatchCompressedStreamTools"/>
		</class>
		<class id="net.minecraft.nbt.NBTBase">
			<replaceMethod code="{
				byte id = $1.^method:NBTBase/getId^();
				$2.writeByte(id);

				if (id != 0) {
					$2.writeUTF($1.^method:NBTBase/getName^());
					if (id == 10) {
						synchronized ($1) {
							$1.^method:NBTBase/write^($2);
						}
					} else {
						$1.^method:NBTBase/write^($2);
					}
				}
			}">writeNamedTag
			</replaceMethod>
		</class>
		<class id="net.minecraft.nbt.NBTBase">
			<addAll fromClass="nallar.patched.nbt.PatchNBTBase"/>
		</class>
		<class id="net.minecraft.nbt.NBTTagCompound">
			<addAll fromClass="nallar.patched.nbt.PatchNBTTagCompound"/>
			<replaceInitializer field="tagMap" class="nallar.collections.PartiallySynchronizedMap"/>
		</class>
		<class id="net.minecraft.entity.Entity">
			<addAll fromClass="nallar.patched.entity.PatchEntity"/>
		</class>
		<class id="net.minecraft.entity.Entity">
			<final field="rand"/>
			<newField static="" field="nextEntityID_" class="java.util.concurrent.atomic.AtomicInteger"/>
			<insertAfter field="entityId" code="this.$field = this.nextEntityID_.getAndIncrement();"/>
			<insertBefore code="if ($1 == 0 &amp;&amp; $2 == 0 &amp;&amp; $3 == 0) { return; }">moveEntity
			</insertBefore>
		</class>
		<class id="net.minecraft.entity.EntityLiving">
			<addAll fromClass="nallar.patched.entity.PatchEntityLiving"/>
			<insertSuper>onLivingUpdate</insertSuper>
		</class>
		<class id="net.minecraft.entity.EntityLivingBase">
			<addAll fromClass="nallar.patched.entity.PatchEntityLivingBase"/>
		</class>
		<class id="net.minecraft.entity.item.EntityItem">
			<addAll fromClass="nallar.patched.entity.PatchEntityItem"/>
			<insertSuper>onUpdate</insertSuper>
		</class>
		<class id="net.minecraft.entity.item.EntityXPOrb">
			<addAll fromClass="nallar.patched.entity.PatchEntityXPOrb"/>
		</class>
		<class id="net.minecraft.tileentity.TileEntity">
			<addAll fromClass="nallar.patched.PatchTileEntity"/>
		</class>
		<class id="net.minecraft.entity.EntityTrackerEntry" env="mcpc">
			<removeUntilOpcode index="-2" opcode="ATHROW">tryStartWachingThis,removePlayerFromTracker
			</removeUntilOpcode>
		</class>
		<class id="net.minecraft.entity.EntityTracker" env="mcpc">
			<removeUntilOpcode index="-2" opcode="ATHROW">
				removeEntityFromAllTrackingPlayers,addEntityToTracker(Lnet/minecraft/entity/Entity;IIZ)V
			</removeUntilOpcode>
		</class>
		<class id="net.minecraft.entity.EntityTracker">
			<!-- Yet more comodification exceptions -->
			<addAll fromClass="nallar.patched.entity.PatchEntityTracker"/>
			<newField field="readWriteLock" class="nallar.tickthreading.util.concurrent.TwoWayReentrantReadWriteLock"/>
			<newField field="writeLock" class="java.util.concurrent.locks.Lock" code="this.readWriteLock.writeLock();"/>
			<newField field="readLock" class="java.util.concurrent.locks.Lock" code="this.readWriteLock.readLock();"/>
			<lock field="writeLock">
				addEntityToTracker(Lnet/minecraft/entity/Entity;)V,addEntityToTracker(Lnet/minecraft/entity/Entity;IIZ)V,removeEntityFromAllTrackingPlayers
			</lock>
			<lock field="readLock">updateTrackedEntities,removePlayerFromTrackers,func_85172_a</lock>
		</class>
		<class id="net.minecraft.village.Village">
			<addAll fromClass="nallar.patched.PatchVillage"/>
		</class>
		<class id="net.minecraft.village.VillageCollection">
			<addAll fromClass="nallar.patched.collection.PatchVillageCollection"/>
			<!-- Literally the most useless collection. Locking instead of voiding in case it ever does something useful in future -->
			<newField field="readWriteLock" class="nallar.tickthreading.util.concurrent.TwoWayReentrantReadWriteLock"/>
			<newField field="writeLock" class="java.util.concurrent.locks.Lock" code="this.readWriteLock.writeLock();"/>
			<newField field="readLock" class="java.util.concurrent.locks.Lock" code="this.readWriteLock.readLock();"/>
			<lock field="writeLock">addVillagerPosition</lock>
			<lock field="readLock">findNearestVillage,func_82566_a</lock>
		</class>
		<class id="net.minecraft.server.dedicated.DedicatedServerSleepThread">
			<disable>run</disable>
		</class>
		<class id="net.minecraft.server.management.ServerConfigurationManager">
			<addAll fromClass="nallar.patched.server.PatchServerConfigurationManager"/>
			<newField field="readWriteLock" class="nallar.tickthreading.util.concurrent.TwoWayReentrantReadWriteLock"/>
			<newField field="playersUpdateLock" class="java.util.concurrent.locks.Lock"
					  code="this.readWriteLock.writeLock();"/>
			<newField field="playerUpdateLock" class="java.util.concurrent.locks.Lock"
					  code="this.readWriteLock.readLock();"/>
			<lock field="playerUpdateLock">createPlayerForUser,sendPacketToAllPlayers,sendPlayerInfoToAllPlayers</lock>
			<lock field="playerUpdateLock">
				sendPacketToAllPlayersInDimension,getPlayerListAsString,getAllUsernames,getPlayerForUsername,findPlayers,sendToAllNearExcept
			</lock>
			<lock field="playerUpdateLock">saveAllPlayerData,getPlayerList</lock>
			<replaceInitializer field="playerEntityList" class="nallar.collections.LockArrayList"/>
			<insertAfter
					code="((nallar.collections.LockArrayList)^field:ServerConfigurationManager/playerEntityList^).lock = playersUpdateLock;"/>
			<synchronize field="$1.playerNetServerHandler">respawnPlayer</synchronize>
			<synchronize field="$1.^field:EntityPlayerMP/playerNetServerHandler^">
				transferPlayerToDimension(L^class:EntityPlayerMP^;IL^class:Teleporter^;)V
			</synchronize>
		</class>
		<class id="net.minecraft.server.management.ServerConfigurationManager" env="forge">
			<addAll fromClass="nallar.patched.server.PatchServerConfigurationManagerForge"/>
		</class>
		<class id="net.minecraft.server.management.PlayerManager">
			<addAll fromClass="nallar.patched.world.tracking.PatchPlayerManager"/>
			<replaceMethodCall method="sort" index="1" code="{ }">updateMountedMovingPlayer</replaceMethodCall>
			<synchronize>addPlayer,removePlayer</synchronize>
			<synchronize field="$1.loadedChunks">addPlayer,removePlayer,filterChunkLoadQueue</synchronize>
			<synchronize field="$1.loadedChunks">updateMountedMovingPlayer</synchronize>
			<profile>updatePlayerInstances</profile>
		</class>
		<class id="net.minecraft.server.management.PlayerInstance" env="forge">
			<replaceMethodCall method="^class:ChunkProviderServer^.^method:ChunkProviderServer/loadChunk^"
							   code="{ $_ = null; }"/>
		</class>
		<class id="net.minecraft.server.management.PlayerInstance">
			<replaceInitializer field="playersInChunk" code="$_ = Collections.synchronizedList(new ArrayList());"/>
			<replaceMethodCall method="^class:PlayerManager^.^method:PlayerManager/getWorldServer^" removeAfter="true"/>
			<addAll fromClass="nallar.patched.world.tracking.PatchPlayerInstance"/>
			<public field="loaded"/>
			<final field="chunkLocation"/>
		</class>
		<class id="net.minecraft.world.ChunkCoordIntPair">
			<addAll fromClass="nallar.patched.storage.PatchChunkCoordIntPair"/>
			<public field="chunkXPos"/>
			<public field="chunkZPos"/>
			<noFinal field="chunkXPos"/>
			<noFinal field="chunkZPos"/>
		</class>
		<class id="net.minecraft.world.Teleporter">
			<replaceMethodCall newMethod="getTEWithLoad" method="^class:WorldServer^.^method:World/getBlockTileEntity^">
				^all^
			</replaceMethodCall>
			<replaceMethodCall newMethod="getBlockIdWithLoad" method="^class:WorldServer^.^method:World/getBlockId^">
				^all^
			</replaceMethodCall>
		</class>
		<class id="net.minecraft.crash.CrashReport">
			<addAll fromClass="nallar.patched.server.PatchCrashReport"/>
		</class>
		<class id="net.minecraft.block.BlockRedstoneTorch">
			<addAll fromClass="nallar.patched.block.PatchBlockRedstoneTorch"/>
		</class>
		<class id="net.minecraft.block.BlockRedstoneWire">
			<synchronize>calculateCurrentChanges,updateAndPropagateCurrentStrength</synchronize>
		</class>
		<class id="net.minecraft.block.BlockFlowing">
			<!--
				TODO: Make this cleaner once it's possible to access method parameters while replacing a MethodCall expression.
				See https://issues.jboss.org/browse/JASSIST-197
			-->
			<replaceMethodCall
					code="if (((org.bukkit.craftbukkit.v1_6_R3.CraftWorld) ((org.bukkit.event.block.BlockEvent) $1).getBlock().getWorld()).getHandle().safeToGenerate()) { $0.callEvent($$); }"
					method="callEvent">updateTick
			</replaceMethodCall>
		</class>
		<class id="net.minecraft.network.TcpConnection">
			<addAll fromClass="nallar.patched.network.PatchTcpConnection"/>
		</class>
		<class id="net.minecraft.network.TcpReaderThread">
			<replace class="nallar.patched.network.ReplaceTcpReaderThread"/>
		</class>
		<class id="net.minecraft.entity.ai.EntityAITasks">
			<synchronize>addTask,func_85156_a,onUpdateTasks,func_75775_b</synchronize>
		</class>
		<class id="net.minecraft.world.World" env="mcpc">
			<removeUntilOpcode index="-2" opcode="ATHROW">addEntity,removePlayerEntityDangerously</removeUntilOpcode>
		</class>
		<class id="net.minecraft.server.gui.TextAreaLogHandler">
			<synchronize>publish</synchronize>
		</class>
		<!--suppress DeprecatedClassUsageInspection -->
		<class id="net.minecraftforge.liquids.LiquidTank">
			<synchronize/>
		</class>
		<class id="net.minecraftforge.common.DimensionManager">
			<addAll fromClass="nallar.patched.forge.PatchDimensionManager"/>
			<synchronize field="unloadQueue">unloadWorld</synchronize>
			<insertBefore code="if (getWorld($1) != null) { return; }">initDimension</insertBefore>
			<synchronize>unloadWorlds,initDimension,setWorld</synchronize>
			<insertAfter code="if ($2 != null) { $2.setDimension($1); }">setWorld</insertAfter>
		</class>
		<class id="net.minecraftforge.common.DimensionManager" env="mcpc">
			<replaceMethod code="{
				org.bukkit.event.world.WorldUnloadEvent e = new org.bukkit.event.world.WorldUnloadEvent($1.getWorld());
				org.bukkit.Bukkit.getServer().getPluginManager().callEvent(e);
				return e.isCancelled();
			}
			">fireBukkitWorldUnload
			</replaceMethod>
			<replaceMethod code="{
				org.bukkit.Bukkit.getServer().getPluginManager().callEvent(new org.bukkit.event.world.WorldSaveEvent($1.getWorld()));
			}
			">fireBukkitWorldSave
			</replaceMethod>
			<replaceMethod code="{
				java.lang.reflect.Field field = org.bukkit.Bukkit.getServer().getClass().getDeclaredField(&quot;worlds&quot;);
				field.setAccessible(true);
				((java.util.Map) field.get(org.bukkit.Bukkit.getServer())).values().remove($1.getWorld());
			}
			">removeBukkitWorld
			</replaceMethod>
			<removeUntilOpcode opcode="return" index="1">initDimension</removeUntilOpcode>
		</class>
	</minecraftCommon>
	<bukkit>
		<class id="org.bukkit.plugin.SimplePluginManager">
			<synchronize>
				subscribeToPermission,unsubscribeFromPermission,subscribeToDefaultPerms,unsubscribeFromDefaultPerms,getPermissionSubscriptions,getDefaultPermSubscriptions
			</synchronize>
			<replaceMethod code="{ fireEvent($$); }">callEvent</replaceMethod>
		</class>
		<class id="org.bukkit.craftbukkit.v1_6_R3.CraftServer">
			<replaceMethodCall method="registerDimension" code="{ }">
				createWorld(Lorg.bukkit.WorldCreator;)Lorg.bukkit.World;
			</replaceMethodCall>
			<replaceMethodCall method="addMVDimension" code="{ }">
				createWorld(Lorg.bukkit.WorldCreator;)Lorg.bukkit.World;
			</replaceMethodCall>
			<ignoreExceptions
					code="System.err.println(&quot;Loading world failed&quot; + $e); $e.printStackTrace(); throw new java.lang.Error($e);">
				createWorld(Lorg.bukkit.WorldCreator;)Lorg.bukkit.World;
			</ignoreExceptions>
			<replaceMethod code="{
				return net.minecraftforge.common.DimensionManager.unloadWorld(((org.bukkit.craftbukkit.v1_6_R3.CraftWorld) $1).getHandle(), $2);
			}">unloadWorld(Lorg.bukkit.World;Z)V
			</replaceMethod>
		</class>
		<class id="org.bukkit.craftbukkit.v1_6_R3.entity.CraftPlayer">
			<removeUntilOpcode index="-2" opcode="ATHROW">kickPlayer</removeUntilOpcode>
		</class>
		<class id="org.bukkit.craftbukkit.v1_6_R3.CraftWorld">
			<removeUntilOpcode index="-2" opcode="ATHROW">unloadChunkRequest,unloadChunk,loadChunk</removeUntilOpcode>
			<replaceMethod
					code=" {
							Object[] chunks = world.getChunks();
							org.bukkit.Chunk[] craftChunks = new org.bukkit.Chunk[chunks.length];
							for (int i = 0; i &lt; craftChunks.length; i++) {
								craftChunks[i] = ((^class:Chunk^) chunks[i]).bukkitChunk;
							}
							return craftChunks;
							} "
					>getLoadedChunks
			</replaceMethod>
			<replaceFieldUsage class="^class:WorldServer^" field="^field:World/loadedEntityList^"
							   readCode="$_ = world.getEntities();">
				getLivingEntities,getEntities,getEntitiesByClass(Ljava.lang.Class;)Ljava.util.Collection;,getEntitiesByClasses
			</replaceFieldUsage>
			<replaceFieldUsage class="^class:WorldServer^" field="^field:World/loadedEntityList^"
							   readCode="$_ = world.getPlayerEntities();">getPlayers
			</replaceFieldUsage>
			<replaceMethod
					code=" {
								return world.^field:WorldServer/theChunkProviderServer^.getChunkAt($1, $2, $3, null) != null;
							} "
					>loadChunk(IIZ)Z
			</replaceMethod>
			<replaceMethod
					code=" {
								if ($4 &amp;&amp; isChunkInUse($1, $2)) {
										return false;
								}

								world.^field:WorldServer/theChunkProviderServer^.unloadChunkImmediately($1, $2, $3);

								return true;
							} "
					>unloadChunk(IIZZ)Z
			</replaceMethod>
			<replaceMethod
					code=" {
								world.^field:WorldServer/theChunkProviderServer^.regenerateChunk($1, $2);

								refreshChunk($1, $2);

								return true;
							} "
					>regenerateChunk
			</replaceMethod>
			<replaceMethod code="throw new UnsupportedOperationException(&quot;Not threadsafe.&quot;);">
				chunkLoadPostProcess
			</replaceMethod>
			<disable>processChunkGC</disable>
		</class>
	</bukkit>
	<spigot>
		<class id="org.bukkit.craftbukkit.v1_6_R3.util.WatchdogThread">
			<disable>run</disable>
		</class>
	</spigot>
	<forge>
		<class id="net.minecraftforge.common.Configuration">
			<addAll fromClass="nallar.patched.forge.PatchConfiguration"/>
		</class>
		<class id="net.minecraftforge.common.ConfigCategory">
			<addAll fromClass="nallar.patched.forge.PatchConfigCategory"/>
		</class>
		<class id="net.minecraftforge.event.Event">
			<final field="listeners"/>
			<removeFieldAndInitializers field="annotationMap" silent="true"/>
			<addAll fromClass="nallar.patched.forge.PatchEvent"/>
		</class>
		<class id="net.minecraftforge.common.ForgeChunkManager$Ticket">
			<public all="true"/>
		</class>
		<class id="net.minecraftforge.common.ForgeChunkManager" env="mcpc">
			<removeFieldAndInitializers field="forcedChunks" silent="true"/>
		</class>
		<class id="net.minecraftforge.common.ForgeChunkManager">
			<addAll fromClass="nallar.patched.forge.PatchForgeChunkManager"/>
		</class>
	</forge>
	<forgeModLoader>
		<class id="cpw.mods.fml.common.registry.GameRegistry">
			<addAll fromClass="nallar.patched.forge.PatchGameRegistry"/>
		</class>
		<class id="cpw.mods.fml.common.registry.TickRegistry">
			<addAll fromClass="nallar.patched.forge.PatchTickRegistry"/>
		</class>
		<class id="cpw.mods.fml.relauncher.FMLLogFormatter">
			<replace class="nallar.tickthreading.LogFormatter"/>
		</class>
		<class id="cpw.mods.fml.common.event.FMLInterModComms$IMCMessage">
			<addAll fromClass="nallar.patched.forge.PatchIMCMessage"/>
		</class>
		<class id="cpw.mods.fml.common.Loader$ModIdComparator">
			<public/>
		</class>
		<class id="cpw.mods.fml.common.asm.FMLSanityChecker">
			<replaceMethodCall code="{ $_ = null; }" method="severe">call</replaceMethodCall>
		</class>
		<class id="cpw.mods.fml.common.FMLModContainer">
			<replaceMethodCall index="0" code="{ $_ = null; }" method="log">constructMod</replaceMethodCall>
			<replaceFieldUsage field="fingerprintNotPresent" readCode="$_ = false;">constructMod</replaceFieldUsage>
		</class>
		<class id="cpw.mods.fml.common.registry.BlockTracker">
			<synchronize>getNextBlockId,doReserveId</synchronize>
		</class>
		<class id="cpw.mods.fml.common.FMLCommonHandler">
			<addAll fromClass="nallar.patched.forge.PatchFMLCommonHandler"/>
			<profile>onPreServerTick,onPostServerTick,onPreWorldTick,onPostWorldTick</profile>
		</class>
		<class id="cpw.mods.fml.common.network.PacketDispatcher">
			<addAll fromClass="nallar.patched.forge.PatchPacketDispatcher"/>
		</class>
		<class id="cpw.mods.fml.common.network.ModListResponsePacket">
			<replaceMethodCall index="2" code="{ $_ = null; }" method="info">execute</replaceMethodCall>
		</class>
	</forgeModLoader>
	<factorization>
		<class id="factorization.weird.TileEntityBarrel">
			<replaceMethod code="{
				^class:ItemStack^ i = this.item;
				if (i == null) {
					return 0;
				}
				^class:ItemStack^ top = this.topStack;
				^class:ItemStack^ b = this.bottomStack;
				if ((top == null) || (!itemMatch(top))) {
					top = i.^method:ItemStack/copy^();
					top.^field:ItemStack/stackSize^ = 0;
					this.topStack = top;
				}
				if ((b == null) || (!itemMatch(b))) {
					b = i.^method:ItemStack/copy^();
					b.^field:ItemStack/stackSize^ = 0;
					this.bottomStack = b;
				}
				return top.^field:ItemStack/stackSize^ + this.middleCount + b.^field:ItemStack/stackSize^;
			}">getItemCount
			</replaceMethod>
			<synchronize>updateStacks,changeItemCount,setItemCount,a(IL^class:ItemStack^;)V</synchronize>
		</class>
		<class id="factorization.charge.TileEntityMirror">
			<replaceMethod code="{
				this.next_check = (300 + rand.nextInt(60));
			}">setNextCheck
			</replaceMethod>
		</class>
		<class id="factorization.wrath.TileEntityRouter">
			<newField field="emptyUpdateCount" class="int" code="0" static=""/>
			<replaceMethod code="{
				if (this.^field:TileEntity/worldObj^.^method:World/isBlockGettingPowered^(this.^field:TileEntity/xCoord^, this.^field:TileEntity/yCoord^, this.^field:TileEntity/zCoord^)) {
					return false;
				}
				if (this.is_input) {
					return this.buffer != null;
				}
				if (this.buffer == null) {
					return ++emptyUpdateCount % 5 == 0;
				}

				return this.buffer.^field:ItemStack/stackSize^ &lt; this.buffer.^method:ItemStack/getMaxStackSize^();
			}">shouldUpdate
			</replaceMethod>
		</class>
		<class id="factorization.charge.TileEntitySolarTurbine">
			<synchronize>addReflector</synchronize>
		</class>
		<class id="factorization.wrath.TileEntityWrathLamp">
			<replaceInitializer field="airToUpdate" class="nallar.collections.SynchronizedPriorityQueue">^static^
			</replaceInitializer>
			<threadLocal field="toVisit" type="java.util.HashSet"
						 threadLocalField="nallar.tickthreading.global.ThreadLocals.factorizationFindLightAirParentToVisit"/>
			<replaceMethodCall code="$_ = $0.getChunkFromBlockCoordsIfExists($$);"
							   method="^class:World^.^method:World/getChunkFromBlockCoords^">findLightAirParent
			</replaceMethodCall>
		</class>
		<class id="factorization.api.Charge">
			<newField field="staticLock" class="java.lang.Object" static=""/>
			<synchronize field="staticLock">update</synchronize>
		</class>
	</factorization>
	<liteLoader>
		<class id="com.mumfrey.liteloader.core.HookProfiler">
			<!-- LiteLoader makes the profiler not threadsafe - I may look into patching this better in future, but TT isn't really intended for clients -->
			<synchronize>a(Ljava/lang/String;)V,b()V</synchronize>
		</class>
	</liteLoader>
	<buildCraftCore>
		<class id="buildcraft.core.EntityRobot">
			<synchronize>build</synchronize>
		</class>
	</buildCraftCore>
	<buildCraftFactory>
		<class id="buildcraft.BuildCraftFactory$QuarryChunkloadCallback">
			<replaceMethodCall newMethod="getTEWithLoad" method="^class:World^.^method:World/getBlockTileEntity^">
				ticketsLoaded(Ljava.util.List;L^class:World^;)V
			</replaceMethodCall>
			<replaceMethodCall newMethod="getBlockIdWithLoad" method="^class:World^.^method:World/getBlockId^">
				ticketsLoaded(Ljava.util.List;L^class:World^;I)Ljava.util.List;
			</replaceMethodCall>
		</class>
	</buildCraftFactory>
	<thermalExpansionPlugins>
		<class id="thermalexpansion.plugins.cc.TurtleWrench">
			<ignoreExceptions type="java.lang.NullPointerException" code="return false;">attack</ignoreExceptions>
		</class>
	</thermalExpansionPlugins>
	<thermalExpansionTransport>
		<class id="thermalexpansion.block.conduit.TileConduitEnergy">
			<newField field="tickLock" class="java.lang.Object" static=""/>
			<synchronize field="tickLock">updateGridIfNull</synchronize>
		</class>
		<class id="thermalexpansion.block.conduit.TileConduitLiquid">
			<newField field="tickLock" class="java.lang.Object" static=""/>
			<synchronize field="tickLock">updateGridIfNull</synchronize>
		</class>
		<class id="thermalexpansion.block.conduit.GridLiquid">
			<synchronize>
				transferLiquid,removeNode,removeConduit,setNewGrid,changeMode,increaseTracker,addNode,addConduit
			</synchronize>
			<replaceMethod code="{
				int n = this.conduitList.size() + this.outputList.size() + this.inputList.size();
				if (n &lt; 1) {
					n = 1;
				}
				int a = getLiquidAmount();
				return isFirst($1) ? (a / n + a % n) : (a / n);
			}">getSharedAmount
			</replaceMethod>
		</class>
		<class id="thermalexpansion.block.conduit.GridEnergy">
			<synchronize>
				transferEnergy,removeNode,removeConduit,setNewGrid,changeMode,increaseTracker,addNode,addConduit
			</synchronize>
		</class>
	</thermalExpansionTransport>
	<thremalExpansionFactory>
		<class id="thermalexpansion.block.device.TileTankPortable">
			<replaceMethod code="{
				if (this.myTank.getLiquidAmount() &lt;= 0) {
					return;
				}

				int[] coords = cofh.util.BlockUtils.getAdjacentCoordinatesForSide(this.^field:TileEntity/xCoord^, this.^field:TileEntity/yCoord^, this.^field:TileEntity/zCoord^, 0);

				^class:TileEntity^ theTile = this.^field:TileEntity/worldObj^.^method:World/getBlockTileEntity^(coords[0], coords[1], coords[2]);
				if (theTile instanceof net.minecraftforge.liquids.ITankContainer) {
					if (theTile instanceof thermalexpansion.block.device.TileTankPortable &amp;&amp;
							!((((thermalexpansion.block.device.TileTankPortable)theTile).myTank.getLiquidID() &lt;= 0) ||
							(((thermalexpansion.block.device.TileTankPortable)theTile).myTank.getLiquidAmount() != 8000))) {
						return;
					}
					int fillQty = Math.min(this.myTank.getLiquidAmount(), 250);
					int quantity = ((net.minecraftforge.liquids.ITankContainer)theTile).fill(net.minecraftforge.common.ForgeDirection.UP, new net.minecraftforge.liquids.LiquidStack(this.myTank.getLiquidID(), fillQty, this.myTank.getLiquidMeta()), true);
					if (quantity &gt; 0) {
						this.myTank.drain(quantity, true);
					}
				}
			}">transferLiquid
			</replaceMethod>
		</class>
	</thremalExpansionFactory>
	<industrialCraft>
		<class id="ic2.core.IC2">
			<synchronize>addSingleTickCallback</synchronize>
		</class>
		<class id="ic2.core.ExplosionIC2">
			<synchronize>doExplosion</synchronize>
		</class>
		<class id="ic2.core.block.wiring.TileEntityElectricBlock">
			<replaceMethodCall method="self.^method:TileEntity/onInventoryChanged^" code="{ }">
				^method:TileEntity/updateEntity^
			</replaceMethodCall>
		</class>
	</industrialCraft>
	<gregTech>
		<class id="gregtechmod.api.GregTech_API">
			<replaceNew oldClass="java.util.HashMap" newClass="nallar.collections.CHashMap"/>
		</class>
		<class id="gregtechmod.GT_Mod">
			<synchronize>readIDSUData,writeIDSUData</synchronize>
		</class>
		<class id="gregtechmod.common.tileentities.GT_TileEntityMetaID_Machine">
			<replaceMethodCall method="self.^method:TileEntity/onInventoryChanged^" code="{ }">
				^method:TileEntity/updateEntity^
			</replaceMethodCall>
		</class>
		<class id="gregtechmod.common.tileentities.GT_TileEntity_IDSU">
			<replaceMethodCall method="remove" code="{ $_ = null; }">setEnergyVar</replaceMethodCall>
		</class>
		<class id="gregtechmod.api.metatileentity.MetaTileEntity">
			<unvolatile field="VERSION"/>
			<final field="VERSION"/>
		</class>
		<class id="gregtechmod.api.metatileentity.BaseMetaTileEntity">
			<replaceFieldUsage field="mAverageEUInputIndex"
							   writeCode="mAverageEUInputIndex = $1 >= mAverageEUInput.length ? 0 : $1;">
				^method:TileEntity/updateEntity^
			</replaceFieldUsage>
			<replaceFieldUsage field="mAverageEUOutputIndex"
							   writeCode="mAverageEUOutputIndex = $1 >= mAverageEUOutput.length ? 0 : $1;">
				^method:TileEntity/updateEntity^
			</replaceFieldUsage>
			<replaceMethod code="{
				gregtechmod.api.metatileentity.MetaTileEntity m = mMetaTileEntity;
				return m != null &amp;&amp; m.getBaseMetaTileEntity() == this;
			}">hasValidMetaTileEntity
			</replaceMethod>
		</class>
		<class id="gregtechmod.api.metatileentity.BaseMetaTileEntityMJ" srg="true">
			<replaceMethod code="{
				if (hasMJConverterUpgrade()) {
					buildcraft.api.power.IPowerProvider p = mProvider;
					if (p == null) {
						synchronized(this) {
							p = mProvider;
							if (p == null) {
								p = buildcraft.api.power.PowerFramework.currentFramework.createPowerProvider();
								mProvider = p;
								p.configure(100, 1, 100, 1, 10000);
							}
						}
					}
					else {
						int c = getMJCapacity();
						if (c > 0) {
							int s = getStoredMJ();
							if (s &lt; c) {
								increaseStoredMJ((int)p.useEnergy(1.0F, (float) c - s, true), true);
							}
						}
					}
      	}
			}">updateStatus
			</replaceMethod>
			<replaceMethod code="{
				buildcraft.api.power.IPowerProvider powerProvider = getPowerProvider();
				if (powerProvider == null) {
					return 0;
				}
				return Math.min(powerProvider.getMaxEnergyReceived(), (int) (powerProvider.getMaxEnergyStored() - powerProvider.getEnergyStored() + 0.5f));
			}">powerRequest
			</replaceMethod>
		</class>
	</gregTech>
	<chickenChunks>
		<class id="codechicken.chunkloader.ChunkLoaderManager">
			<disable>cleanChunks</disable>
			<disable>tickEnd</disable>
			<newMethod code="
			public static void serverTick() {
        if (^class:MinecraftServer^.^method:MinecraftServer/getServer^().currentTick % 1200 == 0) {
        	updateLoginTimes();
        }
      	tickDownUnloads();
      	revivePlayerLoaders();
			}
			"/>
			<replaceMethodCall newMethod="getTEWithLoad" method="^class:World^.^method:World/getBlockTileEntity^">
				^all^
			</replaceMethodCall>
			<replaceMethodCall newMethod="getBlockIdWithLoad" method="^class:World^.^method:World/getBlockId^">^all^
			</replaceMethodCall>
		</class>
		<class id="codechicken.chunkloader.ChunkLoaderEventHandler">
			<replaceMethod
					code="return java.util.EnumSet.of(cpw.mods.fml.common.TickType.SERVER, cpw.mods.fml.common.TickType.WORLD);">
				ticks
			</replaceMethod>
			<replaceMethod code="{
			if($1.contains(cpw.mods.fml.common.TickType.SERVER)) {
			   codechicken.chunkloader.ChunkLoaderManager.serverTick();
         codechicken.chunkloader.PlayerChunkViewerManager.instance().update();
      }

      if($1.contains(cpw.mods.fml.common.TickType.WORLD)) {
         codechicken.chunkloader.PlayerChunkViewerManager.instance().calculateChunkChanges((^class:WorldServer^)$2[0]);
      }
			}">tickEnd
			</replaceMethod>
		</class>
		<class id="codechicken.chunkloader.PlayerChunkViewerManager">
			<replaceInitializer field="ticketIDs" class="nallar.collections.CHashMap"/>
			<replaceInitializer field="lastLoadedChunkMap" class="nallar.collections.CHashMap"/>
			<replaceInitializer field="playerViewers" class="nallar.collections.ConcurrentLinkedQueueList"/>
			<replaceInitializer field="chunkChanges" class="nallar.collections.LinkedListIterateClear"/>
			<replaceInitializer field="ticketChanges" class="nallar.collections.LinkedListIterateClear"/>
			<replaceInitializer field="dimChanges" class="nallar.collections.LinkedListIterateClear"/>
			<replaceInitializer field="logouts" class="nallar.collections.LinkedListIterateClear"/>
			<replaceInitializer field="addViewers" class="nallar.collections.LinkedListIterateClear"/>
			<replaceMethod code="{
				++time;
				nallar.collections.LinkedListIterateClear logouts = (nallar.collections.LinkedListIterateClear) this.logouts;
				Iterator var2 = logouts.clearIterator();
				ArrayList temp = new ArrayList(logouts.size() + 3);
				while (var2.hasNext()) {
					temp.add(var2.next());
				}

				var2 = temp.iterator();
				String username;
				while(var2.hasNext()) {
					username = (String)var2.next();
					Iterator player = playerViewers.iterator();

					while(player.hasNext()) {
						if(((codechicken.chunkloader.PlayerChunkViewerTracker)player.next()).owner.^field:EntityPlayer/username^.equals(username)) {
							player.remove();
						}
					}
				}

				var2 = temp.iterator();

				Iterator var4;
				codechicken.chunkloader.PlayerChunkViewerTracker player1;
				while(var2.hasNext()) {
					username = (String)var2.next();
					var4 = playerViewers.iterator();

					while(var4.hasNext()) {
						player1 = (codechicken.chunkloader.PlayerChunkViewerTracker)var4.next();
						player1.removePlayer(username);
					}
				}

				nallar.collections.LinkedListIterateClear dimChanges = (nallar.collections.LinkedListIterateClear) this.dimChanges;
				var2 = dimChanges.clearIterator();
				ArrayList tempDim = new ArrayList(dimChanges.size() + 3);
				while (var2.hasNext()) {
					tempDim.add(var2.next());
				}

				var2 = tempDim.iterator();
				codechicken.chunkloader.PlayerChunkViewerManager$DimensionChange username1;
				while(var2.hasNext()) {
					username1 = (codechicken.chunkloader.PlayerChunkViewerManager$DimensionChange)var2.next();
					if(username1.add) {
						var4 = playerViewers.iterator();

						while(var4.hasNext()) {
							player1 = (codechicken.chunkloader.PlayerChunkViewerTracker)var4.next();
							player1.loadDimension(username1.world);
						}
					}
				}

				nallar.collections.LinkedListIterateClear chunkChanges = (nallar.collections.LinkedListIterateClear) this.chunkChanges;

				var2 = chunkChanges.clearIterator();

				while(var2.hasNext()) {
					codechicken.chunkloader.PlayerChunkViewerManager$ChunkChange username2 = (codechicken.chunkloader.PlayerChunkViewerManager$ChunkChange)var2.next();
					var4 = playerViewers.iterator();

					while(var4.hasNext()) {
						player1 = (codechicken.chunkloader.PlayerChunkViewerTracker)var4.next();
						player1.sendChunkChange(username2);
					}
				}

				nallar.collections.LinkedListIterateClear ticketChanges = (nallar.collections.LinkedListIterateClear) this.ticketChanges;
				var2 = ticketChanges.clearIterator();

				while(var2.hasNext()) {
					codechicken.chunkloader.PlayerChunkViewerManager$TicketChange username3 = (codechicken.chunkloader.PlayerChunkViewerManager$TicketChange)var2.next();
					if(ticketIDs.containsKey(username3.ticket)) {
						var4 = playerViewers.iterator();

						while(var4.hasNext()) {
							player1 = (codechicken.chunkloader.PlayerChunkViewerTracker)var4.next();
							player1.sendTicketChange(username3);
						}
					} else {
						ticketIDs.put(username3.ticket, Integer.valueOf(ticketID++));
						var4 = playerViewers.iterator();

						while(var4.hasNext()) {
							player1 = (codechicken.chunkloader.PlayerChunkViewerTracker)var4.next();
							player1.addTicket(codechicken.core.CommonUtils.getDimension(username3.ticket.world), username3.ticket);
						}
					}
				}

				var2 = tempDim.iterator();

				while(var2.hasNext()) {
					username1 = (codechicken.chunkloader.PlayerChunkViewerManager$DimensionChange)var2.next();
					if(!username1.add) {
						var4 = playerViewers.iterator();

						while(var4.hasNext()) {
							player1 = (codechicken.chunkloader.PlayerChunkViewerTracker)var4.next();
							player1.unloadDimension(codechicken.core.CommonUtils.getDimension(username1.world));
						}
					}
				}

				if(time % 10 == 0) {
					var2 = codechicken.core.ServerUtils.getAllPlayers().iterator();

					while(var2.hasNext()) {
						^class:EntityPlayer^ username4 = (^class:EntityPlayer^)var2.next();
						var4 = playerViewers.iterator();

						while(var4.hasNext()) {
							player1 = (codechicken.chunkloader.PlayerChunkViewerTracker)var4.next();
							player1.updatePlayer(username4);
						}
					}
				}


				var2 = ((nallar.collections.LinkedListIterateClear) this.addViewers).clearIterator();

				while(var2.hasNext()) {
					username = (String)var2.next();
					^class:EntityPlayerMP^ player2 = codechicken.core.ServerUtils.getPlayer(username);
					if(player2 != null) {
						playerViewers.add(new codechicken.chunkloader.PlayerChunkViewerTracker(player2, this));
					}
				}
			 }">update
			</replaceMethod>
			<synchronize>update</synchronize>
			<synchronize field="$1.^field:WorldServer/theChunkProviderServer^.^field:ChunkProviderServer/loadedChunks^">
				calculateChunkChanges
			</synchronize>
		</class>
		<class id="codechicken.chunkloader.ChunkLoaderManager$ChunkLoaderOrganiser">
			<replaceMethodCall newMethod="getTEWithLoad" method="^class:World^.^method:World/getBlockTileEntity^">
				^all^
			</replaceMethodCall>
			<replaceMethodCall newMethod="getBlockIdWithLoad" method="^class:World^.^method:World/getBlockId^">^all^
			</replaceMethodCall>
			<synchronize>revive(L^class:World^;)V,devive,revive()V,load,save</synchronize>
			<replaceInitializer field="dormantLoaders" class="nallar.collections.CHashMap"/>
			<replaceInitializer field="forcedChunksByChunk" class="nallar.collections.CHashMap"/>
			<replaceInitializer field="forcedChunksByLoader" class="nallar.collections.CHashMap"/>
			<replaceInitializer field="timedUnloadQueue" class="nallar.collections.LinkedTimedHashMapQueue"/>
			<replaceMethod code="{
				Iterator iterator = this.timedUnloadQueue.keySet().iterator();
				while (iterator.hasNext()) {
					remChunk((codechicken.chunkloader.ChunkLoaderManager.DimChunkCoord)iterator.next());
				}
			}">tickDownUnloads
			</replaceMethod>
		</class>
		<class id="codechicken.core.CommonUtils">
			<replaceMethod code="return $1.dimensionId;">getDimension(L^class:World^;)I</replaceMethod>
		</class>
	</chickenChunks>
	<wirelessRedstone>
		<class id="codechicken.wirelessredstone.core.RedstoneEther">
			<replaceInitializer field="playerJammedMap" class="nallar.collections.CHashMap"/>
			<final field="playerJammedMap"/>
		</class>
		<class id="codechicken.wirelessredstone.core.RedstoneEtherServer">
			<synchronize>tick</synchronize>
		</class>
		<class id="codechicken.wirelessredstone.core.RedstoneEtherFrequency">
			<replaceMethodCall index="0" code="{}" method="println">updateReceiver</replaceMethodCall>
		</class>
	</wirelessRedstone>
	<extraBiomesXL>
		<class id="extrabiomes.blocks.BlockAutumnLeaves$BlockType">
			<insertBefore code="if (loadedCustomBlocks) { return; }">loadCustomBlocks</insertBefore>
			<synchronize/>
		</class>
		<class id="extrabiomes.blocks.BlockGreenLeaves$BlockType">
			<insertBefore code="if (loadedCustomBlocks) { return; }">loadCustomBlocks</insertBefore>
			<synchronize/>
		</class>
		<class id="extrabiomes.module.summa.worldgen.WorldGenLegendOak$TreeBlock">
			<insertBefore code="if (loadedCustomBlocks) { return; }">loadCustomBlocks</insertBefore>
			<synchronize>loadCustomBlocks</synchronize>
		</class>
		<class id="extrabiomes.module.summa.worldgen.WorldGenFirTreeHuge$TreeBlock">
			<insertBefore code="if (loadedCustomBlocks) { return; }">loadCustomBlocks</insertBefore>
			<synchronize>loadCustomBlocks</synchronize>
		</class>
		<class id="extrabiomes.module.summa.worldgen.WorldGenFirTree$TreeBlock">
			<insertBefore code="if (loadedCustomBlocks) { return; }">loadCustomBlocks</insertBefore>
			<synchronize>loadCustomBlocks</synchronize>
		</class>
		<class id="extrabiomes.module.summa.worldgen.WorldGenAutumnTree$AutumnTreeType">
			<insertBefore code="if (loadedCustomBlocks) { return; }">loadCustomBlocks</insertBefore>
			<synchronize>loadCustomBlocks</synchronize>
		</class>
		<class id="extrabiomes.module.summa.worldgen.WorldGenAcacia$TreeBlock">
			<insertBefore code="if (loadedCustomBlocks) { return; }">loadCustomBlocks</insertBefore>
			<synchronize>loadCustomBlocks</synchronize>
		</class>
		<class id="extrabiomes.module.summa.worldgen.WorldGenRedwood$TreeBlock">
			<insertBefore code="if (loadedCustomBlocks) { return; }">loadCustomBlocks</insertBefore>
			<synchronize>loadCustomBlocks</synchronize>
		</class>
	</extraBiomesXL>
	<portalGun>
		<class id="portalgun.common.core.PacketHandlerServer">
			<replaceMethodCall method="console" index="0" code="{ }">onPacketData</replaceMethodCall>
		</class>
		<class id="portalgun.common.core.TickHandlerServer">
			<synchronize field="$1.^field:World/loadedEntityList^">worldTick</synchronize>
			<replaceInitializer field="grabMap" class="nallar.collections.CHashMap"/>
			<replaceInitializer field="portals" class="nallar.collections.CHashMap"/>
			<replaceInitializer field="moonPortals" class="nallar.collections.CHashMap"/>
			<replaceInitializer field="potatosProgression" class="nallar.collections.CHashMap"/>
			<replaceInitializer field="lastSeenEntity" class="nallar.collections.CHashMap"/>
			<replaceInitializer field="hasFallen" class="nallar.collections.CHashMap"/>
		</class>
		<class id="portalgun.common.core.ChunkLoadHandler">
			<replaceInitializer field="entTickets" class="nallar.collections.CHashMap"/>
			<replaceInitializer field="portalTickets" class="nallar.collections.CHashMap"/>
			<replaceMethodCall newMethod="getTEWithLoad" method="^class:World^.^method:World/getBlockTileEntity^">
				ticketsLoaded(Ljava.util.List;L^class:World^;)V,ticketsLoaded(Ljava.util.List;L^class:World^;I)Ljava.util.List;
			</replaceMethodCall>
			<replaceMethodCall newMethod="getBlockIdWithLoad" method="^class:World^.^method:World/getBlockId^">
				ticketsLoaded(Ljava.util.List;L^class:World^;)V,ticketsLoaded(Ljava.util.List;L^class:World^;I)Ljava.util.List;
			</replaceMethodCall>
			<synchronize static=""/>
		</class>
	</portalGun>
	<graviGun>
		<class id="gravigun.common.core.TickHandlerServer">
			<synchronize field="$1.^field:World/weatherEffects^">worldTick</synchronize>
			<replaceInitializer field="grabMap" class="java.util.concurrent.ConcurrentHashMap"/>
			<replaceInitializer field="tossedEntities" class="java.util.concurrent.ConcurrentHashMap"/>
			<replaceInitializer field="tosser" class="java.util.concurrent.ConcurrentHashMap"/>
			<replaceInitializer field="chargedThrow" class="java.util.concurrent.ConcurrentHashMap"/>
		</class>
	</graviGun>
	<twilightForest>
		<class id="twilightforest.entity.HydraHeadContainer">
			<insertBefore code="{
				if ($1 != null &amp;&amp; $1.^field:Entity/boundingBox^ == null) {
					return;
				}
			}">faceEntity,setTargetEntity
			</insertBefore>
		</class>
		<class id="twilightforest.TFFeatureCache">
			<replaceInitializer field="cache" class="nallar.collections.SynchronizedList"/>
			<synchronize field="cache">save</synchronize>
			<insertAfter code="{
				if (!(cache instanceof nallar.collections.SynchronizedList)) {
					cache = new nallar.collections.SynchronizedList(cache);
				}
			}">load
			</insertAfter>
		</class>
		<class id="twilightforest.block.BlockTFTowerDevice">
			<replaceMethodCall code="{ }" method="println">^method:Block/breakBlock^</replaceMethodCall>
		</class>
		<class id="twilightforest.block.BlockTFMagicLogSpecial">
			<!-- Spams logs, slow -->
			<disable>doSortingTreeEffect</disable>
		</class>
		<class id="twilightforest.biomes.TFBiomeDecorator">
			<synchronize>^method:BiomeDecorator/decorate^</synchronize>
		</class>
	</twilightForest>
	<additionalPipes>
		<class id="buildcraft.additionalpipes.pipes.PipePowerTeleport">
			<synchronize>receiveEnergy,requestEnergy</synchronize>
		</class>
		<class id="buildcraft.additionalpipes.pipes.TeleportManager">
			<synchronize>getConnectedPipes</synchronize>
		</class>
	</additionalPipes>
	<MFFS>
		<class id="mods.mffs.network.server.ForceFieldServerUpdatehandler$ForceFieldpacket">
			<public all="true"/>
			<synchronize field="queue">addto</synchronize>
		</class>
		<class id="mods.mffs.network.server.ForceFieldServerUpdatehandler">
			<replaceMethod code="{
				^class:World^[] worlds = net.minecraftforge.common.DimensionManager.getWorlds();
				^class:World^ world;
				for (int i = 0; i &lt; worlds.length; i++) {
					world = worlds[i];
					StringBuilder str = new StringBuilder();

					Stack queue = getWorldMap(world).queue;
					if (queue.isEmpty()) {
						continue;
					}
					synchronized(queue) {
						while (!queue.isEmpty()) {
							str.append(queue.pop());
							str.append(&quot;/&quot;);
							str.append(queue.pop());
							str.append(&quot;/&quot;);
							str.append(queue.pop());
							str.append(&quot;!&quot;);
							str.append(queue.pop());
							str.append(&quot;&lt;&quot;);
							str.append(queue.pop());
							str.append(&quot;/&quot;);
							str.append(queue.pop());
							str.append(&quot;/&quot;);
							str.append(queue.pop());
							str.append(&quot;>&quot;);
							if (str.length() > 7500) {
								break;
							}
						}
					}
					if (str.length() > 0) {
						try {
							ByteArrayOutputStream bos = new ByteArrayOutputStream(63000);
							DataOutputStream dos = new DataOutputStream(bos);

							dos.writeInt(0);
							dos.writeInt(0);
							dos.writeInt(0);
							dos.writeInt(100);
							dos.writeUTF(str.toString());

							^class:Packet250CustomPayload^ pkt = new ^class:Packet250CustomPayload^();
							pkt.^field:Packet250CustomPayload/channel^ = &quot;MFFS&quot;;
							pkt.^field:Packet250CustomPayload/data^ = bos.toByteArray();
							pkt.^field:Packet250CustomPayload/length^ = bos.size();

							cpw.mods.fml.common.network.PacketDispatcher.sendPacketToAllInDimension(pkt, world.^field:World/provider^.^field:WorldProvider/dimensionId^);
						} catch (Exception e) {
							Log.severe(&quot;Failed to send MFFS force-field update&quot;, e);
						}
					}
				}
			}">tickEnd
			</replaceMethod>
			<synchronize>tickEnd</synchronize>
		</class>
		<class id="mods.mffs.common.item.ItemCardPowerLink">
			<synchronize/>
		</class>
		<class id="mods.mffs.common.ModularForceFieldSystem$MFFSChunkloadCallback">
			<replaceMethodCall newMethod="getTEWithLoad" method="^class:World^.^method:World/getBlockTileEntity^">
				ticketsLoaded(Ljava.util.List;L^class:World^;)V,ticketsLoaded(Ljava.util.List;L^class:World^;I)Ljava.util.List;
			</replaceMethodCall>
			<replaceMethodCall newMethod="getBlockIdWithLoad" method="^class:World^.^method:World/getBlockId^">
				ticketsLoaded(Ljava.util.List;L^class:World^;)V,ticketsLoaded(Ljava.util.List;L^class:World^;I)Ljava.util.List;
			</replaceMethodCall>
		</class>
		<class id="mods.mffs.common.Linkgrid$Worldlinknet">
			<replaceInitializer field="FieldFusion" class="java.util.concurrent.ConcurrentHashMap"/>
			<replaceInitializer field="Jammer" class="java.util.concurrent.ConcurrentHashMap"/>
		</class>
		<class id="mods.mffs.common.tileentity.TileEntityProjector">
			<synchronize>calculateField(Z)Z,getInteriorPoints</synchronize>
			<replaceMethod code="{
				^class:ItemStack^ i = ^method:IInventory/getStackInSlot^(1);
				return i != null &amp;&amp; i.^method:ItemStack/getItem^() instanceof mods.mffs.common.modules.ModuleBase;
			}">hasValidTypeMod
			</replaceMethod>
			<replaceMethod code="{
				^class:ItemStack^ i = ^method:IInventory/getStackInSlot^(1);
				if (i == null) {
					return null;
				}
				^class:Item^ item = i.^method:ItemStack/getItem^();
				if (item instanceof mods.mffs.common.modules.ModuleBase) {
					return (mods.mffs.common.modules.ModuleBase) item;
				}
				return null;
			}">get_type
			</replaceMethod>
			<replaceMethod code="{
				HashSet field_def = new HashSet();
				HashSet field_interior = new HashSet();
				mods.mffs.common.modules.ModuleBase type = get_type();
				if(type == null) {
					this.field_def = field_def;
					this.field_interior = field_interior;
					return false;
				}
         HashSet tField = new HashSet();
         HashSet tFieldInt = new HashSet();
         if (type instanceof mods.mffs.common.modules.Module3DBase) {
            ((mods.mffs.common.modules.Module3DBase) type).calculateField(this, tField, tFieldInt);
         } else {
            type.calculateField(this, tField);
         }

         Iterator i$ = tField.iterator();

         mods.mffs.api.PointXYZ pnt;
         mods.mffs.api.PointXYZ tp;
         while(i$.hasNext()) {
            pnt = (mods.mffs.api.PointXYZ)i$.next();
            if(pnt.Y + ^field:TileEntity/yCoord^ &lt; 255) {
               tp = new mods.mffs.api.PointXYZ(pnt.X + ^field:TileEntity/xCoord^, pnt.Y + ^field:TileEntity/yCoord^, pnt.Z + ^field:TileEntity/zCoord^, ^field:TileEntity/worldObj^);
               if(!Forcefielddefine(tp, $1)) {
               		this.field_def = field_def;
									this.field_interior = field_interior;
                  return false;
               }

               field_def.add(tp);
            }
         }

         i$ = tFieldInt.iterator();

         while(i$.hasNext()) {
            pnt = (mods.mffs.api.PointXYZ)i$.next();
            if(pnt.Y + ^field:TileEntity/yCoord^ &lt; 255) {
               tp = new mods.mffs.api.PointXYZ(pnt.X + ^field:TileEntity/xCoord^, pnt.Y + ^field:TileEntity/yCoord^, pnt.Z + ^field:TileEntity/zCoord^, ^field:TileEntity/worldObj^);
               if(!calculateBlock(tp)) {
               		this.field_def = field_def;
									this.field_interior = field_interior;
                  return false;
               }

               field_interior.add(tp);
            }
         }

				this.field_def = field_def;
				this.field_interior = field_interior;
    		return true;
			}">calculateField(Z)Z
			</replaceMethod>
		</class>
	</MFFS>
	<thaumcraft>
		<class id="thaumcraft.common.lib.WorldTicker">
			<newField code="nallar.tickthreading.util.contextaccess.ContextAccess.$"
					  class="nallar.tickthreading.util.contextaccess.ContextAccess" field="context" static="true"/>
			<insertBefore code="{
				if (context.runningUnder(thaumcraft.common.lib.WorldTicker.class)) {
					return;
				}
			}">addSwapper
			</insertBefore>
		</class>
		<class id="thaumcraft.common.tiles.TileSensor">
			<replaceMethod code="((ArrayList) noteBlockEvents.get($1)).addAll($1.getNoteBlockEvents());">
				getNoteBlockEvents
			</replaceMethod>
		</class>
	</thaumcraft>
	<appliedEnergistics>
		<class id="appeng.proxy.ProxyGregTech">
			<replaceMethod code="{
				return $1 instanceof gregtechmod.common.tileentities.GT_TileEntity_Quantumchest;
			}">isQuantumChest
			</replaceMethod>
		</class>
		<class id="appeng.me.crafting.CraftRequest">
			<replaceInitializer field="Prereqs" class="SynchronizedList"/>
			<final field="Prereqs"/>
		</class>
		<class id="appeng.me.CellInventory">
			<synchronize>^all^</synchronize>
		</class>
		<class id="appeng.util.Platform">
			<insertBefore code="{
				if ($1 == $2) {
					return true;
				}
				if ($1 == null || $2 == null) {
					return false;
				}
			}">NBTEqualityTest
			</insertBefore>
		</class>
		<class id="appeng.api.me.tiles.IGridMachine">
			<newMethod code="public abstract void tickNetwork();"/>
		</class>
		<class id="appeng.me.tile.TileController">
			<newField class="int" static="" field="tickSkip" code="0"/>
			<newField class="java.util.ArrayList" code="new ArrayList();" field="tiles"/>
			<synchronize field="$1">requestUpdate</synchronize>
			<rename name="requestUpdate_">requestUpdate</rename>
			<newField field="updateQueue" class="java.util.concurrent.ConcurrentLinkedQueue"
					  code="new java.util.concurrent.ConcurrentLinkedQueue()"/>
			<newMethod code="public void requestUpdate(appeng.api.me.tiles.IGridTileEntity tt) {
				if (tt instanceof appeng.me.tile.TileInterfaceBase) {
					updateQueue.add(tt);
				}
			}"/>
			<insertBefore code="{
				appeng.api.me.tiles.IGridTileEntity tt;
				HashSet done = new HashSet();
				while ((tt = ((appeng.api.me.tiles.IGridTileEntity) updateQueue.poll())) != null) {
					if (done.add(tt)) {
						requestUpdate_(tt);
					}
				}
				if (enabled) {
					Iterator i = tiles.iterator();
					while (i.hasNext()) {
						appeng.api.me.tiles.IGridMachine igm = (appeng.api.me.tiles.IGridMachine) i.next();
						try {
							igm.tickNetwork();
						} catch (AbstractMethodError e) {
							System.out.println(&quot;AE IGridMachine missing tickNetwork: &quot; + igm.getClass().getName());
						}
					}
				}
				if (tickSkip++ % 2 == 0) {
					return;
				}
			}">updateTileEntity
			</insertBefore>
			<insertBefore code="{
				tiles.clear();
				if ($1 != null) {
					Iterator i = $1.iterator();
					while (i.hasNext()) {
						appeng.common.grid.GridEnumeration$NetworkNode tr = (appeng.common.grid.GridEnumeration$NetworkNode) i.next();
						^class:TileEntity^ tile = (^class:TileEntity^) tr.getTile();
						if (tile != this &amp;&amp; tile != null &amp;&amp; tile instanceof appeng.api.me.tiles.IGridMachine) {
							tiles.add(tile);
						}
					}
				}
			}">configureController
			</insertBefore>
			<replaceInitializer field="WaitingQueue" class="nallar.collections.ConcurrentLinkedQueueList"/>
			<replaceInitializer field="CraftingQueue" class="nallar.collections.ConcurrentLinkedQueueList"/>
			<synchronize field="CManager.getPrereqs()">getJobList,getJobStatus,cancelJob</synchronize>
			<synchronize>
				configureController,getCellArray,updateTileEntity,advanceCraftingCursor,resetWaitingQueue
			</synchronize>
		</class>
		<class id="appeng.me.tile.TileStorageBus">
			<synchronize>getCellArray,getItem</synchronize>
		</class>
		<class id="appeng.me.MEInventoryArray">
			<synchronize>^all^</synchronize>
		</class>
		<class id="appeng.common.grid.MEGridEvents">
			<replaceInitializer field="requests" class="nallar.collections.ConcurrentQueueList">^static^
			</replaceInitializer>
		</class>
		<class id="
			appeng.me.tile.TileAssembler
			appeng.me.tile.TileAssemblerMB
			appeng.me.tile.TileChest
			appeng.me.tile.TileCraftingMonitor
			appeng.me.tile.TileDarkCable
			appeng.me.tile.TileDrive
			appeng.me.tile.TileEnergyCell
			appeng.me.tile.TileInputCable
			appeng.me.tile.TileInterfaceBase
			appeng.me.tile.TileIOPort
			appeng.me.tile.TileLevelEmitter
			appeng.me.tile.TileOutputCable
			appeng.me.tile.TileP2PTunnel
			appeng.me.tile.TileSpatialIOPort
			appeng.me.tile.TileSpatialPylon
			appeng.me.tile.TileStorageBus
			appeng.me.tile.TileStorageMonitor
			appeng.me.tile.TileTerminal
			appeng.me.tile.TileTransitionPlane
			appeng.me.tile.TileWireless
			crazypants.enderio.conduit.TileConduitBundle
			extracells.tileentity.TileEntityBusFluidExport
			extracells.tileentity.TileEntityBusFluidImport
			extracells.tileentity.TileEntityBusFluidStorage
			extracells.tileentity.TileEntityFluidCrafter
			extracells.tileentity.TileEntityHardMEDrive
			extracells.tileentity.TileEntityInterfaceFluid
			extracells.tileentity.TileEntityLevelEmitterFluid
			extracells.tileentity.TileEntityMEDropper
			extracells.tileentity.TileEntityMonitorStorageFluid
			extracells.tileentity.TileEntityTerminalFluid
			extracells.tileentity.TileEntityTransitionPlaneFluid
		">
			<newMethod code="public void updateTileEntity() { }" ignoreDuplicate=""/>
			<renameInterfaceMethod name="tickNetwork" interface="appeng.api.me.tiles.IGridMachine" allowMissing="">
				updateTileEntity
			</renameInterfaceMethod>
			<newMethod code="private Object getNetworkLock() {
				Object o = getGrid();
				if (o instanceof appeng.api.TileRef) {
					o = ((appeng.api.TileRef) o).getTile();
				}
				return o == null ? new Object() : o;
			}"/>
		</class>
		<class id="appeng.me.tile.TileDrive">
			<synchronize field="getNetworkLock()">getCellArray,resetCache</synchronize>
		</class>
		<class id="appeng.me.tile.TileChest">
			<synchronize field="getNetworkLock()">getCellArray,resetCache</synchronize>
		</class>
	</appliedEnergistics>
	<denLib>
		<class id="denoflionsx.denLib.Lib.denLib$StringUtils">
			<replaceMethod code="return $1;">Hash(Ljava.lang.String;)Ljava.lang.String;</replaceMethod>
		</class>
		<class id="denoflionsx.denLib.Mod.Handlers.ChunkHandler">
			<removeMethod>onEvent</removeMethod>
		</class>
	</denLib>
	<icbm>
		<class id="icbm.api.RadarRegistry">
			<replaceMethod code="detectableEntities.remove($1);">unregister(L^class:Entity^;)V</replaceMethod>
			<replaceMethod code="detectableTileEntities.remove($1);">unregister(L^class:TileEntity^;)V</replaceMethod>
			<replaceMethodCall code="$_ = $0.getTEWithoutLoad($$);"
							   method="^class:World^.^method:World/getBlockTileEntity^">cleanUpArray
			</replaceMethodCall>
			<synchronize>
				cleanUpArray,getEntitiesWithinRadius,getTileEntitiesInArea,unregister(L^class:Entity^;)V,unregister(L^class:TileEntity^;)V,register(L^class:Entity^;)V,register(L^class:TileEntity^;)V
			</synchronize>
			<insertBefore
					code="if (!Thread.holdsLock(icbm.api.RadarRegistry.class)) { throw new UnsupportedOperationException(&quot;Not threadsafe.&quot;); }">
				getEntities,getTileEntities
			</insertBefore>
		</class>
	</icbm>
	<forestry>
		<class id="forestry.apiculture.gadgets.TileAlvearyPlain">
			<replaceInitializer field="modifiers"
								code="$_ = java.util.Collections.newSetFromMap(new java.util.concurrent.ConcurrentHashMap());"/>
			<replaceInitializer field="eventHandlers"
								code="$_ = java.util.Collections.newSetFromMap(new java.util.concurrent.ConcurrentHashMap());"/>
		</class>
	</forestry>
	<railCraft>
		<class id="railcraft.common.util.misc.ChunkManager">
			<replaceMethodCall newMethod="getTEWithLoad" method="^class:World^.^method:World/getBlockTileEntity^">
				ticketsLoaded(Ljava.util.List;L^class:World^;)V,ticketsLoaded(Ljava.util.List;L^class:World^;I)Ljava.util.List;
			</replaceMethodCall>
			<replaceMethodCall newMethod="getBlockIdWithLoad" method="^class:World^.^method:World/getBlockId^">
				ticketsLoaded(Ljava.util.List;L^class:World^;)V,ticketsLoaded(Ljava.util.List;L^class:World^;I)Ljava.util.List;
			</replaceMethodCall>
		</class>
	</railCraft>
	<seasons>
		<class id="WeatherPony.Seasons.Seasons_WorldData">
			<insertAfter code="worldsettings = new java.util.concurrent.ConcurrentHashMap();"/>
		</class>
	</seasons>
	<customOreGen>
		<class id="CustomOreGen.Server.ServerState">
			<replaceMethod code="{ return $1.isChunkSavedPopulated($2, $3); }">isChunkSavedPopulated</replaceMethod>
		</class>
	</customOreGen>
	<enderStorage>
		<class id="codechicken.enderstorage.api.EnderStorageManager">
			<insertAfter code="dirtyStorage = new nallar.collections.LinkedListReplaceIterateTempListClear();"/>
		</class>
	</enderStorage>
	<millenaire>
		<class id="org.millenaire.common.forge.Mill">
			<replaceInitializer field="serverWorlds" class="nallar.collections.CopyOnWriteVector"/>
		</class>
		<class id="org.millenaire.common.MillVillager">
			<replaceMethodCall method="error" code="{ }">registerInGlobalList</replaceMethodCall>
		</class>
		<class id="org.millenaire.common.MillWorld">
			<replaceMethod code="{ return (org.millenaire.common.Building) this.buildings.get($1);	}">getBuilding
			</replaceMethod>
		</class>
		<class id="org.millenaire.common.Point">
			<replaceMethod code="{
				return ((int) x) | (((int) y) &lt;&lt; 12) | (((int) z) &lt;&lt; 20);
			}">hashCode
			</replaceMethod>
		</class>
	</millenaire>
	<stevesCarts>
		<class id="vswe.stevescarts.CommonProxy">
			<replaceMethod code="{
				^class:Entity^ entity = $2.getEntity($1);
				if (entity instanceof vswe.stevescarts.Carts.MinecartModular) {
					return (vswe.stevescarts.Carts.MinecartModular) entity;
				}
				return null;
			}">getCart
			</replaceMethod>
		</class>
	</stevesCarts>
	<dynmap>
		<class id="org.dynmap.forge.SnapshotCache">
			<synchronize/>
		</class>
		<class id="org.dynmap.forge.ForgeMapChunkCache">
			<replaceMethod code="return this.cps.getChunkAt($1, $2, false, null);">loadChunkNoGenerate</replaceMethod>
			<replaceMethod code="return this.cps.readChunkNBT($1, $2);">readChunk</replaceMethod>
		</class>
	</dynmap>
	<gregsLighting>
		<class id="gcewing.lighting.Floodlight">
			<synchronize static="true"/>
		</class>
	</gregsLighting>
	<hats>
		<class id="hats.common.core.TickHandlerServer">
			<replaceInitializer field="mobHats" class="nallar.collections.ConcurrentWeakHashMap"/>
		</class>
	</hats>
	<mineFactoryReloaded>
		<class id="powercrystals.minefactoryreloaded.tile.machine.TileEntityDeepStorageUnit">
			<replaceMethod code="{
				^class:ItemStack^ item = _inventory[$1];
				^class:ItemStack^ item2 = _inventory[2];
				if (item != null)
					{
						if ((_storedQuantity == 0) &amp;&amp; ((item2 == null) || ((item2.^field:ItemStack/itemID^ == item.^field:ItemStack/itemID^) &amp;&amp; (item2.^method:ItemStack/getItemDamage^() == item.^method:ItemStack/getItemDamage^()))) &amp;&amp; (item.^method:ItemStack/getTagCompound^() == null))
						{
							_inventory[$1] = null;
							_storedId = item.^field:ItemStack/itemID^;
							_storedMeta = item.^method:ItemStack/getItemDamage^();
							_storedQuantity = item.^field:ItemStack/stackSize^;
							item = null;
						}
						else if ((item.^field:ItemStack/itemID^ == _storedId) &amp;&amp; (item.^method:ItemStack/getItemDamage^() == _storedMeta) &amp;&amp; (item.^method:ItemStack/getTagCompound^() == null) &amp;&amp; (2147483581 - item.^field:ItemStack/stackSize^ > _storedQuantity))
						{
							if (item.^method:ItemStack/getMaxStackSize^() > 1)
							{
								int s = item.^field:ItemStack/stackSize^;
								item.^field:ItemStack/stackSize^ = 1;
								_storedQuantity += s - 1;
							}
							else
							{
								_inventory[$1] = null;
								_storedQuantity += item.^field:ItemStack/stackSize^;
								item = null;
							}

						}
						else if ((item.^field:ItemStack/itemID^ != _storedId) || (item.^method:ItemStack/getItemDamage^() != _storedMeta) || (item.^method:ItemStack/getTagCompound^() != null))
						{
							_inventory[$1] = item = powercrystals.core.util.UtilInventory.dropStack(this, item, getDropDirection());
						}
					}

					if ((item == null) &amp;&amp; (item2 != null) &amp;&amp; (_storedQuantity > 1) &amp;&amp; (item2.^method:ItemStack/getMaxStackSize^() > 1))
					{
						_inventory[$1] = item = new ^class:ItemStack^(_storedId, 1, _storedMeta);
						_storedQuantity -= 1;
					}
			}">checkInput
			</replaceMethod>
		</class>
	</mineFactoryReloaded>
	<xReliquary>
		<class id="xeno.reliquary.items.AlkahestHandler">
			<replaceMethodCall code="{}" method="println">onCrafting</replaceMethodCall>
		</class>
	</xReliquary>
	<tubestuff>
		<class id="immibis.tubestuff.TubeStuff">
			<insertBefore code="{
				if ($1 == $2) {
					return true;
				}
				if ($1 == null || $2 == null) {
					return false;
				}
			}">areItemsEqual
			</insertBefore>
		</class>
	</tubestuff>
	<mekanism>
		<class id="mekanism.common.TileEntitySmeltingFactory">
			<ignoreExceptions type="java.lang.NullPointerException">onUpdate</ignoreExceptions>
		</class>
	</mekanism>
	<magicBees>
		<class id="magicbees.world.WorldTicker">
			<replaceNew oldClass="java.util.LinkedList" newClass="nallar.collections.ConcurrentLinkedQueueList">
				queueChunkCoords
			</replaceNew>
		</class>
	</magicBees>
	<tagApi>
		<class id="org.kitteh.tag.TagAPI">
			<replaceMethodCall method="equals" code="$_ = true;" index="0">getName,check,handlePacket
			</replaceMethodCall>
		</class>
	</tagApi>
	<mobHats>
		<class id="hats.common.core.TickHandlerServer">
			<newField field="skip" class="int" code="0"/>
			<insertBefore code="{
				if (skip++ % 1800 != 0) {
				 return;
				}
			}">worldTick
			</insertBefore>
			<replaceMethodCall method="^class:EntityLiving^.^method:Entity/isEntityAlive^"
							   code="$_ = $0.^method:Entity/isEntityAlive^() &amp;&amp; $0.chunk != null;">worldTick
			</replaceMethodCall>
		</class>
	</mobHats>
	<revamp>
		<class id="rivvest.Revamp.EntityEventHandler">
			<replaceInitializer field="entitiesToConvert" class="nallar.collections.SynchronizedList"/>
		</class>
		<class id="rivvest.Revamp.ServerTickerRevamp">
			<replaceMethodCall method="java.util.List.clear" code="{}">runConversions</replaceMethodCall>
			<insertBefore code="{
				synchronized ($1) {
					ArrayList temp = new ArrayList($1);
					$1.clear();
					$1 = temp;
				}
			}">runConversions
			</insertBefore>
		</class>
	</revamp>
	<morpheus>
		<class id="net.quetzi.morpheus.SleepChecker">
			<replaceMethod code="{
				if (($1 != null) &amp;&amp; (net.quetzi.morpheus.Morpheus.alertEnabled)) {
					for (Iterator i$ = $2.^field:World/playerEntities^.iterator(); i$.hasNext(); ) {
						^class:EntityPlayerMP^ entityPlayer = (^class:EntityPlayerMP^)i$.next();
						entityPlayer.^method:EntityPlayerMP/sendChatToPlayer^($1);
					}
				}
				net.quetzi.morpheus.Morpheus.mLog.info($1.toString());
			}">alertPlayers
			</replaceMethod>
			<replaceMethod code="{
					for (Iterator i$ = $1.^field:World/playerEntities^.iterator(); i$.hasNext(); ) {
						^class:EntityPlayerMP^ player = (^class:EntityPlayerMP^)i$.next();
						net.quetzi.morpheus.world.WorldSleepState wss = (net.quetzi.morpheus.world.WorldSleepState) net.quetzi.morpheus.Morpheus.playerSleepStatus.get(Integer.valueOf(player.^field:Entity/dimension^));
						if (player.^method:EntityPlayer/isPlayerFullyAsleep^() &amp;&amp; !wss.isPlayerSleeping(player.^field:EntityPlayerMP/username^)) {
							wss.setPlayerAsleep(player.^field:EntityPlayerMP/username^);
							alertPlayers(createAlert(player.^field:Entity/worldObj^, player,net.quetzi.morpheus.Morpheus.onSleepText), $1);
						} else if (!player.^method:EntityPlayer/isPlayerFullyAsleep^() &amp;&amp; wss.isPlayerSleeping(player.^field:EntityPlayerMP/username^)) {
							wss.setPlayerAwake(player.^field:EntityPlayerMP/username^);
							alertPlayers(createAlert(player.^field:Entity/worldObj^, player,net.quetzi.morpheus.Morpheus.onWakeText), $1);
						}
					}
			}">updatePlayerStates
			</replaceMethod>
		</class>
	</morpheus>
	<canUpdateFixes onDemand="true">
		<class id="
		com.advGenetics.TileEntity.TileEntityMicroscope
		com.xcompwiz.mystcraft.tileentity.TileEntityBookBinder
		com.xcompwiz.mystcraft.tileentity.TileEntityBookReceptacle
		com.xcompwiz.mystcraft.tileentity.TileEntityBookstand
		com.xcompwiz.mystcraft.tileentity.TileEntityLinkModifier
		com.xcompwiz.mystcraft.tileentity.TileEntityStarFissure
		emasher.sockets.pipes.TileDirectionChanger
		emasher.sockets.pipes.TileFrame
		extracells.tileentity.TileEntityCertusTank
		extracells.tileentity.TileEntityHardMEDrive
		extracells.tileentity.TileEntityLevelEmitterFluid
		extracells.tileentity.TileEntityMEDropper
		extracells.tileentity.TileEntityMonitorStorageFluid
		extracells.tileentity.TileEntityVoidFluid
		">
			<newMethod code="public boolean ^method:TileEntity/canUpdate^() {
				return false;
			}"/>
		</class>
	</canUpdateFixes>
</mods>