gt: 		return Vector3.equals(this, o);
context: package com.mumfrey.worldeditcui.util;
  
  import net.minecraft.entity.Entity;
  
  /**
   * Represents a 3d vector.
   */
  public class Vector3 implements Comparable<Vector3>
  {
  	
  	/**
  	 * Vector with all elements set to 0. (0, 0, 0)
  	 */
  	public final static Vector3 ZERO = new Vector3(0, 0, 0);
  	/**
  	 * Unit Vector in the X direction. (1, 0, 0)
  	 */
  	public final static Vector3 UNIT_X = new Vector3(1, 0, 0);
  	/**
  	 * Unit Vector facing Forward. (1, 0, 0)
  	 */
  	public final static Vector3 Forward = UNIT_X;
  	/**
  	 * Unit Vector in the Y direction. (0, 1, 0)
  	 */
  	public final static Vector3 UNIT_Y = new Vector3(0, 1, 0);
  	/**
  	 * Unit Vector pointing Up. (0, 1, 0)
  	 */
  	public final static Vector3 Up = UNIT_Y;
  	/**
  	 * Unit Vector in the Z direction. (0, 0, 1)
  	 */
  	public final static Vector3 UNIT_Z = new Vector3(0, 0, 1);
  	/**
  	 * Unit Vector pointing Right. (0, 0, 1)
  	 */
  	public final static Vector3 Right = UNIT_Z;
  	/**
  	 * Unit Vector with all elements set to 1. (1, 1, 1)
  	 */
  	public final static Vector3 ONE = new Vector3(1, 1, 1);
  	protected double x, y, z;
  	
  	/**
  	 * Constructs a new Vector3 for the specified entity's position
  	 * 
  	 * @param entity
  	 * @param partialTicks
  	 */
  	public Vector3(Entity entity, double partialTicks)
  	{
  		this(
  			entity.prevPosX + ((entity.posX - entity.prevPosX) * partialTicks),
  			entity.prevPosY + ((entity.posY - entity.prevPosY) * partialTicks),
  			entity.prevPosZ + ((entity.posZ - entity.prevPosZ) * partialTicks)
  		);
  	}
  	
  	/**
  	 * Constructs a new Vector3 with the given x, y, z
  	 *
  	 * @param x
  	 * @param y
  	 * @param z
  	 */
  	public Vector3(double x, double y, double z)
  	{
  		this.x = x;
  		this.y = y;
  		this.z = z;
  	}
  	
  	/**
  	 * Constructs a new Vector3 with the given x, y, z
  	 *
  	 * @param x
  	 * @param y
  	 * @param z
  	 */
  	public Vector3(Double x, Double y, Double z)
  	{
  		this(x.doubleValue(), y.doubleValue(), z.doubleValue());
  	}
  	
  	/**
  	 * Constructs a new Vector3 with all elements set to 0
  	 */
  	public Vector3()
  	{
  		this(0, 0, 0);
  	}
  	
  	/**
  	 * Constructs a new Vector3 that is a clone of the given vector3
  	 *
  	 * @param clone
  	 */
  	public Vector3(Vector3 clone)
  	{
  		this(clone.getX(), clone.getY(), clone.getZ());
  	}
  	
  	/**
  	 * Constructs a new Vector3 from the given Vector2 and z
  	 *
  	 * @param vector
  	 * @param z
  	 */
  	public Vector3(Vector2 vector, double z)
  	{
  		this(vector.getX(), vector.getY(), z);
  	}
  	
  	/**
  	 * Constructs a new Vector3 from the given Vector2 and z set to 0
  	 *
  	 * @param vector
  	 */
  	public Vector3(Vector2 vector)
  	{
  		this(vector, 0);
  	}
  	
  	public double getX()
  	{
  		return this.x;
  	}
  	
  	public double getY()
  	{
  		return this.y;
  	}
  	
  	public double getZ()
  	{
  		return this.z;
  	}
  	
  	/**
  	 * Adds two vectors
  	 *
  	 * @param that
  	 * @return
  	 */
  	public Vector3 add(Vector3 that)
  	{
  		return Vector3.add(this, that);
  	}
  	
  	/**
  	 * Subtracts two vectors
  	 *
  	 * @param that
  	 * @return
  	 */
  	public Vector3 subtract(Vector3 that)
  	{
  		return Vector3.subtract(this, that);
  	}
  	
  	/**
  	 * Scales by the scalar value
  	 *
  	 * @param scale
  	 * @return
  	 */
  	public Vector3 scale(double scale)
  	{
  		return Vector3.scale(this, scale);
  	}
  	
  	/**
  	 * Takes the dot product of two vectors
  	 *
  	 * @param that
  	 * @return
  	 */
  	public double dot(Vector3 that)
  	{
  		return Vector3.dot(this, that);
  	}
  	
  	/**
  	 * Takes the cross product of two vectors
  	 *
  	 * @param that
  	 * @return
  	 */
  	public Vector3 cross(Vector3 that)
  	{
  		return Vector3.cross(this, that);
  	}
  	
  	/**
  	 * Returns a Vector2 object using the X and Z values of
  	 * this Vector3. The x of this Vector3 becomes the x 
  	 * of the Vector2, and the z of this Vector3 becomes the 
  	 * y of the Vector2.
  	 * 
  	 * @return 
  	 */
  	public Vector2 toVector2()
  	{
  		return Vector3.toVector2(this);
  	}
  	
  	/**
  	 * Returns a Vector2m object using the X and Z values of
  	 * this Vector3. The x of this Vector3 becomes the x 
  	 * of the Vector2, and the z of this Vector3 becomes the 
  	 * y of the Vector2m.
  	 * 
  	 * @return 
  	 */
  	public Vector2m toVector2m()
  	{
  		return Vector3.toVector2m(this);
  	}
  	
  	/**
  	 * Rounds the X, Y, and Z values of this Vector3 up to 
  	 * the nearest integer value. 
  	 * 
  	 * @return 
  	 */
  	public Vector3 ceil()
  	{
  		return new Vector3(Math.ceil(this.x), Math.ceil(this.y), Math.ceil(this.z));
  	}
  	
  	/**
  	 * Rounds the X, Y, and Z values of this Vector3 down to 
  	 * the nearest integer value. 
  	 * 
  	 * @return 
  	 */
  	public Vector3 floor()
  	{
  		return new Vector3(Math.floor(this.x), Math.floor(this.y), Math.floor(this.z));
  	}
  	
  	/**
  	 * Rounds the X, Y, and Z values of this Vector3 to 
  	 * the nearest integer value. 
  	 * 
  	 * @return 
  	 */
  	public Vector3 round()
  	{
  		return new Vector3(Math.round(this.x), Math.round(this.y), Math.round(this.z));
  	}
  	
  	/**
  	 * Sets the X, Y, and Z values of this Vector3 to their
  	 * absolute value.
  	 * 
  	 * @return 
  	 */
  	public Vector3 abs()
  	{
  		return new Vector3(Math.abs(this.x), Math.abs(this.y), Math.abs(this.z));
  	}
  	
  	/**
  	 * Gets the distance between this Vector3 and a given Vector3.
  	 * 
  	 * @param a
  	 * @return 
  	 */
  	public double distance(Vector3 a)
  	{
  		return Vector3.distance(a, this);
  	}
  	
  	/**
  	 * Raises the X, Y, and Z values of this Vector3 to the given power.
  	 * 
  	 * @param power
  	 * @return 
  	 */
  	public Vector3 pow(double power)
  	{
  		return Vector3.pow(this, power);
  	}
  	
  	/**
  	 * returns the squared length of the vector
  	 *
  	 * @return
  	 */
  	public double lengthSquared()
  	{
  		return Vector3.lengthSquared(this);
  	}
  	
  	/**
  	 * returns the length of this vector. Note: makes use of Math.sqrt and is
  	 * not cached.
  	 *
  	 * @return
  	 */
  	public double length()
  	{
  		return Vector3.length(this);
  	}
  	
  	/**
  	 * Returns a fast approximation of this vector's length.
  	 * 
  	 * @return 
  	 */
  	public double fastLength()
  	{
  		return Vector3.fastLength(this);
  	}
  	
  	/**
  	 * returns the vector with a length of 1
  	 *
  	 * @return
  	 */
  	public Vector3 normalize()
  	{
  		return Vector3.normalize(this);
  	}
  	
  	/**
  	 * returns the vector as [x,y,z]
  	 *
  	 * @return
  	 */
  	public double[] toArray()
  	{
  		return Vector3.toArray(this);
  	}
  	
  	/**
  	 * Compares two Vector3s
  	 */
  	@Override
  	public int compareTo(Vector3 o)
  	{
  		return Vector3.compareTo(this, o);
  	}
  	
  	/**
  	 * Checks if two Vector3s are equal
  	 */
  	@Override
  	public boolean equals(Object o)
  	{
  