content: package thebetweenlands.common.world.gen.feature.structure;
  
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Random;
  import java.util.UUID;
  
  import javax.annotation.Nullable;
  
  import net.minecraft.block.Block;
  import net.minecraft.block.BlockBush;
  import net.minecraft.block.state.IBlockState;
  import net.minecraft.entity.SharedMonsterAttributes;
  import net.minecraft.init.Blocks;
  import net.minecraft.nbt.NBTTagCompound;
  import net.minecraft.tileentity.TileEntity;
  import net.minecraft.util.ResourceLocation;
  import net.minecraft.util.WeightedSpawnerEntity;
  import net.minecraft.util.math.AxisAlignedBB;
  import net.minecraft.util.math.BlockPos;
  import net.minecraft.world.World;
  import thebetweenlands.api.loot.ISharedLootContainer;
  import thebetweenlands.api.storage.LocalRegion;
  import thebetweenlands.api.storage.StorageUUID;
  import thebetweenlands.common.block.structure.BlockSlabBetweenlands;
  import thebetweenlands.common.block.terrain.BlockCragrock;
  import thebetweenlands.common.entity.mobs.EntityPyrad;
  import thebetweenlands.common.registries.BlockRegistry;
  import thebetweenlands.common.registries.LootTableRegistry;
  import thebetweenlands.common.world.WorldProviderBetweenlands;
  import thebetweenlands.common.world.gen.biome.decorator.SurfaceType;
  import thebetweenlands.common.world.gen.feature.WorldGenHelper;
  import thebetweenlands.common.world.storage.BetweenlandsWorldStorage;
  import thebetweenlands.common.world.storage.SharedLootPoolStorage;
  import thebetweenlands.common.world.storage.location.LocationCragrockTower;
  import thebetweenlands.common.world.storage.location.guard.ILocationGuard;
  
  public class WorldGenCragrockTower extends WorldGenHelper {
  	private static IBlockState CRAGROCK;
  	private static IBlockState MOSSY_CRAGROCK_TOP;
  	private static IBlockState MOSSY_CRAGROCK_BOTTOM;
  	private static IBlockState CRAGROCK_BRICKS;
  	private static IBlockState SMOOTH_CRAGROCK_STAIRS;
  	private static IBlockState CRAGROCK_BRICK_SLAB;
  	private static IBlockState CRAGROCK_BRICK_SLAB_UPSIDEDOWN;
  	private static IBlockState SMOOTH_CRAGROCK_SLAB;
  	private static IBlockState SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN;
  	private static IBlockState CRAGROCK_BRICK_STAIRS;
  	private static IBlockState CRAGROCK_PILLAR;
  	private static IBlockState SMOOTH_CRAGROCK;
  	private static IBlockState CHISELED_CRAGROCK;
  	private static IBlockState ROOT;
  	private static IBlockState SMOOTH_BETWEENSTONE_WALL;
  	private static IBlockState CRAGROCK_BRICK_WALL;
  	private static IBlockState SMOOTH_CRAGROCK_WALL;
  	private static IBlockState INACTIVE_GLOWING_SMOOTH_CRAGROCK;
  	private static IBlockState AIR;
  
  	private Random lootRng;
  	private SharedLootPoolStorage lootStorage;
  	private ILocationGuard guard;
  	private LocationCragrockTower towerLocation;
  	private BetweenlandsWorldStorage worldStorage;
  
  	private static final ThreadLocal<Boolean> CASCADING_GEN_MUTEX = new ThreadLocal<Boolean>() {
  		@Override
  		protected Boolean initialValue() {
  			return false;
  		}
  	};
  	
  	public WorldGenCragrockTower() {
  		super(17, 64, 19);
  	}
  
  	protected boolean isProtectedBlock(IBlockState state) {
  		Block block = state.getBlock();
  		if(block != Blocks.AIR && block != BlockRegistry.MOB_SPAWNER && block != BlockRegistry.LOOT_POT && block != BlockRegistry.ROOT && block != BlockRegistry.WEAK_SMOOTH_CRAGROCK) {
  			return true;
  		}
  		return false;
  	}
  	
  	@Override
  	protected void setBlockAndNotifyAdequately(World worldIn, BlockPos pos, IBlockState state) {
  		if(this.isProtectedBlock(state)) {
  			this.guard.setGuarded(worldIn, pos, true);
  		} else {
  			this.guard.setGuarded(worldIn, pos, false);
  		}
  		
  		super.setBlockAndNotifyAdequately(worldIn, pos, state);
  		
  		TileEntity tile = worldIn.getTileEntity(pos);
  		
  		if(tile instanceof ISharedLootContainer) {
  			ResourceLocation lootTable = this.getLootTableForBlock(worldIn, pos, state);
  			
  			if(lootTable != null) {
  				((ISharedLootContainer) tile).setSharedLootTable(this.lootStorage, lootTable, this.lootRng.nextLong());
  			}
  		}
  	}
  	
  	@Nullable
  	protected ResourceLocation getLootTableForBlock(World world, BlockPos pos, IBlockState state) {
  		Block block = state.getBlock();
  		
  		if(block == BlockRegistry.LOOT_POT) {
  			return LootTableRegistry.CRAGROCK_TOWER_POT;
  		} else if(block == BlockRegistry.WEEDWOOD_CHEST) {
  			return LootTableRegistry.CRAGROCK_TOWER_CHEST;
  		}
  		
  		return null;
  	}
  	
  	@Override
  	public boolean generate(World worldIn, Random rand, BlockPos pos) {
  		if(CASCADING_GEN_MUTEX.get()) {
  			return false;
  		}
  		
  		CASCADING_GEN_MUTEX.set(true);
  		
  		try {
  			CRAGROCK = BlockRegistry.CRAGROCK.getDefaultState();
  			MOSSY_CRAGROCK_TOP = BlockRegistry.CRAGROCK.getDefaultState().withProperty(BlockCragrock.VARIANT, BlockCragrock.EnumCragrockType.MOSSY_1);
  			MOSSY_CRAGROCK_BOTTOM = BlockRegistry.CRAGROCK.getDefaultState().withProperty(BlockCragrock.VARIANT, BlockCragrock.EnumCragrockType.MOSSY_2);
  			CRAGROCK_BRICKS = BlockRegistry.CRAGROCK_BRICKS.getDefaultState();
  			SMOOTH_CRAGROCK_STAIRS = BlockRegistry.SMOOTH_CRAGROCK_STAIRS.getDefaultState();
  			CRAGROCK_BRICK_SLAB = BlockRegistry.CRAGROCK_BRICK_SLAB.getDefaultState();
  			CRAGROCK_BRICK_SLAB_UPSIDEDOWN = BlockRegistry.CRAGROCK_BRICK_SLAB.getDefaultState().withProperty(BlockSlabBetweenlands.HALF, BlockSlabBetweenlands.EnumBlockHalfBL.TOP);
  			SMOOTH_CRAGROCK_SLAB = BlockRegistry.SMOOTH_CRAGROCK_SLAB.getDefaultState();
  			SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN = BlockRegistry.SMOOTH_CRAGROCK_SLAB.getDefaultState().withProperty(BlockSlabBetweenlands.HALF, BlockSlabBetweenlands.EnumBlockHalfBL.TOP);
  			CRAGROCK_BRICK_STAIRS = BlockRegistry.CRAGROCK_BRICK_STAIRS.getDefaultState();
  			CRAGROCK_PILLAR = BlockRegistry.CRAGROCK_PILLAR.getDefaultState();
  			SMOOTH_CRAGROCK = BlockRegistry.SMOOTH_CRAGROCK.getDefaultState();
  			ROOT = BlockRegistry.ROOT.getDefaultState();
  			SMOOTH_BETWEENSTONE_WALL = BlockRegistry.SMOOTH_BETWEENSTONE_WALL.getDefaultState();
  			CRAGROCK_BRICK_WALL = BlockRegistry.SMOOTH_CRAGROCK_WALL.getDefaultState();
  			SMOOTH_CRAGROCK_WALL = BlockRegistry.SMOOTH_CRAGROCK_WALL.getDefaultState();
  			INACTIVE_GLOWING_SMOOTH_CRAGROCK = BlockRegistry.INACTIVE_GLOWING_SMOOTH_CRAGROCK.getDefaultState();
  			CHISELED_CRAGROCK = BlockRegistry.CRAGROCK_CHISELED.getDefaultState();
  			AIR = Blocks.AIR.getDefaultState();
  	
  			while (worldIn.isAirBlock(pos) && pos.getY() > WorldProviderBetweenlands.LAYER_HEIGHT)
  				pos = pos.add(0, -1, 0);
  	
  	
  			this.worldStorage = BetweenlandsWorldStorage.forWorld(worldIn);
  			this.towerLocation = new LocationCragrockTower(this.worldStorage, new StorageUUID(UUID.randomUUID()), LocalRegion.getFromBlockPos(pos));
  			this.guard = this.towerLocation.getGuard();
  	
  			//Shared loot storage
  			this.lootRng = new Random(rand.nextLong());
  			this.lootStorage = new SharedLootPoolStorage(this.worldStorage, new StorageUUID(UUID.randomUUID()), LocalRegion.getFromBlockPos(pos), rand.nextLong());
  			this.worldStorage.getLocalStorageHandler().addLocalStorage(this.lootStorage);
  			
  			return tower(worldIn, rand, pos.getX(), pos.getY(), pos.getZ());
  		} finally {
  			CASCADING_GEN_MUTEX.set(false);
  		}
  	}
  
  
  	private boolean canGenerate(World world, int x, int y, int z, int direction, int width, int depth) {
  		x -= width / 2;
  		z -= depth / 2;
  		switch (direction) {
  		case 0:
  			for (int yy = y; yy < y + height; yy++)
  				for (int xx = x; xx < x + width; xx++)
  					for (int zz = z; zz < z + depth; zz++) {
  						if (!(world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.BETWEENSTONE || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.CRAGROCK || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.SWAMP_DIRT || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.SWAMP_GRASS || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.WEEDWOOD_BUSH || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() instanceof BlockBush || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock().isReplaceable(world, this.getCheckPos(xx, yy, zz))))
  							return false;
  					}
  			break;
  		case 1:
  			for (int yy = y; yy < y + height; yy++)
  				for (int zz = z + depth - 1; zz > z + depth - width - 1; zz--)
  					for (int xx = x; xx < x + depth; xx++) {
  						if (!(world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.BETWEENSTONE || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.CRAGROCK || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.SWAMP_DIRT || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.SWAMP_GRASS || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.WEEDWOOD_BUSH || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() instanceof BlockBush || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock().isReplaceable(world, this.getCheckPos(xx, yy, zz))))
  							return false;
  
  					}
  			break;
  		case 2:
  			for (int yy = y; yy < y + height; yy++)
  				for (int xx = x + width - 1; xx > x + width - width - 1; xx--)
  					for (int zz = z + depth - 1; zz > z + depth - depth - 1; zz--) {
  						if (!(world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.BETWEENSTONE || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.CRAGROCK || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.SWAMP_DIRT || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.SWAMP_GRASS || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.WEEDWOOD_BUSH || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() instanceof BlockBush || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock().isReplaceable(world, this.getCheckPos(xx, yy, zz))))
  							return false;
  
  					}
  			break;
  		case 3:
  			for (int yy = y; yy < y + height; yy++)
  				for (int zz = z; zz < z + width; zz++)
  					for (int xx = x + width - 1; xx > x + width - depth - 1; xx--) {
  						if (!(world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.BETWEENSTONE || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.CRAGROCK || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.SWAMP_DIRT || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock() == BlockRegistry.SWAMP_GRASS || world.getBlockState(this.getCheckPos(xx, yy, zz)).getBlock().isReplaceable(world, this.getCheckPos(xx, yy, zz))))
  							return false;
  
  					}
  			break;
  		}
  		return true;
  	}
  
  	private boolean tower(World world, Random random, int x, int y, int z) {
  		int direction = random.nextInt(4);
  
  		BlockPos highestPoint = new BlockPos(x, y, z);
  		for(int xo = -8; xo <= 8; xo++) {
  			for(int zo = -8; zo <= 8; zo++) {
  				BlockPos localPoint = world.getHeight(new BlockPos(x + xo, y, z + zo));
  				if(localPoint.getY() - y >= 0 && localPoint.getY() - y <= 5 && localPoint.getY() > highestPoint.getY()) {
  					highestPoint = localPoint;
  				}
  			}
  		}
  		x = highestPoint.getX();
  		y = highestPoint.getY();
  		z = highestPoint.getZ();
  
  		if (!canGenerate(world, x, y, z, direction, 21, 21))
  			return false;
  
  		if (!rotatedCubeMatches(world, x, y, z, 1, -1, 7, 2, 1, 1, direction, SurfaceType.MIXED_GROUND_OR_REPLACEABLE)
  				|| !rotatedCubeMatches(world, x, y, z, 14, -1, 7, 2, 1, 1, direction, SurfaceType.MIXED_GROUND_OR_REPLACEABLE))
  			return false;
  
  		rotatedCubeVolume(world, x, y, z, 0, 0, 3, Blocks.AIR.getDefaultState(), width, height, depth - 3, direction);
  
  		List<BlockPos> inactiveGlowingCragrockBlocks = new ArrayList<BlockPos>();
  		List<BlockPos> inactiveWisps = new ArrayList<BlockPos>();
  		List<BlockPos> blockades = new ArrayList<BlockPos>();
  		BlockPos[][] levelBlockades = new BlockPos[5][];
  
  		//FLOOR 0
  		//WALLS
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 7, 0, 5, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 8, 0, 5, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 9, 0, 5, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 5, 0, 6, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 6, 0, 6, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 10, 0, 6, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 11, 0, 6, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 4, 0, 7, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 4, 0, 8, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 12, 0, 7, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 12, 0, 8, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 3, 0, 9, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 3, 0, 10, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 3, 0, 11, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 13, 0, 9, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 13, 0, 10, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 13, 0, 11, CRAGROCK, 1, 3, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 12, 0, 12, CRAGROCK, 1, 5, 2, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 12, 0, 13, CRAGROCK, 1, 5, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 4, 0, 12, CRAGROCK, 1, 5, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 4, 0, 13, CRAGROCK, 1, 5, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 10, 0, 14, CRAGROCK, 1, 5, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 11, 0, 14, CRAGROCK, 1, 5, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 5, 0, 14, CRAGROCK, 1, 5, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 6, 0, 14, CRAGROCK, 1, 5, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 7, 0, 15, CRAGROCK, 1, 5, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 8, 0, 15, CRAGROCK, 1, 5, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 9, 0, 15, CRAGROCK, 1, 5, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 3, 5, CRAGROCK_BRICKS, 3, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 3, 6, CRAGROCK_BRICKS, 2, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 3, 6, CRAGROCK_BRICKS, 2, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 3, 7, CRAGROCK_BRICKS, 1, 2, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 3, 7, CRAGROCK_BRICKS, 1, 2, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 3, 9, CRAGROCK_BRICKS, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 3, 9, CRAGROCK_BRICKS, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 3, 10, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 3, 10, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 4, 10, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 4, 10, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 3, 11, CRAGROCK, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 3, 11, CRAGROCK, 1, 2, 1, direction);
  
  		//FLOOR
  		rotatedCubeVolume(world, x, y, z, 7, 0, 6, SMOOTH_CRAGROCK, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 0, 7, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 0, 7, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 0, 7, SMOOTH_CRAGROCK, 1, 1, 8, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 0, 7, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 0, 7, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 0, 8, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 0, 8, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 0, 8, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 0, 8, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 0, 8, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 0, 8, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 0, 9, SMOOTH_CRAGROCK, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 0, 9, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 0, 9, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 0, 9, SMOOTH_CRAGROCK, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 0, 9, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 0, 9, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 0, 9, SMOOTH_CRAGROCK, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 0, 10, SMOOTH_CRAGROCK, 7, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 0, 11, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 0, 11, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 0, 11, SMOOTH_CRAGROCK, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 0, 11, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 0, 11, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 0, 12, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 0, 12, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 0, 12, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 0, 12, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 0, 12, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 0, 12, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 0, 13, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 0, 13, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 0, 13, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 0, 13, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 0, 14, SMOOTH_CRAGROCK, 3, 1, 1, direction);
  
  		//CEILING
  		rotatedCubeVolume(world, x, y, z, 7, 4, 6, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 4, 7, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 4, 7, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 4, 7, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 4, 7, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 4, 7, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 4, 8, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 4, 8, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 2, 1, 5, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 4, 8, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 2, 1, 5, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 4, 8, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 4, 9, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 4, 9, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 4, 9, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 4, 9, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 4, 10, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 4, 10, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 4, 11, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 4, 11, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 4, 12, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 4, 12, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 4, 13, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 4, 13, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 4, 13, SMOOTH_CRAGROCK, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 4, 13, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 4, 13, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 4, 14, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 4, 14, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  
  		//INTERIOR
  		rotatedCubeVolume(world, x, y, z, 8, 1, 9, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 2, 10, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 3, 11, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 4, 12, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 1, 10, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 1, 11, SMOOTH_CRAGROCK, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 3, 12, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 3, 13, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 1, 14, SMOOTH_CRAGROCK, 1, 3, 1, direction);
  		rotatedSpawner(world, x, y, z, 8, 2, 13, direction, "thebetweenlands:termite").setMaxEntities(6).setDelayRange(120, 300).setSpawnInAir(false);
  		rotatedCubeVolume(world, x, y, z, 9, 1, 11, ROOT, 1, 2 + random.nextInt(2), 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 1, 10, ROOT, 1, 2 + random.nextInt(2), 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 1, 14, ROOT, 1, 1 + random.nextInt(2), 1, direction);
  		rotatedLootPot(world, random, x, y, z, 9, 1, 14, direction, 1, 2, 3, null);
  		rotatedLootPot(world, random, x, y, z, 12, 1, 9, direction, 1, 2, 3, null);
  		rotatedLootPot(world, random, x, y, z, 12, 1, 10, direction, 1, 2, 3, null);
  		rotatedLootPot(world, random, x, y, z, 12, 1, 11, direction, 1, 2, 3, null);
  
  		//FLOOR 1
  		//WALLS
  		rotatedCubeVolume(world, x, y, z, 7, 5, 5, CRAGROCK_BRICKS, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 5, 6, CRAGROCK_BRICKS, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 5, 6, CRAGROCK_BRICKS, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 5, 7, CRAGROCK_BRICKS, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 5, 7, CRAGROCK_BRICKS, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 5, 9, CRAGROCK_BRICKS, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 5, 9, CRAGROCK_BRICKS, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 5, 12, CRAGROCK_BRICKS, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 5, 12, CRAGROCK_BRICKS, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 5, 14, CRAGROCK_BRICKS, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 5, 14, CRAGROCK_BRICKS, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 5, 15, CRAGROCK_BRICKS, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 6, 5, CHISELED_CRAGROCK, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 6, 6, CHISELED_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 6, 6, CHISELED_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 6, 7, CHISELED_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 6, 7, CHISELED_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 6, 9, CHISELED_CRAGROCK, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 6, 9, CHISELED_CRAGROCK, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 6, 12, CHISELED_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 6, 12, CHISELED_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 6, 14, CHISELED_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 6, 14, CHISELED_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 6, 15, CHISELED_CRAGROCK, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 7, 5, CRAGROCK_BRICKS, 3, 6, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 7, 6, CRAGROCK_BRICKS, 2, 6, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 7, 6, CRAGROCK_BRICKS, 2, 6, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 7, 7, CRAGROCK_BRICKS, 1, 6, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 7, 7, CRAGROCK_BRICKS, 1, 6, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 7, 9, CRAGROCK_BRICKS, 1, 6, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 7, 9, CRAGROCK_BRICKS, 1, 6, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 7, 12, CRAGROCK_BRICKS, 1, 6, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 7, 12, CRAGROCK_BRICKS, 1, 6, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 7, 14, CRAGROCK_BRICKS, 2, 6, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 7, 14, CRAGROCK_BRICKS, 2, 6, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 7, 15, CRAGROCK_BRICKS, 3, 6, 1, direction);
  
  		//CEILING
  		rotatedCubeVolume(world, x, y, z, 7, 9, 6, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 9, 7, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 9, 7, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 9, 7, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 9, 7, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 9, 7, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 9, 8, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 9, 8, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 2, 1, 5, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 9, 8, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 2, 1, 5, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 9, 8, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 9, 9, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 9, 9, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 9, 9, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 9, 9, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 9, 10, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 9, 10, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 9, 11, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 9, 11, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 9, 12, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 9, 12, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 9, 13, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 9, 13, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 9, 13, CRAGROCK_BRICKS, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 9, 13, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 9, 13, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 9, 14, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 9, 14, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  
  		//INTERIOR
  		rotatedCubeVolume(world, x, y, z, 8, 5, 8, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 6, 9, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 7, 10, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 8, 11, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 9, 12, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 5, 9, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 6, 10, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 7, 11, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 8, 12, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 8, 14, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 7, 15, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 5, 15, Blocks.AIR.getDefaultState(), 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 5, 7, SMOOTH_BETWEENSTONE_WALL, 1, 4, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 5, 7, SMOOTH_BETWEENSTONE_WALL, 1, 4, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 5, 13, SMOOTH_BETWEENSTONE_WALL, 1, 4, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 5, 13, SMOOTH_BETWEENSTONE_WALL, 1, 4, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 5, 11, ROOT, 1, 2 + random.nextInt(2), 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 5, 6, ROOT, 1, 2 + random.nextInt(2), 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 5, 14, ROOT, 1, 2 + random.nextInt(2), 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 5, 10, ROOT, 1, 2 + random.nextInt(2), 1, direction);
  		rotatedLootPot(world, random, x, y, z, 8, 5, 6, direction, 1, 2, 3, null);
  
  		//FLOOR 2
  		//CEILING/WALLS
  		rotatedCubeVolume(world, x, y, z, 7, 12, 6, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 12, 7, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 12, 7, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 12, 7, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 12, 7, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 12, 8, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 12, 8, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 12, 9, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 12, 9, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 12, 9, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 12, 9, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 12, 11, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 12, 11, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 12, 12, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 12, 12, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 12, 13, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 12, 13, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 12, 13, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 12, 13, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 12, 14, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 12, 13, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 12, 10, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 12, 7, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 12, 10, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 13, 13, CRAGROCK_BRICK_WALL, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 13, 10, CRAGROCK_BRICK_WALL, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 13, 7, CRAGROCK_BRICK_WALL, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 13, 10, CRAGROCK_BRICK_WALL, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 14, 13, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 14, 10, SMOOTH_CRAGROCK, 7, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 14, 7, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 14, 8, SMOOTH_CRAGROCK, 5, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 14, 9, SMOOTH_CRAGROCK, 5, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 14, 11, SMOOTH_CRAGROCK, 4, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 14, 11, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 13, 6, CRAGROCK_BRICKS, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 13, 7, CRAGROCK_BRICKS, 2, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 13, 7, CRAGROCK_BRICKS, 2, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 13, 8, CRAGROCK_BRICKS, 1, 3, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 13, 8, CRAGROCK_BRICKS, 1, 3, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 13, 10, CRAGROCK_BRICKS, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 13, 10, CRAGROCK_BRICKS, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 13, 11, CRAGROCK_BRICKS, 1, 3, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 13, 11, CRAGROCK_BRICKS, 1, 3, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 13, 13, CRAGROCK_BRICKS, 2, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 13, 13, CRAGROCK_BRICKS, 2, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 13, 14, CRAGROCK_BRICKS, 1, 3, 1, direction);
  
  		//BLOCKADE 1
  		blockades.clear();
  		rotatedCubeVolume(world, x, y, z, 7, 14, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 4, 1, 1, direction, pos -> blockades.add(pos));
  		levelBlockades[0] = blockades.toArray(new BlockPos[0]);
  
  		//INTERIOR
  		rotatedCubeVolume(world, x, y, z, 5, 10, 7, SMOOTH_BETWEENSTONE_WALL, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 10, 7, SMOOTH_BETWEENSTONE_WALL, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 10, 13, SMOOTH_BETWEENSTONE_WALL, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 10, 13, SMOOTH_BETWEENSTONE_WALL, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 10, 8, SMOOTH_BETWEENSTONE_WALL, 1, 4, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 10, 12, SMOOTH_BETWEENSTONE_WALL, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 10, 12, SMOOTH_BETWEENSTONE_WALL, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 10, 8, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 10, 9, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 10, 10, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 11, 10, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 11, 11, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 11, 12, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 12, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 12, 12, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 12, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 13, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 13, 12, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 13, 12, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 14, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 10, 9, ROOT, 1, 1 + random.nextInt(2), 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 10, 11, ROOT, 1, 1 + random.nextInt(2), 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 10, 13, ROOT, 1, 1 + random.nextInt(2), 1, direction);
  		rotatedLootPot(world, random, x, y, z, 7, 10, 14, direction, 1, 2, 4, null);
  		rotatedLootPot(world, random, x, y, z, 8, 10, 14, direction, 1, 2, 4, null);
  		rotatedLootPot(world, random, x, y, z, 9, 10, 14, direction, 1, 2, 4, null);
  		rotatedLootPot(world, random, x, y, z, 12, 10, 9, direction, 1, 2, 4, null);
  		rotatedLootPot(world, random, x, y, z, 12, 10, 10, direction, 1, 2, 4, null);
  		rotatedLootPot(world, random, x, y, z, 12, 10, 11, direction, 1, 2, 4, null);
  
  		//FLOOR 3
  		//WALLS
  		rotatedCubeVolume(world, x, y, z, 8, 16, 6, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 16, 7, CHISELED_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 16, 7, CHISELED_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 16, 8, CHISELED_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 16, 8, CHISELED_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 16, 10, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 16, 10, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 16, 11, CHISELED_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 16, 11, CHISELED_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 16, 13, CHISELED_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 16, 13, CHISELED_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 16, 14, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 17, 6, SMOOTH_CRAGROCK, 1, 7, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 17, 7, SMOOTH_CRAGROCK, 2, 7, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 17, 7, SMOOTH_CRAGROCK, 2, 7, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 17, 8, SMOOTH_CRAGROCK, 1, 7, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 17, 8, SMOOTH_CRAGROCK, 1, 7, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 17, 10, SMOOTH_CRAGROCK, 1, 7, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 17, 10, SMOOTH_CRAGROCK, 1, 7, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 17, 11, SMOOTH_CRAGROCK, 1, 7, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 17, 11, SMOOTH_CRAGROCK, 1, 7, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 17, 13, SMOOTH_CRAGROCK, 2, 7, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 17, 13, SMOOTH_CRAGROCK, 2, 7, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 17, 14, SMOOTH_CRAGROCK, 1, 7, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 15, 7, SMOOTH_CRAGROCK_WALL, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 15, 13, CRAGROCK_BRICK_WALL, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 15, 10, CRAGROCK_BRICK_WALL, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 17, 7, CRAGROCK_BRICK_WALL, 1, 6, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 15, 10, CRAGROCK_BRICK_WALL, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 16, 7, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 18, 10, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 20, 13, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 22, 10, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 24, 6, CHISELED_CRAGROCK, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 24, 7, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 24, 7, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 24, 8, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 24, 8, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 24, 9, CHISELED_CRAGROCK, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 24, 9, CHISELED_CRAGROCK, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 24, 12, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 24, 12, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 24, 13, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 24, 13, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 24, 14, CHISELED_CRAGROCK, 3, 1, 1, direction);
  
  		//INTERIOR
  		rotatedCubeVolume(world, x, y, z, 8, 15, 10, CRAGROCK_BRICK_WALL, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 16, 10, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedSpawner(world, x, y, z, 8, 17, 10, direction, "thebetweenlands:chiromaw").setMaxEntities(4).setCheckRange(16.0D).setSpawnRange(3).setDelayRange(180, 500);
  		rotatedCubeVolume(world, x, y, z, 6, 15, 8, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 15, 8, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 15, 8, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 16, 8, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 16, 8, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 16, 8, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 17, 8, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 17, 9, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 17, 10, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 18, 10, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 18, 11, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 18, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 19, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 19, 12, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 19, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 20, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 20, 12, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 20, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 21, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 21, 11, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 21, 10, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 22, 10, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 22, 9, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 22, 8, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 23, 8, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 22, 8, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 4, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 22, 9, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 4, direction);
  		rotatedLootPot(world, random, x, y, z, 10, 15, 8, direction, 2, 3, 3, null);
  		rotatedLootPot(world, random, x, y, z, 9, 15, 8, direction, 2, 3, 3, null);
  
  		//CEILING
  		rotatedCubeVolume(world, x, y, z, 7, 23, 7, SMOOTH_CRAGROCK, 4, 1, 7, direction);
  
  		//BLOCKADE 2
  		blockades.clear();
  		rotatedCubeVolume(world, x, y, z, 6, 23, 9, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 4, direction, pos -> blockades.add(pos));
  		levelBlockades[1] = blockades.toArray(new BlockPos[0]);
  
  		rotatedCubeVolume(world, x, y, z, 7, 23, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 23, 10, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 23, 10, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  
  
  		//WALLS FLOOR 4/5/6
  		rotatedCubeVolume(world, x, y, z, 7, 25, 6, SMOOTH_CRAGROCK, 3, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 25, 7, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 25, 7, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 25, 8, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 25, 8, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 25, 9, SMOOTH_CRAGROCK, 1, 8, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 25, 9, SMOOTH_CRAGROCK, 1, 8, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 25, 12, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 25, 12, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 25, 13, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 25, 13, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 25, 14, SMOOTH_CRAGROCK, 3, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 33, 6, CHISELED_CRAGROCK, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 33, 7, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 33, 7, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 33, 8, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 33, 8, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 33, 9, CHISELED_CRAGROCK, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 33, 9, CHISELED_CRAGROCK, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 33, 12, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 33, 12, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 33, 13, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 33, 13, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 33, 14, CHISELED_CRAGROCK, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 34, 6, SMOOTH_CRAGROCK, 3, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 34, 7, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 34, 7, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 34, 8, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 34, 8, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 34, 9, SMOOTH_CRAGROCK, 1, 8, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 34, 9, SMOOTH_CRAGROCK, 1, 8, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 34, 12, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 34, 12, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 34, 13, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 34, 13, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 34, 14, SMOOTH_CRAGROCK, 3, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 42, 6, CHISELED_CRAGROCK, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 42, 7, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 42, 7, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 42, 8, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 42, 8, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 42, 9, CHISELED_CRAGROCK, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 42, 9, CHISELED_CRAGROCK, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 42, 12, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 42, 12, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 42, 13, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 42, 13, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 42, 14, CHISELED_CRAGROCK, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 43, 6, SMOOTH_CRAGROCK, 3, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 43, 7, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 43, 7, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 43, 8, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 43, 8, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 43, 9, SMOOTH_CRAGROCK, 1, 8, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 43, 9, SMOOTH_CRAGROCK, 1, 8, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 43, 12, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 43, 12, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 43, 13, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 43, 13, SMOOTH_CRAGROCK, 1, 8, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 43, 14, SMOOTH_CRAGROCK, 3, 8, 1, direction);
  
  		//FLOOR 4
  		//INTERIOR
  		rotatedCubeVolume(world, x, y, z, 8, 24, 10, CRAGROCK_BRICK_WALL, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 25, 10, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedSpawner(world, x, y, z, 8, 26, 10, direction, "thebetweenlands:swamp_hag").setMaxEntities(3).setCheckRange(16.0D).setDelayRange(180, 500).setSpawnInAir(false);
  		rotatedCubeVolume(world, x, y, z, 10, 24, 8, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 24, 9, SMOOTH_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 24, 10, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 25, 10, SMOOTH_CRAGROCK_SLAB, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 25, 11, SMOOTH_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 25, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 26, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 26, 12, SMOOTH_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 26, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 27, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 27, 12, SMOOTH_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 27, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 28, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 28, 11, SMOOTH_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 28, 10, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 29, 10, SMOOTH_CRAGROCK_SLAB, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 29, 9, SMOOTH_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 29, 8, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 30, 8, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 30, 7, SMOOTH_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 30, 7, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 31, 7, SMOOTH_CRAGROCK_SLAB, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 31, 7, SMOOTH_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 31, 8, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 32, 8, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 31, 9, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 31, 9, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 31, 11, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 31, 11, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 31, 12, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 31, 12, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 31, 13, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 31, 13, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 31, 13, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 31, 12, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 31, 12, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 31, 10, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 30, 10, INACTIVE_GLOWING_SMOOTH_CRAGROCK, 1, 1, 1, direction, pos -> inactiveGlowingCragrockBlocks.add(pos));
  		rotatedCubeVolume(world, x, y, z, 11, 29, 10, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedLootPot(world, random, x, y, z, 8, 24, 13, direction, 2, 3, 4, null);
  		rotatedLootPot(world, random, x, y, z, 7, 24, 13, direction, 2, 3, 4, null);
  		rotatedLootPot(world, random, x, y, z, 9, 24, 13, direction, 2, 3, 4, null);
  		rotatedLootPot(world, random, x, y, z, 10, 24, 12, direction, 2, 3, 4, null);
  		rotatedLootPot(world, random, x, y, z, 10, 24, 11, direction, 2, 3, 4, null);
  
  		//CEILING
  		rotatedCubeVolume(world, x, y, z, 5, 32, 9, SMOOTH_CRAGROCK, 7, 1, 4, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 32, 9, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 32, 13, SMOOTH_CRAGROCK, 3, 1, 1, direction);
  
  		//BLOCKADE 3
  		blockades.clear();
  		rotatedCubeVolume(world, x, y, z, 6, 32, 8, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 4, 1, 1, direction, pos -> blockades.add(pos));
  		rotatedCubeVolume(world, x, y, z, 7, 32, 7, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 3, 1, 1, direction, pos -> blockades.add(pos));
  		levelBlockades[2] = blockades.toArray(new BlockPos[0]);
  
  		//FLOOR 5
  		//INTERIOR
  		rotatedCubeVolume(world, x, y, z, 8, 33, 10, CRAGROCK_BRICK_WALL, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 34, 10, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  
  		NBTTagCompound nbt = new NBTTagCompound();
  		NBTTagCompound entityNbt = new NBTTagCompound();
  		entityNbt.setString("id", "thebetweenlands:pyrad");
  		EntityPyrad pyrad = new EntityPyrad(world);
  		pyrad.getEntityAttribute(EntityPyrad.AGRESSIVE).setBaseValue(1);
  		entityNbt.setTag("Attributes", SharedMonsterAttributes.writeBaseAttributeMapToNBT(pyrad.getAttributeMap()));
  		nbt.setTag("Entity", entityNbt);
  		rotatedSpawner(world, x, y, z, 8, 35, 10, direction, "thebetweenlands:pyrad")
  		.setMaxEntities(3)
  		.setCheckRange(16.0D)
  		.setDelayRange(180, 500)
  		.setSpawnInAir(false)
  		.setNextEntity(new WeightedSpawnerEntity(nbt));
  
  		rotatedCubeVolume(world, x, y, z, 10, 33, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 33, 12, SMOOTH_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 33, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 34, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 34, 12, SMOOTH_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 34, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 35, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 35, 11, SMOOTH_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 35, 10, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 36, 10, SMOOTH_CRAGROCK_SLAB, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 36, 9, SMOOTH_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 36, 8, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 37, 8, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 37, 7, SMOOTH_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 37, 7, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 38, 7, SMOOTH_CRAGROCK_SLAB, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 38, 7, SMOOTH_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 38, 8, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 39, 8, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 39, 9, SMOOTH_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 39, 10, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 40, 10, SMOOTH_CRAGROCK_SLAB, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 40, 11, SMOOTH_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 40, 12, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 41, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 40, 12, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 40, 13, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 40, 13, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 40, 12, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 40, 12, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 40, 11, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 40, 10, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 40, 9, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 40, 9, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 40, 8, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 40, 13, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 39, 13, INACTIVE_GLOWING_SMOOTH_CRAGROCK, 1, 1, 1, direction, pos -> inactiveGlowingCragrockBlocks.add(pos));
  		rotatedCubeVolume(world, x, y, z, 8, 38, 13, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedLootPot(world, random, x, y, z, 7, 33, 12, direction, 2, 5, 3, null);
  		rotatedLootPot(world, random, x, y, z, 6, 33, 12, direction, 2, 5, 3, null);
  		rotatedLootPot(world, random, x, y, z, 5, 33, 11, direction, 2, 5, 3, null);
  		rotatedLootPot(world, random, x, y, z, 5, 33, 10, direction, 2, 5, 3, null);
  		rotatedLootPot(world, random, x, y, z, 5, 33, 9, direction, 2, 5, 3, null);
  
  		//CEILING
  		rotatedCubeVolume(world, x, y, z, 6, 41, 7, SMOOTH_CRAGROCK, 4, 1, 7, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 41, 8, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 41, 9, SMOOTH_CRAGROCK, 1, 1, 3, direction);
  
  		//BLOCKADE 4
  		blockades.clear();
  		rotatedCubeVolume(world, x, y, z, 10, 41, 8, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 4, direction, pos -> blockades.add(pos));
  		rotatedCubeVolume(world, x, y, z, 11, 41, 9, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 3, direction, pos -> blockades.add(pos));
  		levelBlockades[3] = blockades.toArray(new BlockPos[0]);
  
  		//FLOOR 6
  		//INTERIOR
  		rotatedCubeVolume(world, x, y, z, 8, 42, 10, CRAGROCK_BRICK_WALL, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 43, 10, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedSpawner(world, x, y, z, 8, 44, 10, direction, "thebetweenlands:wight").setMaxEntities(2).setCheckRange(24.0D).setDelayRange(300, 600).setSpawnInAir(false);
  		rotatedCubeVolume(world, x, y, z, 6, 42, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 42, 11, SMOOTH_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 42, 10, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 43, 10, SMOOTH_CRAGROCK_SLAB, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 43, 9, SMOOTH_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 43, 8, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 44, 8, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 44, 7, SMOOTH_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 44, 7, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 45, 7, SMOOTH_CRAGROCK_SLAB, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 45, 7, SMOOTH_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 45, 8, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 46, 8, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 46, 9, SMOOTH_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 46, 10, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 47, 10, SMOOTH_CRAGROCK_SLAB, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 47, 11, SMOOTH_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 47, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 48, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 48, 12, SMOOTH_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 48, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 49, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 49, 12, SMOOTH_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 49, 12, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 50, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 49, 11, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 49, 11, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 49, 9, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 49, 9, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 49, 8, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 49, 8, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 49, 7, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 49, 7, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 49, 7, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 49, 8, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 49, 8, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 49, 10, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 48, 10, INACTIVE_GLOWING_SMOOTH_CRAGROCK, 1, 1, 1, direction, pos -> inactiveGlowingCragrockBlocks.add(pos));
  		rotatedCubeVolume(world, x, y, z, 5, 47, 10, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedLootPot(world, random, x, y, z, 8, 42, 7, direction, 3, 7, 4, null);
  		rotatedLootPot(world, random, x, y, z, 7, 42, 7, direction, 3, 7, 4, null);
  		rotatedLootPot(world, random, x, y, z, 9, 42, 7, direction, 3, 7, 4, null);
  		rotatedLootPot(world, random, x, y, z, 6, 42, 8, direction, 3, 7, 4, null);
  		rotatedLootPot(world, random, x, y, z, 6, 42, 9, direction, 3, 7, 4, null);
  
  		//CEILING
  		rotatedCubeVolume(world, x, y, z, 5, 50, 8, SMOOTH_CRAGROCK, 7, 1, 4, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 50, 11, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 50, 7, SMOOTH_CRAGROCK, 3, 1, 1, direction);
  
  		//BLOCKADE 5
  		blockades.clear();
  		rotatedCubeVolume(world, x, y, z, 7, 50, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 4, 1, 1, direction, pos -> blockades.add(pos));
  		rotatedCubeVolume(world, x, y, z, 7, 50, 13, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 3, 1, 1, direction, pos -> blockades.add(pos));
  		levelBlockades[4] = blockades.toArray(new BlockPos[0]);
  
  		//TOP FLOOR
  		rotatedCubeVolume(world, x, y, z, 7, 51, 6, SMOOTH_CRAGROCK_SLAB, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 51, 7, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 51, 7, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 51, 8, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 51, 8, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 51, 9, SMOOTH_CRAGROCK_SLAB, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 51, 9, SMOOTH_CRAGROCK_SLAB, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 51, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 51, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 51, 13, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 51, 13, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 51, 14, SMOOTH_CRAGROCK_SLAB, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 51, 5, CHISELED_CRAGROCK, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 51, 6, CHISELED_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 51, 6, CHISELED_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 51, 7, CHISELED_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 51, 7, CHISELED_CRAGROCK, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 51, 8, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 51, 8, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 51, 9, CHISELED_CRAGROCK, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 51, 9, CHISELED_CRAGROCK, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 51, 12, CHISELED_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 51, 12, CHISELED_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 51, 13, CHISELED_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 51, 13, CHISELED_CRAGROCK, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 51, 14, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 51, 14, CHISELED_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 51, 15, CHISELED_CRAGROCK, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 51, 4, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 51, 5, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 51, 5, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 51, 6, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 51, 6, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 51, 7, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 51, 7, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 51, 9, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 51, 9, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 51, 12, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 51, 12, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 3, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 51, 14, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 51, 14, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 51, 15, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 51, 15, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 51, 16, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 52, 4, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 52, 4, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 52, 4, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 52, 5, MOSSY_CRAGROCK_TOP, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 52, 5, MOSSY_CRAGROCK_TOP, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 52, 6, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 52, 6, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 52, 7, MOSSY_CRAGROCK_TOP, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 52, 7, MOSSY_CRAGROCK_TOP, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 52, 9, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 52, 10, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 52, 11, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 52, 9, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 52, 10, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 52, 11, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 52, 12, MOSSY_CRAGROCK_TOP, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 52, 14, CRAGROCK_PILLAR, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 52, 12, MOSSY_CRAGROCK_TOP, 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 52, 14, CRAGROCK_PILLAR, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 52, 14, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 52, 14, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 52, 15, MOSSY_CRAGROCK_TOP, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 52, 15, MOSSY_CRAGROCK_TOP, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 52, 16, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 52, 16, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 52, 16, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 53, 4, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 53, 4, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 53, 4, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 53, 6, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 53, 6, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 53, 9, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 53, 10, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 53, 11, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 53, 9, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 53, 10, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 53, 11, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 53, 14, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 53, 14, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 53, 16, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 53, 16, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 53, 16, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 54, 4, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 54, 10, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 54, 10, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 54, 16, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 53, 14, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 53, 14, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 54, 14, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 54, 14, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 55, 14, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		rotatedCubeVolume(world, x, y, z, 13, 55, 14, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		rotatedCubeVolume(world, x, y, z, 3, 52, 11, CRAGROCK_PILLAR, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 55, 11, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 56, 11, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 57, 11, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		rotatedCubeVolume(world, x, y, z, 3, 53, 8, CRAGROCK_PILLAR, 1, 4, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 57, 8, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 58, 8, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 59, 8, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		rotatedCubeVolume(world, x, y, z, 5, 53, 5, CRAGROCK_PILLAR, 1, 6, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 59, 5, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 60, 5, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 61, 5, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		rotatedCubeVolume(world, x, y, z, 8, 55, 4, CRAGROCK_PILLAR, 1, 6, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 61, 4, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 62, 4, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 63, 4, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		rotatedCubeVolume(world, x, y, z, 11, 53, 5, CRAGROCK_PILLAR, 1, 6, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 59, 5, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 60, 5, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 61, 5, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		rotatedCubeVolume(world, x, y, z, 13, 53, 8, CRAGROCK_PILLAR, 1, 4, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 57, 8, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 58, 8, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 59, 8, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		rotatedCubeVolume(world, x, y, z, 13, 52, 11, CRAGROCK_PILLAR, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 55, 11, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 56, 11, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 57, 11, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		rotatedCubeVolume(world, x, y, z, 8, 52, 5, CRAGROCK_BRICK_WALL, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 53, 5, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedSpawner(world, x, y, z, 8, 54, 5, direction, "thebetweenlands:swamp_hag").setMaxEntities(3).setCheckRange(10.0D).setDelayRange(150, 500).setSpawnInAir(false);
  		rotatedCubeVolume(world, x, y, z, 8, 52, 15, CRAGROCK_BRICK_WALL, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 53, 15, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedSpawner(world, x, y, z, 8, 54, 15, direction, "thebetweenlands:wight").setMaxEntities(2).setCheckRange(24.0D).setDelayRange(300, 600).setSpawnInAir(false);
  		rotatedLootChest(world, random, x, y, z, 7, 52, 5, direction, 5, 8, 2, 0, null);
  		rotatedLootChest(world, random, x, y, z, 9, 52, 5, direction, 5, 8, 2, 0, null);
  		rotatedLootChest(world, random, x, y, z, 7, 52, 15, direction, 5, 8, 2, 2, null);
  		rotatedLootPot(world, random, x, y, z, 10, 52, 6, direction, 3, 4, 3, null);
  		rotatedLootPot(world, random, x, y, z, 11, 52, 6, direction, 3, 4, 3, null);
  		rotatedLootPot(world, random, x, y, z, 6, 52, 6, direction, 3, 4, 3, null);
  		rotatedLootPot(world, random, x, y, z, 5, 52, 6, direction, 3, 4, 3, null);
  		rotatedLootPot(world, random, x, y, z, 12, 52, 8, direction, 3, 4, 3, null);
  		rotatedLootPot(world, random, x, y, z, 12, 52, 12, direction, 3, 4, 3, null);
  		rotatedLootPot(world, random, x, y, z, 12, 52, 13, direction, 3, 4, 3, null);
  		rotatedLootPot(world, random, x, y, z, 3, 52, 10, direction, 3, 4, 3, null);
  		rotatedCubeVolume(world, x, y, z, 7, 51, 7, ROOT, 1, 2 + random.nextInt(5), 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 51, 11, ROOT, 1, 1 + random.nextInt(2), 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 52, 9, ROOT, 1, 2 + random.nextInt(3), 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 52, 13, ROOT, 1, 1 + random.nextInt(3), 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 52, 15, ROOT, 1, 2 + random.nextInt(3), 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 52, 7, ROOT, 1, 1 + random.nextInt(3), 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 52, 10, ROOT, 1, 1 + random.nextInt(2), 1, direction);
  
  
  		//OUTSIDE DECORATION
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 0, 0, 6, CRAGROCK_PILLAR, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 0, 1, 6, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 0, 2, 6, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 0, 3, 6, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 0, 0, 9, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 0, 1, 9, CRAGROCK_PILLAR, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 0, 3, 9, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 0, 4, 9, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 0, 5, 9, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 0, 0, 12, CRAGROCK_PILLAR, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 0, 2, 12, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 0, 3, 12, CRAGROCK_PILLAR, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 0, 5, 12, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 0, 6, 12, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 0, 7, 12, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		if (isReplaceable(world, x, y, z, 2, -1, 15, direction))
  			rotatedCubeVolumeExtendedDown(world, x, y, z, 2, -1, 15, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 0, 15, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 1, 15, CRAGROCK_PILLAR, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 3, 15, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 4, 15, CRAGROCK_PILLAR, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 7, 15, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 8, 15, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 9, 15, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		if (isReplaceable(world, x, y, z, 5, -1, 17, direction))
  			rotatedCubeVolumeExtendedDown(world, x, y, z, 5, -1, 17, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 0, 17, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 1, 17, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 2, 17, CRAGROCK_PILLAR, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 4, 17, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 5, 17, CRAGROCK_PILLAR, 1, 4, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 9, 17, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 10, 17, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 11, 17, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 8, 0, 18, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 1, 18, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 2, 18, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 3, 18, CRAGROCK_PILLAR, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 4, 18, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 5, 18, CRAGROCK_PILLAR, 1, 6, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 11, 18, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 12, 18, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 13, 18, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 16, 0, 6, CRAGROCK_PILLAR, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 16, 1, 6, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 16, 2, 6, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 16, 3, 6, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 16, 0, 9, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 16, 1, 9, CRAGROCK_PILLAR, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 16, 3, 9, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 16, 4, 9, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 16, 5, 9, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 16, 0, 12, CRAGROCK_PILLAR, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 16, 2, 12, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 16, 3, 12, CRAGROCK_PILLAR, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 16, 5, 12, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 16, 6, 12, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 16, 7, 12, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		rotatedCubeVolume(world, x, y, z, 14, 0, 15, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		if (isReplaceable(world, x, y, z, 14, -1, 15, direction))
  			rotatedCubeVolumeExtendedDown(world, x, y, z, 14, -1, 15, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 1, 15, CRAGROCK_PILLAR, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 3, 15, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 4, 15, CRAGROCK_PILLAR, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 7, 15, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 8, 15, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 9, 15, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  		if (isReplaceable(world, x, y, z, 11, -1, 17, direction))
  			rotatedCubeVolumeExtendedDown(world, x, y, z, 11, -1, 17, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 0, 17, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 1, 17, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 2, 17, CRAGROCK_PILLAR, 1, 2, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 4, 17, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 5, 17, CRAGROCK_PILLAR, 1, 4, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 9, 17, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 10, 17, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 11, 17, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  
  		//STAIRS 1
  		int stair1Length = 16;
  		for(int steps = 0; steps < 17; steps++) {
  			BlockPos stairPosRight = this.rotatePos(world, x, y, z, 1, -1 - steps, 8 - steps*2, direction);
  			BlockPos stairPosLeft = this.rotatePos(world, x, y, z, 2, -1 - steps, 8 - steps*2, direction);
  			IBlockState stairBlockRight = world.getBlockState(stairPosRight);
  			IBlockState stairBlockLeft = world.getBlockState(stairPosLeft);
  			if(!stairBlockRight.getBlock().isReplaceable(world, stairPosRight) || stairBlockRight.getMaterial().isLiquid() ||
  					!stairBlockLeft.getBlock().isReplaceable(world, stairPosLeft) || stairBlockLeft.getMaterial().isLiquid() || steps == 16) {
  				stair1Length = steps;
  
  				if(world.getBlockState(stairPosRight).getBlock().isReplaceable(world, stairPosRight)) {
  					this.setBlockAndNotifyAdequately(world, stairPosRight, CRAGROCK_BRICKS);
  				}
  
  				if(world.getBlockState(stairPosLeft).getBlock().isReplaceable(world, stairPosLeft)) {
  					this.setBlockAndNotifyAdequately(world, stairPosLeft, SMOOTH_CRAGROCK);
  				}
  
  				break;
  			}
  
  			if(steps % 2 == 0) {
  				rotatedCubeVolumeExtendedDown(world, x, y, z, 0,  - steps, 6 - steps*2, CRAGROCK_PILLAR, 1, 1, 1, direction);
  				rotatedCubeVolume(world, x, y, z, 0, 1 - steps, 6 - steps*2, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  				rotatedCubeVolume(world, x, y, z, 0, 2 - steps, 6 - steps*2, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  				rotatedCubeVolume(world, x, y, z, 0, 3 - steps, 6 - steps*2, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  
  				rotatedCubeVolumeExtendedDown(world, x, y, z, 3,  - steps, 6 - steps*2, CRAGROCK_PILLAR, 1, 1, 1, direction);
  				rotatedCubeVolume(world, x, y, z, 3, 1 - steps, 6 - steps*2, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  				rotatedCubeVolume(world, x, y, z, 3, 2 - steps, 6 - steps*2, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  				rotatedCubeVolume(world, x, y, z, 3, 3 - steps, 6 - steps*2, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  			}
  
  			rotatedCubeVolume(world, x, y, z, 1, -1 - steps, 8 - steps*2, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  			rotatedCubeVolume(world, x, y, z, 2, -1 - steps, 8 - steps*2, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  			rotatedCubeVolume(world, x, y, z, 1, -1 - steps, 7 - steps*2, CRAGROCK_BRICKS, 1, 1, 1, direction);
  			rotatedCubeVolume(world, x, y, z, 2, -1 - steps, 7 - steps*2, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  			rotatedCubeVolume(world, x, y, z, 1, -1 - steps, 6 - steps*2, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  			rotatedCubeVolume(world, x, y, z, 2, -1 - steps, 6 - steps*2, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		}
  
  		//STAIRS 2
  		int stair2Length = 16;
  		for(int steps = 0; steps < 17; steps++) {
  			BlockPos stairPosRight = this.rotatePos(world, x, y, z, 1 + 13, -1 - steps, 8 - steps*2, direction);
  			BlockPos stairPosLeft = this.rotatePos(world, x, y, z, 2 + 13, -1 - steps, 8 - steps*2, direction);
  			IBlockState stairBlockRight = world.getBlockState(stairPosRight);
  			IBlockState stairBlockLeft = world.getBlockState(stairPosLeft);
  			if(!stairBlockRight.getBlock().isReplaceable(world, stairPosRight) || stairBlockRight.getMaterial().isLiquid() ||
  					!stairBlockLeft.getBlock().isReplaceable(world, stairPosLeft) || stairBlockLeft.getMaterial().isLiquid() || steps == 16) {
  				stair2Length = steps;
  
  				if(world.getBlockState(stairPosRight).getBlock().isReplaceable(world, stairPosRight)) {
  					this.setBlockAndNotifyAdequately(world, stairPosRight, SMOOTH_CRAGROCK);
  				}
  
  				if(world.getBlockState(stairPosLeft).getBlock().isReplaceable(world, stairPosLeft)) {
  					this.setBlockAndNotifyAdequately(world, stairPosLeft, CRAGROCK_BRICKS);
  				}
  
  				break;
  			}
  
  			if(steps % 2 == 0) {
  				rotatedCubeVolumeExtendedDown(world, x, y, z, 0 + 13,  - steps, 6 - steps*2, CRAGROCK_PILLAR, 1, 1, 1, direction);
  				rotatedCubeVolume(world, x, y, z, 0 + 13, 1 - steps, 6 - steps*2, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  				rotatedCubeVolume(world, x, y, z, 0 + 13, 2 - steps, 6 - steps*2, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  				rotatedCubeVolume(world, x, y, z, 0 + 13, 3 - steps, 6 - steps*2, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  
  				rotatedCubeVolumeExtendedDown(world, x, y, z, 3 + 13,  - steps, 6 - steps*2, CRAGROCK_PILLAR, 1, 1, 1, direction);
  				rotatedCubeVolume(world, x, y, z, 3 + 13, 1 - steps, 6 - steps*2, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  				rotatedCubeVolume(world, x, y, z, 3 + 13, 2 - steps, 6 - steps*2, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  				rotatedCubeVolume(world, x, y, z, 3 + 13, 3 - steps, 6 - steps*2, AIR, 1, 1, 1, direction, pos -> inactiveWisps.add(pos));
  			}
  
  			rotatedCubeVolume(world, x, y, z, 2 + 13, -1 - steps, 8 - steps*2, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  			rotatedCubeVolume(world, x, y, z, 1 + 13, -1 - steps, 8 - steps*2, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  			rotatedCubeVolume(world, x, y, z, 2 + 13, -1 - steps, 7 - steps*2, CRAGROCK_BRICKS, 1, 1, 1, direction);
  			rotatedCubeVolume(world, x, y, z, 1 + 13, -1 - steps, 7 - steps*2, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  			rotatedCubeVolume(world, x, y, z, 2 + 13, -1 - steps, 6 - steps*2, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  			rotatedCubeVolume(world, x, y, z, 1 + 13, -1 - steps, 6 - steps*2, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		}
  
  		int stairsLength = Math.max(stair2Length, stair1Length);
  
  
  		AxisAlignedBB stairsAABB;
  
  		switch(direction) {
  		default:
  		case 0:
  			stairsAABB = new AxisAlignedBB(x - 8, y - stairsLength - 8, z - stairsLength * 2 - 1, x + 9, y, z);
  			break;
  		case 1:
  			stairsAABB = new AxisAlignedBB(x - stairsLength * 2, y - stairsLength - 8, z - 7, x + 1, y, z + 10);
  			break;
  		case 2:
  			stairsAABB = new AxisAlignedBB(x - 8, y - stairsLength - 8, z + stairsLength * 2 + 2, x + 9, y, z);
  			break;
  		case 3:
  			stairsAABB = new AxisAlignedBB(x + stairsLength * 2 + 1, y - stairsLength - 8, z - 9, x, y, z + 8);
  			break;
  		}
  
  		stairsAABB = stairsAABB.grow(4, 0, 4);
  
  		rotatedCubeVolume(world, x, y, z, 1, 0, 8, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 1, 0, 9, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 1, 0, 10, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 1, 1, 10, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 1, 1, 11, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 1, 1, 12, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 1, 2, 12, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 2, 13, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 2, 14, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 3, 14, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 2, 15, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 3, 15, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 3, 16, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 3, 16, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 4, 16, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 4, 17, CRAGROCK_BRICKS, 5, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 15, 0, 8, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 15, 0, 9, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 15, 0, 10, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 15, 1, 10, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 15, 1, 11, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 15, 1, 12, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 15, 2, 12, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 2, 13, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 2, 14, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 3, 14, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 2, 15, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 3, 15, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 3, 16, CRAGROCK_BRICKS, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 3, 16, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 4, 16, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  
  		rotatedCubeVolume(world, x, y, z, 2, 0, 8, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 0, 9, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 0, 10, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 1, 10, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 1, 11, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 1, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 2, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 1, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 2, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 2, 13, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 2, 14, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 3, 14, SMOOTH_CRAGROCK_SLAB, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 3, 15, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 3, 15, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 4, 15, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 4, 15, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 4, 16, SMOOTH_CRAGROCK, 5, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 4, 15, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 0, 8, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 0, 9, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 0, 10, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 1, 10, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 1, 11, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 1, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 2, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 1, 12, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 2, 12, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 2, 13, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 2, 14, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 3, 14, SMOOTH_CRAGROCK_SLAB, 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 3, 15, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 3, 15, SMOOTH_CRAGROCK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 4, 15, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  
  		rotatedCubeVolume(world, x, y, z, 7, 13, 5, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 3, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 13, 6, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 13, 6, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 13, 6, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 13, 6, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 13, 6, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 13, 7, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 13, 6, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 13, 7, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 13, 7, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 13, 7, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 13, 8, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 13, 8, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 13, 9, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 13, 9, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 13, 10, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 13, 10, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 2, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 13, 11, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 13, 11, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 13, 12, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 13, 13, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 13, 12, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 13, 13, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 13, 13, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 13, 13, SMOOTH_CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 13, 14, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 13, 14, SMOOTH_CRAGROCK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 13, 14, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 13, 14, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 2, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 13, 15, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 13, 15, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 13, 15, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 23, 6, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 23, 6, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 23, 14, getStateFromRotation(0, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 23, 14, getStateFromRotation(2, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 23, 9, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 23, 11, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 23, 9, getStateFromRotation(3, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 23, 11, getStateFromRotation(1, direction, SMOOTH_CRAGROCK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 14, 7, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 14, 7, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 14, 13, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 14, 13, CRAGROCK_BRICK_SLAB, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 15, 7, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 15, 7, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 15, 13, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 15, 13, CRAGROCK_BRICK_SLAB_UPSIDEDOWN, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 7, 4, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 8, 4, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 9, 4, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 10, 4, SMOOTH_CRAGROCK_WALL, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 13, 4, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 14, 4, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 15, 4, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 14, 5, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 15, 5, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 7, 5, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 8, 5, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 9, 5, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 10, 5, SMOOTH_CRAGROCK_WALL, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 13, 5, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 14, 5, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 15, 5, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 14, 6, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 15, 6, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 7, 5, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 8, 5, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 9, 5, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 10, 5, SMOOTH_CRAGROCK_WALL, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 13, 5, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 14, 5, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 15, 5, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 14, 6, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 15, 6, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 7, 7, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 8, 7, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 9, 7, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 10, 7, SMOOTH_CRAGROCK_WALL, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 13, 7, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 14, 7, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 15, 7, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 14, 7, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 15, 7, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 7, 10, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 8, 10, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 9, 10, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 10, 10, SMOOTH_CRAGROCK_WALL, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 13, 10, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 14, 10, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 14, 15, 10, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 14, 10, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 15, 10, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 7, 13, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 8, 13, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 9, 13, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 10, 13, SMOOTH_CRAGROCK_WALL, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 13, 13, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 14, 13, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 15, 13, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 14, 13, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 15, 13, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 7, 7, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 8, 7, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 9, 7, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 10, 7, SMOOTH_CRAGROCK_WALL, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 13, 7, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 14, 7, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 15, 7, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 14, 7, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 15, 7, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 7, 10, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 8, 10, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 9, 10, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 10, 10, SMOOTH_CRAGROCK_WALL, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 13, 10, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 14, 10, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 2, 15, 10, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 14, 10, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 15, 10, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 7, 13, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 8, 13, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 9, 13, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 10, 13, SMOOTH_CRAGROCK_WALL, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 13, 13, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 14, 13, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 15, 13, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 14, 13, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 15, 13, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 7, 16, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 8, 16, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 9, 16, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 10, 16, SMOOTH_CRAGROCK_WALL, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 13, 16, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 14, 16, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 15, 16, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 14, 15, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 15, 15, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 7, 15, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 8, 15, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 9, 15, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 10, 15, SMOOTH_CRAGROCK_WALL, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 13, 15, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 14, 15, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 15, 15, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 14, 14, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 11, 15, 14, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 7, 15, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 8, 15, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 9, 15, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 10, 15, SMOOTH_CRAGROCK_WALL, 1, 3, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 13, 15, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 14, 15, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 15, 15, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 14, 14, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 5, 15, 14, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 48, 5, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 49, 5, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 50, 5, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 48, 8, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 49, 8, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 50, 8, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 48, 8, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 49, 8, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 50, 8, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 48, 6, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 49, 6, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 50, 6, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 48, 10, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 49, 10, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 50, 10, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 48, 14, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 49, 14, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 50, 14, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 48, 6, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 49, 6, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 50, 6, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 48, 10, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 49, 10, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 50, 10, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 48, 14, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 49, 14, getStateFromRotation(0, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 50, 14, getStateFromRotation(2, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 48, 15, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 49, 15, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 50, 15, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 48, 12, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 49, 12, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 50, 12, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 48, 12, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 49, 12, getStateFromRotation(3, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 50, 12, getStateFromRotation(1, direction, CRAGROCK_BRICK_STAIRS, EnumRotationSequence.UPSIDE_DOWN_STAIR), 1, 1, 1, direction);
  		rotatedCubeVolumeExtendedDown(world, x, y, z, 7, 0, 4, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 1, 4, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 2, 4, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		if (isReplaceable(world, x, y, z, 8, -1, 4, direction))
  			rotatedCubeVolumeExtendedDown(world, x, y, z, 8, -1, 4, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 0, 4, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 8, 1, 4, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		if (isReplaceable(world, x, y, z, 9, -1, 4, direction))
  			rotatedCubeVolumeExtendedDown(world, x, y, z, 9, -1, 4, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 9, 0, 4, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		if (isReplaceable(world, x, y, z, 7, -1, 3, direction))
  			rotatedCubeVolumeExtendedDown(world, x, y, z, 7, -1, 3, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 7, 0, 3, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		if (isReplaceable(world, x, y, z, 10, -1, 5, direction))
  			rotatedCubeVolumeExtendedDown(world, x, y, z, 10, -1, 5, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 0, 5, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 10, 1, 5, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		if (isReplaceable(world, x, y, z, 12, -1, 6, direction))
  			rotatedCubeVolumeExtendedDown(world, x, y, z, 12, -1, 6, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 0, 6, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 12, 1, 6, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		if (isReplaceable(world, x, y, z, 13, -1, 7, direction))
  			rotatedCubeVolumeExtendedDown(world, x, y, z, 13, -1, 7, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 0, 7, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		if (isReplaceable(world, x, y, z, 13, -1, 8, direction))
  			rotatedCubeVolumeExtendedDown(world, x, y, z, 13, -1, 8, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 0, 8, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 13, 1, 8, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		if (isReplaceable(world, x, y, z, 6, -1, 5, direction))
  			rotatedCubeVolumeExtendedDown(world, x, y, z, 6, -1, 5, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 0, 5, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 6, 1, 5, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		if (isReplaceable(world, x, y, z, 4, -1, 6, direction))
  			rotatedCubeVolumeExtendedDown(world, x, y, z, 4, -1, 6, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 4, 0, 6, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  		if (isReplaceable(world, x, y, z, 3, -1, 8, direction))
  			rotatedCubeVolumeExtendedDown(world, x, y, z, 3, -1, 8, CRAGROCK, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 0, 8, MOSSY_CRAGROCK_BOTTOM, 1, 1, 1, direction);
  		rotatedCubeVolume(world, x, y, z, 3, 1, 8, MOSSY_CRAGROCK_TOP, 1, 1, 1, direction);
  
  
  		//Add world location
  		x -= width / 2;
  		z -= depth / 2;
  		AxisAlignedBB locationBounds;
  		BlockPos entrance;
  		switch (direction) {
  		default:
  		case 0:
  			locationBounds = new AxisAlignedBB(x - 1, y - 8, z + 1, x + width + 1, y + height, z + depth + 1).grow(6, 6, 6);
  			entrance = new BlockPos(x + width / 2, y + 5, z + depth / 2 + 8);
  			break;
  		case 1:
  			locationBounds = new AxisAlignedBB(x + 1, y - 8, z + depth - width - 1, x + depth + 1, y + height, z + depth + 1).grow(6, 6, 6);
  			entrance = new BlockPos(x + width / 2 + 9, y + 5, z + depth / 2 + 1);
  			break;
  		case 2:
  			locationBounds = new AxisAlignedBB(x - 1 + width - width, y - 8, z + depth - depth - 1, x + 1 + width, y + height, z + depth - 1).grow(6, 6, 6);
  			entrance = new BlockPos(x + width / 2, y + 5, z + depth / 2 - 8);
  			break;
  		case 3:
  			locationBounds = new AxisAlignedBB(x - 1 + width - depth, y - 8, z - 1, x - 1 + width, y + height, z + 1 + width).grow(6, 6, 6);
  			entrance = new BlockPos(x + width / 2 - 9, y + 5, z + depth / 2 - 1);
  			break;
  		}
  		x += width / 2;
  		z += depth / 2;
  
  		if(stairsAABB.minY < locationBounds.minY) {
  			double addY = (locationBounds.minY - stairsAABB.minY) / 2;
  			locationBounds = locationBounds.grow(0, addY, 0).offset(0, -addY, 0);
  		}
  
  		this.towerLocation.addBounds(locationBounds, locationBounds.grow(-12, -10, -12), stairsAABB);
  		this.towerLocation.setLayer(0);
  		this.towerLocation.setVisible(true);
  		this.towerLocation.setSeed(random.nextLong());
  		this.towerLocation.setStructurePos(entrance);
  		for(BlockPos pos : inactiveGlowingCragrockBlocks) {
  			this.towerLocation.addGlowingCragrock(pos);
  		}
  		for(BlockPos pos : inactiveWisps) {
  			this.towerLocation.addInactiveWisp(pos);
  		}
  		for(int i = 0; i < 5; i++) {
  			this.towerLocation.setLevelBlockadeBlocks(i, levelBlockades[i]);
  		}
  		this.towerLocation.setDirty(true);
  		this.worldStorage.getLocalStorageHandler().addLocalStorage(this.towerLocation);
  
  		return true;
  	}
  }
  