gt:                 if (this.speedMultiplier < 0.07D)
context: package net.minecraft.entity.item;
  
  import cpw.mods.fml.relauncher.Side;
  import cpw.mods.fml.relauncher.SideOnly;
  import java.util.List;
  import net.minecraft.block.Block;
  import net.minecraft.block.material.Material;
  import net.minecraft.entity.Entity;
  import net.minecraft.entity.EntityLivingBase;
  import net.minecraft.entity.player.EntityPlayer;
  import net.minecraft.item.Item;
  import net.minecraft.nbt.NBTTagCompound;
  import net.minecraft.util.AxisAlignedBB;
  import net.minecraft.util.DamageSource;
  import net.minecraft.util.MathHelper;
  import net.minecraft.world.World;
  
  public class EntityBoat extends Entity
  {
      private boolean field_70279_a;
      private double speedMultiplier;
      private int boatPosRotationIncrements;
      private double boatX;
      private double boatY;
      private double boatZ;
      private double boatYaw;
      private double boatPitch;
      @SideOnly(Side.CLIENT)
      private double velocityX;
      @SideOnly(Side.CLIENT)
      private double velocityY;
      @SideOnly(Side.CLIENT)
      private double velocityZ;
  
      public EntityBoat(World par1World)
      {
          super(par1World);
          this.field_70279_a = true;
          this.speedMultiplier = 0.07D;
          this.preventEntitySpawning = true;
          this.setSize(1.5F, 0.6F);
          this.yOffset = this.height / 2.0F;
      }
  
      /**
       * 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.dataWatcher.addObject(17, new Integer(0));
          this.dataWatcher.addObject(18, new Integer(1));
          this.dataWatcher.addObject(19, new Float(0.0F));
      }
  
      /**
       * Returns a boundingBox used to collide the entity with other entities and blocks. This enables the entity to be
       * pushable on contact, like boats or minecarts.
       */
      public AxisAlignedBB getCollisionBox(Entity par1Entity)
      {
          return par1Entity.boundingBox;
      }
  
      /**
       * returns the bounding box for this entity
       */
      public AxisAlignedBB getBoundingBox()
      {
          return this.boundingBox;
      }
  
      /**
       * Returns true if this entity should push and be pushed by other entities when colliding.
       */
      public boolean canBePushed()
      {
          return true;
      }
  
      public EntityBoat(World par1World, double par2, double par4, double par6)
      {
          this(par1World);
          this.setPosition(par2, par4 + (double)this.yOffset, par6);
          this.motionX = 0.0D;
          this.motionY = 0.0D;
          this.motionZ = 0.0D;
          this.prevPosX = par2;
          this.prevPosY = par4;
          this.prevPosZ = par6;
      }
  
      /**
       * Returns the Y offset from the entity's position for any entity riding this one.
       */
      public double getMountedYOffset()
      {
          return (double)this.height * 0.0D - 0.30000001192092896D;
      }
  
      /**
       * Called when the entity is attacked.
       */
      public boolean attackEntityFrom(DamageSource par1DamageSource, float par2)
      {
          if (this.isEntityInvulnerable())
          {
              return false;
          }
          else if (!this.worldObj.isRemote && !this.isDead)
          {
              this.setForwardDirection(-this.getForwardDirection());
              this.setTimeSinceHit(10);
              this.setDamageTaken(this.getDamageTaken() + par2 * 10.0F);
              this.setBeenAttacked();
              boolean flag = par1DamageSource.getEntity() instanceof EntityPlayer && ((EntityPlayer)par1DamageSource.getEntity()).capabilities.isCreativeMode;
  
              if (flag || this.getDamageTaken() > 40.0F)
              {
                  if (this.riddenByEntity != null)
                  {
                      this.riddenByEntity.mountEntity(this);
                  }
  
                  if (!flag)
                  {
                      this.dropItemWithOffset(Item.boat.itemID, 1, 0.0F);
                  }
  
                  this.setDead();
              }
  
              return true;
          }
          else
          {
              return true;
          }
      }
  
      @SideOnly(Side.CLIENT)
  
      /**
       * Setups the entity to do the hurt animation. Only used by packets in multiplayer.
       */
      public void performHurtAnimation()
      {
          this.setForwardDirection(-this.getForwardDirection());
          this.setTimeSinceHit(10);
          this.setDamageTaken(this.getDamageTaken() * 11.0F);
      }
  
      /**
       * Returns true if other Entities should be prevented from moving through this Entity.
       */
      public boolean canBeCollidedWith()
      {
          return !this.isDead;
      }
  
      @SideOnly(Side.CLIENT)
  
      /**
       * Sets the position and rotation. Only difference from the other one is no bounding on the rotation. Args: posX,
       * posY, posZ, yaw, pitch
       */
      public void setPositionAndRotation2(double par1, double par3, double par5, float par7, float par8, int par9)
      {
          if (this.field_70279_a)
          {
              this.boatPosRotationIncrements = par9 + 5;
          }
          else
          {
              double d3 = par1 - this.posX;
              double d4 = par3 - this.posY;
              double d5 = par5 - this.posZ;
              double d6 = d3 * d3 + d4 * d4 + d5 * d5;
  
              if (d6 <= 1.0D)
              {
                  return;
              }
  
              this.boatPosRotationIncrements = 3;
          }
  
          this.boatX = par1;
          this.boatY = par3;
          this.boatZ = par5;
          this.boatYaw = (double)par7;
          this.boatPitch = (double)par8;
          this.motionX = this.velocityX;
          this.motionY = this.velocityY;
          this.motionZ = this.velocityZ;
      }
  
      @SideOnly(Side.CLIENT)
  
      /**
       * Sets the velocity to the args. Args: x, y, z
       */
      public void setVelocity(double par1, double par3, double par5)
      {
          this.velocityX = this.motionX = par1;
          this.velocityY = this.motionY = par3;
          this.velocityZ = this.motionZ = par5;
      }
  
      /**
       * Called to update the entity's position/logic.
       */
      public void onUpdate()
      {
          super.onUpdate();
  
          if (this.getTimeSinceHit() > 0)
          {
              this.setTimeSinceHit(this.getTimeSinceHit() - 1);
          }
  
          if (this.getDamageTaken() > 0.0F)
          {
              this.setDamageTaken(this.getDamageTaken() - 1.0F);
          }
  
          this.prevPosX = this.posX;
          this.prevPosY = this.posY;
          this.prevPosZ = this.posZ;
          byte b0 = 5;
          double d0 = 0.0D;
  
          for (int i = 0; i < b0; ++i)
          {
              double d1 = this.boundingBox.minY + (this.boundingBox.maxY - this.boundingBox.minY) * (double)(i + 0) / (double)b0 - 0.125D;
              double d2 = this.boundingBox.minY + (this.boundingBox.maxY - this.boundingBox.minY) * (double)(i + 1) / (double)b0 - 0.125D;
              AxisAlignedBB axisalignedbb = AxisAlignedBB.getAABBPool().getAABB(this.boundingBox.minX, d1, this.boundingBox.minZ, this.boundingBox.maxX, d2, this.boundingBox.maxZ);
  
              if (this.worldObj.isAABBInMaterial(axisalignedbb, Material.water))
              {
                  d0 += 1.0D / (double)b0;
              }
          }
  
          double d3 = Math.sqrt(this.motionX * this.motionX + this.motionZ * this.motionZ);
          double d4;
          double d5;
  
          if (d3 > 0.26249999999999996D)
          {
              d4 = Math.cos((double)this.rotationYaw * Math.PI / 180.0D);
              d5 = Math.sin((double)this.rotationYaw * Math.PI / 180.0D);
  
              for (int j = 0; (double)j < 1.0D + d3 * 60.0D; ++j)
              {
                  double d6 = (double)(this.rand.nextFloat() * 2.0F - 1.0F);
                  double d7 = (double)(this.rand.nextInt(2) * 2 - 1) * 0.7D;
                  double d8;
                  double d9;
  
                  if (this.rand.nextBoolean())
                  {
                      d8 = this.posX - d4 * d6 * 0.8D + d5 * d7;
                      d9 = this.posZ - d5 * d6 * 0.8D - d4 * d7;
                      this.worldObj.spawnParticle("splash", d8, this.posY - 0.125D, d9, this.motionX, this.motionY, this.motionZ);
                  }
                  else
                  {
                      d8 = this.posX + d4 + d5 * d6 * 0.7D;
                      d9 = this.posZ + d5 - d4 * d6 * 0.7D;
                      this.worldObj.spawnParticle("splash", d8, this.posY - 0.125D, d9, this.motionX, this.motionY, this.motionZ);
                  }
              }
          }
  
          double d10;
          double d11;
  
          if (this.worldObj.isRemote && this.field_70279_a)
          {
              if (this.boatPosRotationIncrements > 0)
              {
                  d4 = this.posX + (this.boatX - this.posX) / (double)this.boatPosRotationIncrements;
                  d5 = this.posY + (this.boatY - this.posY) / (double)this.boatPosRotationIncrements;
                  d11 = this.posZ + (this.boatZ - this.posZ) / (double)this.boatPosRotationIncrements;
                  d10 = MathHelper.wrapAngleTo180_double(this.boatYaw - (double)this.rotationYaw);
                  this.rotationYaw = (float)((double)this.rotationYaw + d10 / (double)this.boatPosRotationIncrements);
                  this.rotationPitch = (float)((double)this.rotationPitch + (this.boatPitch - (double)this.rotationPitch) / (double)this.boatPosRotationIncrements);
                  --this.boatPosRotationIncrements;
                  this.setPosition(d4, d5, d11);
                  this.setRotation(this.rotationYaw, this.rotationPitch);
              }
              else
              {
                  d4 = this.posX + this.motionX;
                  d5 = this.posY + this.motionY;
                  d11 = this.posZ + this.motionZ;
                  this.setPosition(d4, d5, d11);
  
                  if (this.onGround)
                  {
                      this.motionX *= 0.5D;
                      this.motionY *= 0.5D;
                      this.motionZ *= 0.5D;
                  }
  
                  this.motionX *= 0.9900000095367432D;
                  this.motionY *= 0.949999988079071D;
                  this.motionZ *= 0.9900000095367432D;
              }
          }
          else
          {
              if (d0 < 1.0D)
              {
                  d4 = d0 * 2.0D - 1.0D;
                  this.motionY += 0.03999999910593033D * d4;
              }
              else
              {
                  if (this.motionY < 0.0D)
                  {
                      this.motionY /= 2.0D;
                  }
  
                  this.motionY += 0.007000000216066837D;
              }
  
              if (this.riddenByEntity != null && this.riddenByEntity instanceof EntityLivingBase)
              {
                  d4 = (double)((EntityLivingBase)this.riddenByEntity).moveForward;
  
                  if (d4 > 0.0D)
                  {
                      d5 = -Math.sin((double)(this.riddenByEntity.rotationYaw * (float)Math.PI / 180.0F));
                      d11 = Math.cos((double)(this.riddenByEntity.rotationYaw * (float)Math.PI / 180.0F));
                      this.motionX += d5 * this.speedMultiplier * 0.05000000074505806D;
                      this.motionZ += d11 * this.speedMultiplier * 0.05000000074505806D;
                  }
              }
  
              d4 = Math.sqrt(this.motionX * this.motionX + this.motionZ * this.motionZ);
  
              if (d4 > 0.35D)
              {
                  d5 = 0.35D / d4;
                  this.motionX *= d5;
                  this.motionZ *= d5;
                  d4 = 0.35D;
              }
  
              if (d4 > d3 && this.speedMultiplier < 0.35D)
              {
                  this.speedMultiplier += (0.35D - this.speedMultiplier) / 35.0D;
  
                  if (this.speedMultiplier > 0.35D)
                  {
                      this.speedMultiplier = 0.35D;
                  }
              }
              else
              {
                  this.speedMultiplier -= (this.speedMultiplier - 0.07D) / 35.0D;
  
  