interface Vec {
    public float x;
    public float y;
    public float z;

    public Vec   clone      ();
    public Vec   copy       (Vec   another);
    public Vec   plus       (Vec   another);
    public Vec   minus      (Vec   another);
    public Vec   mult       (float number);
    public Vec   div        (float number);
    public float dot        (Vec   another);
    public float distToSqr  (Vec   another);
    public float distTo     (Vec   another);
    public float angle      (Vec   edge);
    public Vec   reflect    (Vec   normal);
    public float radius     ();
    public Vec   normalize  ();
}

struct Vec3 extends Vec {
    // Constructors
    public static Vec3 create(float x, float y, float z) {
        Vec3 this = Vec3.allocate();
        this.x = x;
        this.y = y;
        this.z = z;
        return this;
    }

    public Vec clone() {
        return Vec3.create(this.x, this.y, this.z);
    }

    public Vec copy(Vec another) {
        this.x = another.x;
        this.y = another.y;
        this.z = another.z;
        return this;
    }

    // Basic math
    public Vec plus(Vec another) {
        this.x += another.x;
        this.y += another.y;
        this.z += another.z;
        return this;
    }

    public Vec minus(Vec another) {
        this.x += -another.x;
        this.y += -another.y;
        this.z += -another.z;
        return this;
    }

    public Vec mult(float number) {
        this.x *= number;
        this.y *= number;
        this.z *= number;
        return this;
    }

    public Vec div(float number) {
        return this.mult(1/number);
    }

    // Advanced math
    public static Vec3 cross(Vec edge1, Vec edge2) {
        return Vec3.create(edge1.y*edge2.z - edge1.z*edge2.y, edge1.z*edge2.x - edge1.x*edge2.z, edge1.x*edge2.y - edge1.y*edge2.x);
    }

    public float dot(Vec another) {
        return this.x*another.x + this.y*another.y + this.z*another.z;
    }

    public float distToSqr(Vec another) {
        return (this.x - another.x)*(this.x - another.x) + (this.y - another.y)*(this.y - another.y) + (this.z - another.z)*(this.z - another.z);
    }

    public float distTo(Vec another) {
        return SquareRoot(this.distToSqr(another));
    }

    public float angle(Vec edge) {
        return Acos(this.dot(edge)/this.radius()*edge.radius());
    }

    // Misc.
    public static Vec triangleNormal(Vec a, Vec b, Vec c) {
        Vec3 edge1 = b.clone().minus(a);
        Vec3 edge2 = c.clone().minus(a);
        Vec3 result = Vec3.cross(edge1, edge2).normalize();
        edge1.destroy();
        edge2.destroy();
        return result;
    }

    public Vec reflect(Vec normal) {
        float multipler = 2.0*this.dot(normal);
        this.minus(normal.mult(multipler));
        normal.div(multipler);
        return this;
    }

    public float radius() {
        return SquareRoot(this.dot(this));
    }

    public Vec normalize() {
        return this.div(this.radius());
    }
}