import java.awt.geom.*;
import java.util.*;
import java.awt.*;
import java.io.*;


class Intersect {
    private class P extends Point2D.Double {
        P(double x, double y) { super(x,y); }
    }

    public static void main(String[] args) throws IOException {k
        new Intersect().run();
    }

    public void run() throws IOException {
        ArrayList<P> hull, pts = new ArrayList<P>();

        System.out.println(intersect(new P(0,0),
                                    new P(5,3),
                                    new P(5,0),
                                    new P(1,2)
                                    ));
    }

    // 1 means clockwise (right turn)
    // c is on line ab, before a: -1;  after b: 1. between = 0
    public int ccw( P a, P b, P c) {
        return Line2D.relativeCCW(a.x, a.y, b.x, b.y, c.x, c.y);
    }

    public P dir(P a, P b) {
        return new P(b.x - a.x, b.y - a.y);
    }

    public P perp(P a) { return new P(-a.y, a.x); }

    // a.b = |a||b| cos theta
    // a.a = |a|^2
    public static double dot(P a, P b) {
        return a.x*b.x + a.y*b.y;
    }

    // a x b = |a||b| sin theta = 2x triangle area
    // >0 if b is right of a, <0 if b is right of a
    public static double cross(P a, P b) {
        return dot(perp(a), b);
    }

    // Computes intersection point of lines ab and cd.
    public P intersect(P a, P b, P c, P d) {
        P ab = dir(a,b), cd = dir(c,d);
        double r0 = cross(dir(a,c), cd);
        double r = r0 / cross(ab, cd);
        return new P(a.x + r*ab.x, a.y + r*ab.y);
    }

    // Closest point to C on line AB
    public static P closest(P a, P b, P c) {
        P ab = dir(a,b), ac = dir(a,c);
        double u = dot(ab,ac)/dot(ab,ab);
        return new P(a.x + u*ab.x, a.y + u*ab.y);
    }

    public static double area(P a, P b, P c) {
        return cross(dir(a,b), dir(a,c));
        // return (b.x-a.x) * (c.y-a.y) - (c.x-a.x)*(b.y-a.y);
    }

    public static double length(double[] v) {
        return Math.sqrt (v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
    }

    public static double dot(double[] v, double[] z) {
        return v[0]*z[0] + v[1]*z[1] + v[2] * z[2];
    }

    // len of result = |v||z| sin theta
    public static double[] cross(double[] v, double[] z) {
        return new double[] {
            v[1]*z[2] - v[2]*z[1],
            v[2]*z[0] - v[0]*z[2],
            v[0]*z[1] - v[1]*z[0] };
    }

    public static double[] dir(double[] a, double[] b) {
        return new double[] {
            b[0] - a[0],
            b[1] - a[1],
            b[2] - a[2] };
    }
}