gt:         if (compound.hasKey("TileEntityData", 10))
context: package net.minecraft.entity.item;
  
  import com.google.common.collect.Lists;
  import java.util.List;
  import javax.annotation.Nullable;
  import net.minecraft.block.Block;
  import net.minecraft.block.BlockAnvil;
  import net.minecraft.block.BlockFalling;
  import net.minecraft.block.ITileEntityProvider;
  import net.minecraft.block.material.Material;
  import net.minecraft.block.state.IBlockState;
  import net.minecraft.crash.CrashReportCategory;
  import net.minecraft.entity.Entity;
  import net.minecraft.init.Blocks;
  import net.minecraft.item.ItemStack;
  import net.minecraft.nbt.NBTBase;
  import net.minecraft.nbt.NBTTagCompound;
  import net.minecraft.network.datasync.DataParameter;
  import net.minecraft.network.datasync.DataSerializers;
  import net.minecraft.network.datasync.EntityDataManager;
  import net.minecraft.tileentity.TileEntity;
  import net.minecraft.util.DamageSource;
  import net.minecraft.util.EnumFacing;
  import net.minecraft.util.ResourceLocation;
  import net.minecraft.util.math.BlockPos;
  import net.minecraft.util.math.MathHelper;
  import net.minecraft.world.World;
  import net.minecraftforge.fml.relauncher.Side;
  import net.minecraftforge.fml.relauncher.SideOnly;
  
  public class EntityFallingBlock extends Entity
  {
      private IBlockState fallTile;
      public int fallTime;
      public boolean shouldDropItem = true;
      private boolean canSetAsBlock;
      private boolean hurtEntities;
      private int fallHurtMax = 40;
      private float fallHurtAmount = 2.0F;
      public NBTTagCompound tileEntityData;
      protected static final DataParameter<BlockPos> ORIGIN = EntityDataManager.<BlockPos>createKey(EntityFallingBlock.class, DataSerializers.BLOCK_POS);
  
      public EntityFallingBlock(World worldIn)
      {
          super(worldIn);
      }
  
      public EntityFallingBlock(World worldIn, double x, double y, double z, IBlockState fallingBlockState)
      {
          super(worldIn);
          this.fallTile = fallingBlockState;
          this.preventEntitySpawning = true;
          this.setSize(0.98F, 0.98F);
          this.setPosition(x, y + (double)((1.0F - this.height) / 2.0F), z);
          this.motionX = 0.0D;
          this.motionY = 0.0D;
          this.motionZ = 0.0D;
          this.prevPosX = x;
          this.prevPosY = y;
          this.prevPosZ = z;
          this.setOrigin(new BlockPos(this));
      }
  
      public void setOrigin(BlockPos p_184530_1_)
      {
          this.dataManager.set(ORIGIN, p_184530_1_);
      }
  
      @SideOnly(Side.CLIENT)
      public BlockPos getOrigin()
      {
          return (BlockPos)this.dataManager.get(ORIGIN);
      }
  
      /**
       * returns if this entity triggers Block.onEntityWalking on the blocks they walk on. used for spiders and wolves to
       * prevent them from trampling crops
       */
      protected boolean canTriggerWalking()
      {
          return false;
      }
  
      protected void entityInit()
      {
          this.dataManager.register(ORIGIN, BlockPos.ORIGIN);
      }
  
      /**
       * Returns true if other Entities should be prevented from moving through this Entity.
       */
      public boolean canBeCollidedWith()
      {
          return !this.isDead;
      }
  
      /**
       * Called to update the entity's position/logic.
       */
      public void onUpdate()
      {
          Block block = this.fallTile.getBlock();
  
          if (this.fallTile.getMaterial() == Material.AIR)
          {
              this.setDead();
          }
          else
          {
              this.prevPosX = this.posX;
              this.prevPosY = this.posY;
              this.prevPosZ = this.posZ;
  
              if (this.fallTime++ == 0)
              {
                  BlockPos blockpos = new BlockPos(this);
  
                  if (this.worldObj.getBlockState(blockpos).getBlock() == block)
                  {
                      this.worldObj.setBlockToAir(blockpos);
                  }
                  else if (!this.worldObj.isRemote)
                  {
                      this.setDead();
                      return;
                  }
              }
  
              this.motionY -= 0.03999999910593033D;
              this.moveEntity(this.motionX, this.motionY, this.motionZ);
              this.motionX *= 0.9800000190734863D;
              this.motionY *= 0.9800000190734863D;
              this.motionZ *= 0.9800000190734863D;
  
              if (!this.worldObj.isRemote)
              {
                  BlockPos blockpos1 = new BlockPos(this);
  
                  if (this.onGround)
                  {
                      IBlockState iblockstate = this.worldObj.getBlockState(blockpos1);
  
                      if (this.worldObj.isAirBlock(new BlockPos(this.posX, this.posY - 0.009999999776482582D, this.posZ))) //Forge: Don't indent below.
                      if (BlockFalling.canFallThrough(this.worldObj.getBlockState(new BlockPos(this.posX, this.posY - 0.009999999776482582D, this.posZ))))
                      {
                          this.onGround = false;
                          return;
                      }
  
                      this.motionX *= 0.699999988079071D;
                      this.motionZ *= 0.699999988079071D;
                      this.motionY *= -0.5D;
  
                      if (iblockstate.getBlock() != Blocks.PISTON_EXTENSION)
                      {
                          this.setDead();
  
                          if (!this.canSetAsBlock)
                          {
                              if (this.worldObj.canBlockBePlaced(block, blockpos1, true, EnumFacing.UP, (Entity)null, (ItemStack)null) && !BlockFalling.canFallThrough(this.worldObj.getBlockState(blockpos1.down())) && this.worldObj.setBlockState(blockpos1, this.fallTile, 3))
                              {
                                  if (block instanceof BlockFalling)
                                  {
                                      ((BlockFalling)block).onEndFalling(this.worldObj, blockpos1);
                                  }
  
                                  if (this.tileEntityData != null && block instanceof ITileEntityProvider)
                                  {
                                      TileEntity tileentity = this.worldObj.getTileEntity(blockpos1);
  
                                      if (tileentity != null)
                                      {
                                          NBTTagCompound nbttagcompound = tileentity.writeToNBT(new NBTTagCompound());
  
                                          for (String s : this.tileEntityData.getKeySet())
                                          {
                                              NBTBase nbtbase = this.tileEntityData.getTag(s);
  
                                              if (!s.equals("x") && !s.equals("y") && !s.equals("z"))
                                              {
                                                  nbttagcompound.setTag(s, nbtbase.copy());
                                              }
                                          }
  
                                          tileentity.readFromNBT(nbttagcompound);
                                          tileentity.markDirty();
                                      }
                                  }
                              }
                              else if (this.shouldDropItem && this.worldObj.getGameRules().getBoolean("doEntityDrops"))
                              {
                                  this.entityDropItem(new ItemStack(block, 1, block.damageDropped(this.fallTile)), 0.0F);
                              }
                          }
                      }
                  }
                  else if (this.fallTime > 100 && !this.worldObj.isRemote && (blockpos1.getY() < 1 || blockpos1.getY() > 256) || this.fallTime > 600)
                  {
                      if (this.shouldDropItem && this.worldObj.getGameRules().getBoolean("doEntityDrops"))
                      {
                          this.entityDropItem(new ItemStack(block, 1, block.damageDropped(this.fallTile)), 0.0F);
                      }
  
                      this.setDead();
                  }
              }
          }
      }
  
      public void fall(float distance, float damageMultiplier)
      {
          Block block = this.fallTile.getBlock();
  
          if (this.hurtEntities)
          {
              int i = MathHelper.ceiling_float_int(distance - 1.0F);
  
              if (i > 0)
              {
                  List<Entity> list = Lists.newArrayList(this.worldObj.getEntitiesWithinAABBExcludingEntity(this, this.getEntityBoundingBox()));
                  boolean flag = block == Blocks.ANVIL;
                  DamageSource damagesource = flag ? DamageSource.anvil : DamageSource.fallingBlock;
  
                  for (Entity entity : list)
                  {
                      entity.attackEntityFrom(damagesource, (float)Math.min(MathHelper.floor_float((float)i * this.fallHurtAmount), this.fallHurtMax));
                  }
  
                  if (flag && (double)this.rand.nextFloat() < 0.05000000074505806D + (double)i * 0.05D)
                  {
                      int j = ((Integer)this.fallTile.getValue(BlockAnvil.DAMAGE)).intValue();
                      ++j;
  
                      if (j > 2)
                      {
                          this.canSetAsBlock = true;
                      }
                      else
                      {
                          this.fallTile = this.fallTile.withProperty(BlockAnvil.DAMAGE, Integer.valueOf(j));
                      }
                  }
              }
          }
      }
  
      /**
       * (abstract) Protected helper method to write subclass entity data to NBT.
       */
      protected void writeEntityToNBT(NBTTagCompound compound)
      {
          Block block = this.fallTile != null ? this.fallTile.getBlock() : Blocks.AIR;
          ResourceLocation resourcelocation = (ResourceLocation)Block.REGISTRY.getNameForObject(block);
          compound.setString("Block", resourcelocation == null ? "" : resourcelocation.toString());
          compound.setByte("Data", (byte)block.getMetaFromState(this.fallTile));
          compound.setInteger("Time", this.fallTime);
          compound.setBoolean("DropItem", this.shouldDropItem);
          compound.setBoolean("HurtEntities", this.hurtEntities);
          compound.setFloat("FallHurtAmount", this.fallHurtAmount);
          compound.setInteger("FallHurtMax", this.fallHurtMax);
  
          if (this.tileEntityData != null)
          {
              compound.setTag("TileEntityData", this.tileEntityData);
          }
      }
  
      /**
       * (abstract) Protected helper method to read subclass entity data from NBT.
       */
      protected void readEntityFromNBT(NBTTagCompound compound)
      {
          int i = compound.getByte("Data") & 255;
  
          if (compound.hasKey("Block", 8))
          {
              this.fallTile = Block.getBlockFromName(compound.getString("Block")).getStateFromMeta(i);
          }
          else if (compound.hasKey("TileID", 99))
          {
              this.fallTile = Block.getBlockById(compound.getInteger("TileID")).getStateFromMeta(i);
          }
          else
          {
              this.fallTile = Block.getBlockById(compound.getByte("Tile") & 255).getStateFromMeta(i);
          }
  
          this.fallTime = compound.getInteger("Time");
          Block block = this.fallTile.getBlock();
  
          if (compound.hasKey("HurtEntities", 99))
          {
              this.hurtEntities = compound.getBoolean("HurtEntities");
              this.fallHurtAmount = compound.getFloat("FallHurtAmount");
              this.fallHurtMax = compound.getInteger("FallHurtMax");
          }
          else if (block == Blocks.ANVIL)
          {
              this.hurtEntities = true;
          }
  
          if (compound.hasKey("DropItem", 99))
          {
              this.shouldDropItem = compound.getBoolean("DropItem");
          }
  
  