gt:                 float f = (float)(l1 + p_73187_2_) / 1.0F;
context: package tk.cvrunmin.lanfasy.world.gen;
  
  import java.util.List;
  import java.util.Random;
  
  import net.minecraft.block.BlockFalling;
  import net.minecraft.block.material.Material;
  import net.minecraft.block.state.IBlockState;
  import net.minecraft.entity.EnumCreatureType;
  import net.minecraft.init.Blocks;
  import net.minecraft.util.BlockPos;
  import net.minecraft.util.IProgressUpdate;
  import net.minecraft.util.MathHelper;
  import net.minecraft.world.World;
  import net.minecraft.world.biome.BiomeGenBase;
  import net.minecraft.world.chunk.Chunk;
  import net.minecraft.world.chunk.ChunkPrimer;
  import net.minecraft.world.chunk.IChunkProvider;
  import net.minecraft.world.gen.NoiseGenerator;
  import net.minecraft.world.gen.NoiseGeneratorOctaves;
  import net.minecraftforge.common.MinecraftForge;
  import net.minecraftforge.event.terraingen.ChunkProviderEvent;
  import net.minecraftforge.event.terraingen.PopulateChunkEvent;
  import net.minecraftforge.event.terraingen.TerrainGen;
  import net.minecraftforge.fml.common.eventhandler.Event.Result;
  import tk.cvrunmin.lanfasy.init.LFBlocks;
  
  public class ChunkProviderAltifect implements IChunkProvider
  {
      private Random RNG;
      private NoiseGeneratorOctaves noiseGen1;
      private NoiseGeneratorOctaves noiseGen2;
      private NoiseGeneratorOctaves noiseGen3;
      public NoiseGeneratorOctaves noiseGen4;
      public NoiseGeneratorOctaves noiseGen5;
      private World world;
      private double[] densities;
      /** The biomes that are used to generate the chunk */
      private BiomeGenBase[] biomesForGeneration;
      double[] noiseData1;
      double[] noiseData2;
      double[] noiseData3;
      double[] noiseData4;
      double[] noiseData5;
  
      public ChunkProviderAltifect(World worldIn, long p_i2007_2_)
      {
          this.world = worldIn;
          this.RNG = new Random(p_i2007_2_);
          this.noiseGen1 = new NoiseGeneratorOctaves(this.RNG, 16);
          this.noiseGen2 = new NoiseGeneratorOctaves(this.RNG, 16);
          this.noiseGen3 = new NoiseGeneratorOctaves(this.RNG, 8);
          this.noiseGen4 = new NoiseGeneratorOctaves(this.RNG, 10);
          this.noiseGen5 = new NoiseGeneratorOctaves(this.RNG, 16);
  
          NoiseGenerator[] noiseGens = {noiseGen1, noiseGen2, noiseGen3, noiseGen4, noiseGen5};
          noiseGens = TerrainGen.getModdedNoiseGenerators(worldIn, this.RNG, noiseGens);
          this.noiseGen1 = (NoiseGeneratorOctaves)noiseGens[0];
          this.noiseGen2 = (NoiseGeneratorOctaves)noiseGens[1];
          this.noiseGen3 = (NoiseGeneratorOctaves)noiseGens[2];
          this.noiseGen4 = (NoiseGeneratorOctaves)noiseGens[3];
          this.noiseGen5 = (NoiseGeneratorOctaves)noiseGens[4];
      }
  
      public void func_180520_a(int p_180520_1_, int p_180520_2_, ChunkPrimer p_180520_3_)
      {
          byte b0 = 2;
          int k = b0 + 1;
          byte b1 = 33;
          int l = b0 + 1;
          this.densities = this.initializeNoiseField(this.densities, p_180520_1_ * b0, 0, p_180520_2_ * b0, k, b1, l);
  
          for (int i1 = 0; i1 < b0; ++i1)
          {
              for (int j1 = 0; j1 < b0; ++j1)
              {
                  for (int k1 = 0; k1 < 32; ++k1)
                  {
                      double d0 = 0.25D;
                      double d1 = this.densities[((i1 + 0) * l + j1 + 0) * b1 + k1 + 0];
                      double d2 = this.densities[((i1 + 0) * l + j1 + 1) * b1 + k1 + 0];
                      double d3 = this.densities[((i1 + 1) * l + j1 + 0) * b1 + k1 + 0];
                      double d4 = this.densities[((i1 + 1) * l + j1 + 1) * b1 + k1 + 0];
                      double d5 = (this.densities[((i1 + 0) * l + j1 + 0) * b1 + k1 + 1] - d1) * d0;
                      double d6 = (this.densities[((i1 + 0) * l + j1 + 1) * b1 + k1 + 1] - d2) * d0;
                      double d7 = (this.densities[((i1 + 1) * l + j1 + 0) * b1 + k1 + 1] - d3) * d0;
                      double d8 = (this.densities[((i1 + 1) * l + j1 + 1) * b1 + k1 + 1] - d4) * d0;
  
                      for (int l1 = 0; l1 < 4; ++l1)
                      {
                          double d9 = 0.125D;
                          double d10 = d1;
                          double d11 = d2;
                          double d12 = (d3 - d1) * d9;
                          double d13 = (d4 - d2) * d9;
  
                          for (int i2 = 0; i2 < 8; ++i2)
                          {
                              double d14 = 0.125D;
                              double d15 = d10;
                              double d16 = (d11 - d10) * d14;
  
                              for (int j2 = 0; j2 < 8; ++j2)
                              {
                                  IBlockState iblockstate = null;
  
                                  if (d15 > 0.0D)
                                  {
                                      iblockstate = Blocks.air.getDefaultState();
                                  }
  
                                  int k2 = i2 + i1 * 8;
                                  int l2 = l1 + k1 * 4;
                                  int i3 = j2 + j1 * 8;
                                  p_180520_3_.setBlockState(k2, l2, i3, iblockstate);
                                  d15 += d16;
                              }
  
                              d10 += d12;
                              d11 += d13;
                          }
  
                          d1 += d5;
                          d2 += d6;
                          d3 += d7;
                          d4 += d8;
                      }
                  }
              }
          }
      }
  
      public void func_180519_a(ChunkPrimer p_180519_1_)
      {
          ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, chunkX, chunkZ, p_180519_1_, this.world);
          MinecraftForge.EVENT_BUS.post(event);
          if (event.getResult() == Result.DENY) return;
          for (int i = 0; i < 16; ++i)
          {
              for (int j = 0; j < 16; ++j)
              {
                  byte b0 = 1;
                  int k = -1;
                  IBlockState iblockstate = Blocks.air.getDefaultState();
                  IBlockState iblockstate1 = Blocks.air.getDefaultState();
  
                  for (int l = 127; l >= 0; --l)
                  {
                      IBlockState iblockstate2 = p_180519_1_.getBlockState(i, l, j);
  
                      if (iblockstate2.getBlock().getMaterial() == Material.air)
                      {
                          k = -1;
                      }
                      else if (iblockstate2.getBlock() == Blocks.stone)
                      {
                          if (k == -1)
                          {
                              if (b0 <= 0)
                              {
                                  iblockstate = Blocks.air.getDefaultState();
                                  iblockstate1 = Blocks.air.getDefaultState();
                              }
  
                              k = b0;
  
                              if (l >= 0)
                              {
                                  p_180519_1_.setBlockState(i, l, j, iblockstate);
                              }
                              else
                              {
                                  p_180519_1_.setBlockState(i, l, j, iblockstate1);
                              }
                          }
                          else if (k > 0)
                          {
                              --k;
                              p_180519_1_.setBlockState(i, l, j, iblockstate1);
                          }
                      }
                  }
              }
          }
      }
  
      private int chunkX=0, chunkZ=0;
      /**
       * Will return back a chunk, if it doesn't exist and its not a MP client it will generates all the blocks for the
       * specified chunk from the map seed and chunk seed
       */
      public Chunk provideChunk(int x, int z)
      {
          chunkX = x; chunkZ = z;
          this.RNG.setSeed((long)x * 341873128712L + (long)z * 132897987541L);
          ChunkPrimer chunkprimer = new ChunkPrimer();
          this.biomesForGeneration = this.world.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, x * 16, z * 16, 16, 16);
          this.func_180520_a(x, z, chunkprimer);
          this.func_180519_a(chunkprimer);
          Chunk chunk = new Chunk(this.world, chunkprimer, x, z);
          byte[] abyte = chunk.getBiomeArray();
  
          for (int k = 0; k < abyte.length; ++k)
          {
              abyte[k] = (byte)this.biomesForGeneration[k].biomeID;
          }
  
          chunk.generateSkylightMap();
          return chunk;
      }
  
      /**
       * generates a subset of the level's terrain data. Takes 7 arguments: the [empty] noise array, the position, and the
       * size.
       */
      private double[] initializeNoiseField(double[] p_73187_1_, int p_73187_2_, int p_73187_3_, int p_73187_4_, int p_73187_5_, int p_73187_6_, int p_73187_7_)
      {
          ChunkProviderEvent.InitNoiseField event = new ChunkProviderEvent.InitNoiseField(this, p_73187_1_, p_73187_2_, p_73187_3_, p_73187_4_, p_73187_5_, p_73187_6_, p_73187_7_);
          MinecraftForge.EVENT_BUS.post(event);
          if (event.getResult() == Result.DENY) return event.noisefield;
  
          if (p_73187_1_ == null)
          {
              p_73187_1_ = new double[p_73187_5_ * p_73187_6_ * p_73187_7_];
          }
  
          double d0 = 684.412D;
          double d1 = 684.412D;
          this.noiseData4 = this.noiseGen4.generateNoiseOctaves(this.noiseData4, p_73187_2_, p_73187_4_, p_73187_5_, p_73187_7_, 1.121D, 1.121D, 0.5D);
          this.noiseData5 = this.noiseGen5.generateNoiseOctaves(this.noiseData5, p_73187_2_, p_73187_4_, p_73187_5_, p_73187_7_, 200.0D, 200.0D, 0.5D);
          d0 *= 2.0D;
          this.noiseData1 = this.noiseGen3.generateNoiseOctaves(this.noiseData1, p_73187_2_, p_73187_3_, p_73187_4_, p_73187_5_, p_73187_6_, p_73187_7_, d0 / 80.0D, d1 / 160.0D, d0 / 80.0D);
          this.noiseData2 = this.noiseGen1.generateNoiseOctaves(this.noiseData2, p_73187_2_, p_73187_3_, p_73187_4_, p_73187_5_, p_73187_6_, p_73187_7_, d0, d1, d0);
          this.noiseData3 = this.noiseGen2.generateNoiseOctaves(this.noiseData3, p_73187_2_, p_73187_3_, p_73187_4_, p_73187_5_, p_73187_6_, p_73187_7_, d0, d1, d0);
          int k1 = 0;
  
          for (int l1 = 0; l1 < p_73187_5_; ++l1)
          {
              for (int i2 = 0; i2 < p_73187_7_; ++i2)
              {
  