Problem: There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.

For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.

Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.

Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.

Find the place of the exhibition that will be selected.

Constraints

* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.

Inputs

Input is given from Standard Input in the following format:


N
A_1 B_1 C_1
:
A_N B_N C_N


Outputs

Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.

Examples

Input

3
1 1 1
2 -1 2
-1 2 2


Output

1.000000000000000 1.000000000000000


Input

4
1 1 2
1 -1 0
3 -1 -2
1 -3 4


Output

-1.000000000000000 -1.000000000000000


Input

7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10


Output

-1.722222222222222 1.325000000000000

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;
import java.math.*;
// import java.awt.Point;
 
public class Main {
    InputStream is;
    PrintWriter out;
    String INPUT = "";
 
    long MOD = 1_000_000_007;
    long inf = Long.MAX_VALUE;

    void solve(){
        int n = ni();
        double[][] res = new double[n][3];
        for(int i = 0; i < n; i++){
            res[i][0] = (double)ni();
            res[i][1] = (double)ni();
            res[i][2] = (double)ni();
        }
        Arrays.sort(res, new Comparator<double[]>() {
            public int compare(double[] a, double[] b) {
                return Double.compare(-a[0]/a[1], -b[0]/b[1]);
            }
        });
        double left = -1000000000;
        double right = 1000000000;
        long total = n*(n-1)/2;
        for(int i = 0; i < 100; i++){
            double mid = (left+right)/2;
            if(judge(mid,res,n)>=total/2+1) left = mid;
            else right = mid; 
        }
        double x = left;
        Arrays.sort(res, new Comparator<double[]>() {
            public int compare(double[] a, double[] b) {
                return Double.compare(-a[1]/a[0], -b[1]/b[0]);
            }
        });
        left = -1000000000;
        right = 1000000000;
        for(int i = 0; i < 100; i++){
            double mid = (left+right)/2;
            if(judge2(mid,res,n)>=total/2+1) left = mid;
            else right = mid; 
        }
        double y = left;
        out.println(x+" "+y);
    }

    int judge(double mid, double[][] res, int n){
        double[][] line = new double[n][2];
        for(int i = 0; i < n; i++){
            line[i][0] = i;
            line[i][1] = (res[i][2]-res[i][0]*mid)/res[i][1];
        }
        Arrays.sort(line, new Comparator<double[]>() {
            public int compare(double[] a, double[] b) {
                if(a[1]!=b[1]) return Double.compare(a[1],b[1]);
                return Double.compare(a[0],b[0]);
            }
        });
        BIT bit = new BIT(n);
        int num = 0;
        for(int i = 0; i < n; i++){
            int cur = (int)line[i][0];
            num += bit.sum(cur+1,n);
            bit.accumlate(cur,1);
        }
        return num;
    }

    int judge2(double mid, double[][] res, int n){
        double[][] line = new double[n][2];
        for(int i = 0; i < n; i++){
            line[i][0] = i;
            line[i][1] = (res[i][2]-res[i][1]*mid)/res[i][0];
        }
        Arrays.sort(line, new Comparator<double[]>() {
            public int compare(double[] a, double[] b) {
                if(a[1]!=b[1]) return Double.compare(a[1],b[1]);
                return Double.compare(a[0],b[0]);
            }
        });
        BIT bit = new BIT(n);
        int num = 0;
        for(int i = 0; i < n; i++){
            int cur = (int)line[i][0];
            num += bit.sum(cur+1,n);
            bit.accumlate(cur,1);
        }
        return num;
    }

    class BIT {
    private int n;
    private long[] bit;
    public BIT(int n) {
        this.n = n;
        bit = new long[n+1];
    }

    public void accumlate(int index,long num) {
        index++;
        while(index<=n) {
            bit[index] += num;
            index+=index&-index;
        }
    }

    /* [begin , end) */
    public long sum(int begin,int end) {
        return sum(end) - sum(begin);
    }

    private long sum(int i) {
        long s = 0;
        while(i>0) {
            s+=bit[i];
            i-=i&-i;
        }
        return s;
    }

    public long get(int index) {
        return sum(index,index+1);
    }

    public void set(int index,long num) {
        accumlate(index,num-(sum(index)-sum(index-1)));
    }

    public String toString() {
        long[] value = new long[n];
        for(int i=0;i<n;i++) {
            value[i] = get(i);
        }
        return Arrays.toString(value);
    }
}

    void run() throws Exception
    {
        is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
        out = new PrintWriter(System.out);
        long s = System.currentTimeMillis();
        solve();
        out.flush();
        if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
    }
    
    public static void main(String[] args) throws Exception { new Main().run(); }
    
    private byte[] inbuf = new byte[1024];
    private int lenbuf = 0, ptrbuf = 0;
    
    private int readByte()
    {
        if(lenbuf == -1)throw new InputMismatchException();
        if(ptrbuf >= lenbuf){
            ptrbuf = 0;
            try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
            if(lenbuf <= 0)return -1;
        }
        return inbuf[ptrbuf++];
    }
    
    private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
    private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
    
    private double nd() { return Double.parseDouble(ns()); }
    private char nc() { return (char)skip(); }
    
    private String ns()
    {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while(!(isSpaceChar(b) && b != ' ')){
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }
    
    private char[] ns(int n)
    {
        char[] buf = new char[n];
        int b = skip(), p = 0;
        while(p < n && !(isSpaceChar(b))){
            buf[p++] = (char)b;
            b = readByte();
        }
        return n == p ? buf : Arrays.copyOf(buf, p);
    }
    
    private char[][] nm(int n, int m)
    {
        char[][] map = new char[n][];
        for(int i = 0;i < n;i++)map[i] = ns(m);
        return map;
    }
    
    private int[] na(int n)
    {
        int[] a = new int[n];
        for(int i = 0;i < n;i++)a[i] = ni();
        return a;
    }
    
    private int ni()
    {
        int num = 0, b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }
        
        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }
    
    private long nl()
    {
        long num = 0;
        int b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }
        
        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }
    
    private static void tr(Object... o) { System.out.println(Arrays.deepToString(o)); }
 
}