patches.xml

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<mods>
	<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="warning"
												 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>
			<public>releaseEntitySkin</public>
			<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>
			<removeMethod>forceChunk,unforceChunk</removeMethod>
		</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="pendingTickListEntries"/>
		</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_5_R3.chunkio.ChunkIOExecutor" env="mcpc">
			<replaceInitializer field="instance" code="$_ = null;"/>
			<replaceMethod code="throw new UnsupportedOperationException();">tick</replaceMethod>
			<disable>adjustPoolSize</disable>
			<replaceMethod code="((^class:ChunkProviderServer^)$1.^method:World/getChunkProvider^()).getChunkAt($2, $3, true, false, null);">waitForChunkLoad</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_5_R3.util.LongHashSet" remove="true"/>
			<insertAfter field="chunksToUnload" code="$field = new org.bukkit.craftbukkit.v1_5_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.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"/>
			<replaceInitializer field="theAABBLocalPool" code="$_ = null;">^static^</replaceInitializer>
		</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.passive.EntitySquid">
			<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.entity.Entity">
			<addAll fromClass="nallar.patched.entity.PatchEntity"/>
		</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">
			<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"/>
		</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,removeAllTrackingPlayers,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_5_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.block.Block" env="mcpc">
			<threadLocalBoolean field="callingPlaceEvent" threadLocalField="$0.inPlaceEvent"/>
		</class>
		<class id="net.minecraft.world.World" env="mcpc">
			<removeUntilOpcode index="-2" opcode="ATHROW">addEntity,removePlayerEntityDangerously</removeUntilOpcode>
			<insertBefore code="inPlaceEvent = new nallar.tickthreading.util.BooleanThreadLocal();"/>
			<final field="callingPlaceEvent"/>
			<threadLocalBoolean field="callingPlaceEvent" threadLocalField="$0.inPlaceEvent"/>
			<disable>loadChunkOnProvideBegin,loadChunkOnProvideEnd</disable>
		</class>
		<class id="net.minecraft.world.chunk.Chunk" env="mcpc">
			<threadLocalBoolean field="callingPlaceEvent" threadLocalField="$0.inPlaceEvent"/>
		</class>
		<class id="net.minecraft.item.ItemBlock" env="mcpc">
			<threadLocalBoolean field="callingPlaceEvent" threadLocalField="$0.inPlaceEvent"/>
		</class>
		<class id="net.minecraft.server.gui.GuiLogOutputHandler">
			<synchronize>publish</synchronize>
		</class>
	</minecraftCommon>
	<forge>
		<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>
	</forge>
	<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_5_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_5_R3.CraftWorld) $1).getHandle(), $2);
			}">unloadWorld(Lorg.bukkit.World;Z)V
			</replaceMethod>
		</class>
		<class id="org.bukkit.craftbukkit.v1_5_R3.entity.CraftPlayer">
			<removeUntilOpcode index="-2" opcode="ATHROW">kickPlayer</removeUntilOpcode>
		</class>
		<class id="org.bukkit.craftbukkit.v1_5_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_5_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">
			<addAll fromClass="nallar.patched.forge.PatchLoader"/>
		</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.relauncher.RelaunchClassLoader">
			<addAll fromClass="nallar.patched.forge.PatchRelaunchClassLoader"/>
			<synchronize>findClass</synchronize>
		</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.common.TileEntityBarrel">
			<replaceMethod code="{
				^class:ItemStack^ i = this.item;
				^class:ItemStack^ top = this.topStack;
				^class:ItemStack^ b = this.bottomStack;
				if (i == null) {
					return 0;
				}
				if ((top == null) || (!itemMatch(top))) {
					top = i.^method:ItemStack/copy^();
					top.^field:ItemStack/stackSize^ = 0;
					this.topStack = top;
				}
				if ((b == null) || (!itemMatch(b))) {
					b = this.item.^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.common.TileEntityMirror">
			<replaceMethod code="{
				this.next_check = (300 + rand.nextInt(60));
			}">setNextCheck
			</replaceMethod>
		</class>
		<class id="factorization.common.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.common.TileEntitySolarTurbine">
			<synchronize>addReflector</synchronize>
		</class>
		<class id="factorization.common.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>
	<buildCraftEnergy>
		<class id="buildcraft.energy.TileEngine">
			<synchronize>createEngineIfNeeded</synchronize>
			<insertBefore code="if ($1 &gt; 2 || $1 &lt; 0) { $1 = 0; }">newEngine</insertBefore>
		</class>
	</buildCraftEnergy>
	<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>
		<class id="buildcraft.factory.TilePump">
			<replaceInitializer field="blocksToPump" class="nallar.collections.TreeMapHashMap"/>
			<insertBefore code="blocksToPump.clear();">initializePumpFromPosition</insertBefore>
			<synchronize>isActive,getNextIndexToPump,initializePumpFromPosition</synchronize>
		</class>
	</buildCraftFactory>
	<buildCraftTransport>
		<class id="buildcraft.transport.TileGenericPipe">
			<newField field="staticLock" class="java.lang.Object" static=""/>
			<synchronize field="staticLock">initialize</synchronize>
			<synchronize field="facadeBlocks">blockCreated,getBlockId,getTile,computeConnections</synchronize>
		</class>
		<class id="buildcraft.transport.PipeTransportItems">
			<replaceInitializer field="travelingEntities" class="java.util.concurrent.ConcurrentHashMap"/>
			<replaceInitializer field="toRemove" class="nallar.collections.SynchronizedSet"/>
			<replaceMethod code="{
				synchronized(toRemove) {
					java.util.Iterator i = toRemove.iterator();
					while (i.hasNext()) {
						travelingEntities.remove(i.next());
					}
					toRemove.clear();
				}
			}">performRemoval
			</replaceMethod>
		</class>
		<class id="buildcraft.transport.PipeTransportPower">
			<!-- TODO: Non-static lock, if possible -->
			<newField field="staticLock" class="java.lang.Object" static=""/>
			<synchronize field="staticLock">updateEntity</synchronize>
		</class>
	</buildCraftTransport>
	<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>
	<redPowerCore>
		<class id="com.eloraam.redpower.core.RedPowerLib">
			<threadLocal field="blockUpdates" type="java.util.HashSet" threadLocalField="nallar.tickthreading.global.ThreadLocals.redPowerBlockUpdateSet"/>
			<threadLocal field="powerSearchTest" type="java.util.HashSet" threadLocalField="nallar.tickthreading.global.ThreadLocals.redPowerPowerSearchTest"/>
			<threadLocal field="powerSearch" type="java.util.LinkedList" threadLocalField="nallar.tickthreading.global.ThreadLocals.redPowerPowerSearch"/>
			<threadLocalBoolean field="searching" threadLocalField="nallar.tickthreading.global.ThreadLocals.redPowerIsSearching"/>
		</class>
		<class id="com.eloraam.redpower.core.TileExtended">
			<replaceMethod code="this.sendTile();">updateBlock</replaceMethod>
			<replaceMethod code="this.sendTileWithNotify();">updateBlockChange</replaceMethod>
		</class>
		<class id="com.eloraam.redpower.core.TubeBuffer">
			<synchronize>onRemove,pop,addNew,addNewColor,addBounce,addAll,getLast,readFromNBT,writeToNBT</synchronize>
		</class>
		<class id="com.eloraam.redpower.core.TubeFlow">
			<replaceInitializer field="contents" class="nallar.collections.ConcurrentLinkedQueueList"/>
			<replaceInitializer field="contents" code="contents.clear(); $_ = null;">readFromNBT</replaceInitializer>
			<replaceFieldUsage field="contents" writeCode="{ }">readFromNBT</replaceFieldUsage>
			<final field="contents"/>
		</class>
		<class id="com.eloraam.redpower.core.PipeLib">
			<replaceMethodCall index="0" code="{ $_ = null; }" method="printf">registerForgeFluid</replaceMethodCall>
		</class>
	</redPowerCore>
	<redPowerMechanical>
		<class id="com.eloraam.redpower.machine.TileMotor">
			<replaceFieldUsage class="^class:World^" field="^field:World/isRemote^" writeCode="{ }" readCode="{ $_ = false; }">dropFrame,pickFrame</replaceFieldUsage>
			<replaceMethodCall newMethod="setBlockAndMetadataWithUpdateWithoutValidate" method="^class:World^.^method:World/setBlockAndMetadataWithUpdate^">dropFrame,pickFrame</replaceMethodCall>
		</class>
		<class id="com.eloraam.redpower.machine.TileTranspose">
			<synchronize field="buffer">drainBuffer</synchronize>
		</class>
	</redPowerMechanical>
	<industrialCraft>
		<class id="ic2.core.IC2">
			<synchronize>addSingleTickCallback</synchronize>
		</class>
		<class id="ic2.core.EnergyNet">
			<replaceMethodCall method="warning" code="{}">emitEnergyFrom</replaceMethodCall>
			<replaceInitializer field="energySourceToEnergyPathMap" class="java.util.HashMap"/>
			<replaceInitializer field="entityLivingToShockEnergyMap" class="java.util.HashMap"/>
			<synchronize>addTileEntity,removeTileEntity,emitEnergyFrom,discover</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>
		<class id="ic2.core.network.NetworkManager">
			<replaceMethod code="{
				ic2.core.WorldData worldData = ic2.core.WorldData.get($1);
				Collection networkedFieldsToUpdate = worldData.networkedFieldsToUpdate;

				if (worldData.networkedFieldsToUpdate.isEmpty()) return;

				Collection networkedFieldsToUpdateList;
				synchronized(networkedFieldsToUpdate) {
				  networkedFieldsToUpdateList = new ArrayList(networkedFieldsToUpdate);
				  networkedFieldsToUpdate.clear();
				}

				for (Iterator i$ = $1.^field:World/playerEntities^.iterator(); i$.hasNext(); ) {
					^class:EntityPlayerMP^ entityPlayer = (^class:EntityPlayerMP^)i$.next();

					sendUpdatePacket(networkedFieldsToUpdateList, entityPlayer);
				}
			}">sendUpdatePacket(L^class:World^;)V
			</replaceMethod>
		</class>
		<class id="ic2.core.WorldData">
			<replaceInitializer field="networkedFieldsToUpdate" class="nallar.collections.SynchronizedSet"/>
		</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.b.g">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.world.WorldExtension">
			<replaceInitializer field="chunkMap" class="nallar.collections.CHashMap"/>
		</class>
		<class id="codechicken.xycraftcopy.core.world.WorldExtension">
			<replaceInitializer field="chunkMap" class="nallar.collections.CHashMap"/>
		</class>
		<class id="codechicken.core.world.WorldExtensionManager$WorldExtensionEventHandler">
			<synchronize>onChunkLoad,onChunkUnLoad,onChunkDataLoad,onChunkDataSave</synchronize>
		</class>
		<class id="codechicken.xycraftcopy.core.world.WorldExtensionManager$WorldExtensionEventHandler">
			<synchronize>onChunkLoad,onChunkUnLoad,onChunkDataLoad,onChunkDataSave</synchronize>
		</class>
		<class id="codechicken.core.CommonUtils">
			<replaceMethod code="return $1.dimensionId;">getDimension(L^class:World^;)I</replaceMethod>
			<replaceMethod code="{
				java.io.File basesave = getWorldBaseSaveLocation($1);
				String innerSave = $1.^field:World/provider^.getSaveFolder();
				if (innerSave != null) {
					return new java.io.File(basesave, innerSave);
				}

				return basesave;
			}">getWorldSaveLocation(L^class:World^;I)Ljava.io.File;
			</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>
	<myTown>
		<class id="ee.lutsu.alpha.mc.mytown.event.ProtectionEvents">
			<synchronize>tickStart</synchronize>
		</class>
		<class id="ee.lutsu.alpha.mc.mytown.MyTownDatasource">
			<synchronize field="$1.intern()">getOrMakeResident(Ljava.lang.String;)Lee.lutsu.alpha.mc.mytown.entities.Resident;</synchronize>
		</class>
	</myTown>
	<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.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.api.ObjectTags">
			<replaceInitializer field="tags" class="nallar.collections.CHashMap"/>
		</class>
		<class id="thaumcraft.common.aura.AuraManager">
			<replaceNew oldClass="java.util.LinkedList" newClass="nallar.collections.ConcurrentLinkedQueueList">registerAuraNode,addToAuraUpdateList</replaceNew>
			<synchronize>registerAuraNode</synchronize>
		</class>
		<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,addBlockToRestore
			</insertBefore>
		</class>
		<class id="thaumcraft.common.aura.AuraWorldTicker">
			<synchronize field="((^class:WorldServer^)$2[0]).auraLock">tickEnd</synchronize>
			<replaceMethod code="{
				synchronized(thaumcraft.common.aura.AuraManager.class) {
					if (thaumcraft.common.aura.AuraManager.auraUpdateList.get(Integer.valueOf($1)) != null) {
						return;
					}
					LinkedList temp = new ConcurrentLinkedQueueList();
					Collection nodes = thaumcraft.common.aura.AuraManager.auraNodes.values();
					for (Iterator i = nodes.iterator(); i.hasNext();) {
						thaumcraft.api.aura.AuraNode node = (thaumcraft.api.aura.AuraNode) i.next();
						if (node.dimension == $1) {
							temp.add(Integer.valueOf(node.key));
						}
					}
					thaumcraft.common.aura.AuraManager.auraUpdateList.put(Integer.valueOf($1), temp);
				}
			}">populateAuraUpdateList
			</replaceMethod>
		</class>
		<class id="thaumcraft.common.lib.EventHandler">
			<synchronize field="$1.world.auraLock">chunkLoad</synchronize>
		</class>
		<class id="thaumcraft.common.tiles.TileCrystalCapacitor">
			<replaceFieldUsage field="count" writeCode="{ }" readCode="{ $_ = null; }">^all^</replaceFieldUsage>
			<removeField field="count"/>
			<insertAfter code="interval = new Random().nextInt(300);"/>
			<replaceMethod code="{
				^class:World^ world = this.^field:TileEntity/worldObj^;
				if (!world.onClient() &amp;&amp; interval++ % 300 == 0) {
					ArrayList e = thaumcraft.common.aura.AuraManager.getAurasWithin(world, ^field:TileEntity/xCoord^ + 0.5, ^field:TileEntity/yCoord^ + 0.5, ^field:TileEntity/zCoord^ + 0.5);
					if(e.size() == 0) {
					   return;
					}

					Iterator i$ = e.iterator();

					while(i$.hasNext()) {
					   Integer key = (Integer)i$.next();
					   thaumcraft.api.aura.AuraNode nd = thaumcraft.common.aura.AuraManager.getNode(key.intValue());
					   if(nd != null) {
					      if(nd.level &gt; nd.baseLevel &amp;&amp; this.storedVis &lt; this.maxVis) {
					         thaumcraft.common.aura.AuraManager.queueNodeChanges(nd.key, -1, 0, false, null, 0.0F, 0.0F, 0.0F);
					         ++this.storedVis;
					         sendTile();
					         break;
					      }

					      if(nd.level &lt; nd.baseLevel &amp;&amp; this.storedVis &gt; 0) {
					         thaumcraft.common.aura.AuraManager.queueNodeChanges(nd.key, 1, 0, false, null, 0.0F, 0.0F, 0.0F);
					         --this.storedVis;
					         sendTile();
					         break;
					      }
					   }
					}
				}
			}">^method:TileEntity/updateEntity^
			</replaceMethod>
		</class>
		<class id="thaumcraft.common.tiles.TileMarker">
			<replaceInitializer field="markers" class="nallar.collections.CHashMap">^static^</replaceInitializer>
			<replaceInitializer field="markedForDeletion" class="nallar.collections.ArrayListReplaceIterateTempListClear">^static^</replaceInitializer>
		</class>
		<class id="thaumcraft.common.tiles.TileSensor">
			<replaceMethod code="((ArrayList) noteBlockEvents.get($1)).addAll($1.getNoteBlockEvents());">getNoteBlockEvents</replaceMethod>
		</class>
	</thaumcraft>
	<universalElectricity>
		<!-- TODO: Rework UE patches. API changed a lot. -->
	</universalElectricity>
	<appliedEnergistics>
		<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.me.tile.TileController">
			<replaceInitializer field="WaitingQueue" class="nallar.collections.ConcurrentLinkedQueueList"/>
			<replaceInitializer field="CraftingQueue" class="nallar.collections.ConcurrentLinkedQueueList"/>
			<synchronize field="CManager.getPrereqs()">getJobList,getJobStatus,cancelJob</synchronize>
			<synchronize>getCellArray,^method:TileEntity/updateEntity^,advanceCraftingCursor,resetWaitingQueue</synchronize>
		</class>
		<class id="appeng.me.tile.TileDrive">
			<synchronize>getCellArray,resetCache</synchronize>
		</class>
		<class id="appeng.me.tile.TileChest">
			<synchronize>getCellArray,resetCache</synchronize>
		</class>
		<class id="appeng.me.tile.TileStorageBus">
			<synchronize>getCellArray,getSharedTagCompound,signalInput</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>
	</appliedEnergistics>
	<xyCraft>
		<class id="soaryn.xycraft.machines.block.XyCraftWorldExtension">
			<replaceInitializer field="multiBlocks" class="nallar.collections.CHashMap"/>
			<replaceInitializer field="deferredLoadSet" class="nallar.collections.HashSetReplaceIterateTempListNoClear"/>
			<synchronize>defer,remMultiBlock</synchronize>
			<replaceFieldUsage field="useTemp" writeCode="$1 = false;">updateDeffered</replaceFieldUsage>
			<insertAfter code="deferredLoadSet.clear();">updateDeffered</insertAfter>
			<replaceMethod code="synchronized (tempList) { return this.nextMultiBlockID++; }">getNextMultiBlockID</replaceMethod>
		</class>
	</xyCraft>
	<denLib>
		<class id="denoflionsx.denLib">
			<replaceMethod code="return $1;">Hash</replaceMethod>
		</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>
		<class id="forestry.core.utils.Localization">
			<newField class="nallar.collections.PartiallySynchronizedMap" code="new nallar.collections.PartiallySynchronizedMap()" field="map" static=""/>
			<final>mappings,defaultMappings</final>
			<synchronize field="forestry.core.utils.Localization.class">load</synchronize>
			<insertAfter code="{
				load(getCurrentLanguage());
			}"/>
			<insertAfter code="{
				map.clear();
				map.putAll(defaultMappings);
				map.putAll(mappings);
			}">load(Ljava.lang.String;)V
			</insertAfter>
			<unsynchronize>get</unsynchronize>
			<replaceMethod code="{
				return (String) map.get($1);
			}">get
			</replaceMethod>
		</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>
	<mmmPowerSuits>
		<class id="net.machinemuse.powersuits.network.packets.MusePacketPlayerUpdate" srg="true">
			<replaceMethod code="{
				if (net.minecraft.server.MinecraftServer.currentTick % 2 == 0) {
					net.machinemuse.powersuits.network.packets.MusePacketPlayerUpdate updatePacket = new net.machinemuse.powersuits.network.packets.MusePacketPlayerUpdate((cpw.mods.fml.common.network.Player) $1, this.inputMap);
					$1.^field:Entity/motionX^ = this.inputMap.motionX;
					$1.^field:Entity/motionY^ = this.inputMap.motionY;
					$1.^field:Entity/motionZ^ = this.inputMap.motionZ;
					cpw.mods.fml.common.network.PacketDispatcher.sendPacketAroundPlayer((^class:EntityPlayerMP^) $1, updatePacket.getPacket250(), 4096);
				}
			}">handleServer
			</replaceMethod>
		</class>
	</mmmPowerSuits>
	<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>
	<notEnoughItems>
		<class id="codechicken.nei.NEISPH">
			<insertBefore code="{
				if ($1.getType() != 10 &amp;&amp; !$3.^method:EntityPlayerMP/canCommandSenderUseCommand^(4, &quot;give&quot;)) {
					Redirects.notifyAdmins(&quot;Modified NotEnoughItems. Probably duping and/or in creative mode. Packet type &quot; + $1.getType());
					return;
				}
			}">handlePacket
			</insertBefore>
		</class>
	</notEnoughItems>
	<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>
	<dimensionalDoors>
		<replaceFieldUsage field="hasGrownRifts" writeCode="if ($0 != null) { $0.hasGrownRifts = $1; }"/>
	</dimensionalDoors>
	<tagApi>
		<class id="org.kitteh.tag.TagAPI">
			<replaceMethodCall method="equals" code="$_ = true;" index="0">getName,check,handlePacket</replaceMethodCall>
		</class>
	</tagApi>
</mods>