For this Question: <i> Why Geometry?? ? </i>

You are given 4*N+1 distinct points on the cartesian plane. Out of these points, 4*N points represent the end points of N rectangles (<b>with axis parallel to co-ordinate axis</b>), while one point does not belong to any of the rectangles. Report the coordinates of the point that does not belong to any of the N rectangles.The first line of the input contains an integer N.
The next 4*N+1 lines contain two integers X and Y, the coordinates of the given points.

Constraints
1 <= N <= 100000
0 <= X, Y <= 1000000
The given points always represent N rectangles and an extra pointOutput space separated X and Y coordinates of the extra point.Samle Input
1
1 3
1 1
3 1
1 4
3 3

Sample Output
1 4

Explanation: (1, 1), (1, 3), (3, 1), and (3, 3) represent the end of a rectangle, while (1, 4) is the extra point., I have written this Solution Code: import java.io.*;
        import java.io.IOException;
    import java.math.BigInteger;
    import java.util.*;













        public  class Main {


                public static long mod = 1000000007 ;
                public static double epsilon=0.00000000008854;
                public static InputReader sc = new InputReader(System.in);
                public static PrintWriter pw = new PrintWriter(System.out);

                public static long pow(long x,long y,long mod){
                    long ans=1;

                    x%=mod;
                    while(y>0){
                        if((y&1)==1){
                            ans=(ans*x)%mod;
                        }
                        y=y>>1;
                        x=(x*x)%mod;
                    }
                    return ans;
                }

                public static void main(String[] args) throws Exception {

                    int n=sc.nextInt();
                    n=4*n+1;
                    int x=0,y=0;
                    for(int i=0;i<n;i++){
                        int a=sc.nextInt();
                        x^=a;
                        int b=sc.nextInt();
                        y^=b;
                    }
                    pw.println(x+" "+y);






                    pw.flush();
                    pw.close();
                }
                public static Comparator<Integer[]> MOquery(int block){
                    return
                    new Comparator<Integer[]>(){
                        @Override
                        public int compare(Integer a[],Integer b[]){
                            int a1=a[0]/block;
                            int b1=b[0]/block;
                            if(a1==b1){
                                if((a1&1)==1)
                                return a[1].compareTo(b[1]);
                                else{
                                    return b[1].compareTo(a[1]);
                                }
                            }
                            return a1-b1;
                        }
                    };
                }

                public static Comparator<Long[]> column(int i){
                    return
                    new Comparator<Long[]>() {
                        @Override
                        public int compare(Long[] o1, Long[] o2) {
                            return o1[i].compareTo(o2[i]);

                        }
                    };
                }
                public static Comparator<Integer[]> column(){
                    return
                    new Comparator<Integer[]>() {
                        @Override
                        public int compare(Integer[] o1, Integer[] o2) {


                            long a1=o1[0];
                            long a2=o2[1];
                            long b1=o2[0];
                            long b2=o1[1];
                            int ans=0;
                            if(a1*a2>b1*b2){
                                ans=1;
                            }
                            else ans=-1;
                            return ans;
                        }
                    };
                }
                public static Comparator<Integer[]> col(int i){
                    return
                    new Comparator<Integer[]>() {
                        @Override
                        public int compare(Integer[] o1, Integer[] o2) {
                            if(o1[i]-o2[i]!=0)
                            return o1[i].compareTo(o2[i]);
                            return o1[i+1].compareTo(o2[i+1]);

                        }
                    };
                }
                public static Comparator<Integer> des(){
                    return
                    new Comparator<Integer>() {
                        @Override
                        public int compare(Integer o1, Integer o2) {

                            return o2.compareTo(o1);
                        }
                    };
                }




                public static String reverseString(String s){
                    StringBuilder input1 = new StringBuilder();
                    input1.append(s);
                    input1 = input1.reverse();
                    return input1.toString();
                }
                public static int[] scanArray(int n){
                    int a[]=new int [n];

                    for(int i=0;i<n;i++){
                        a[i]=sc.nextInt();
                    }


                    return a;
                }
                public static long[] scanLongArray(int n){
                    long a[]=new long [n];
                    for(int i=0;i<n;i++)
                    a[i]=sc.nextLong();

                    return a;
                }
                public static String [] scanStrings(int n){
                    String a[]=new String [n];
                    for(int i=0;i<n;i++)
                    a[i]=sc.nextLine();

                    return a;
                }
                public static class InputReader {

                    private final InputStream stream;
                    private final byte[] buf = new byte[8192];
                    private int curChar, snumChars;
                    private SpaceCharFilter filter;

                    public InputReader(InputStream stream) {
                        this.stream = stream;
                    }

                    public int snext() {
                        if (snumChars == -1)
                            throw new InputMismatchException();
                        if (curChar >= snumChars) {
                            curChar = 0;
                            try {
                                snumChars = stream.read(buf);
                            } catch (IOException e) {
                                throw new InputMismatchException();
                            }
                            if (snumChars <= 0)
                                return -1;
                        }
                        return buf[curChar++];
                    }

                    public int nextInt() {
                        int c = snext();
                        while (isSpaceChar(c)) {
                            c = snext();
                        }
                        int sgn = 1;
                        if (c == '-') {
                            sgn = -1;
                            c = snext();
                        }
                        int res = 0;
                        do {
                            if (c < '0' || c > '9')
                                throw new InputMismatchException();
                            res *= 10;
                            res += c - '0';
                            c = snext();
                        } while (!isSpaceChar(c));
                        return res * sgn;
                    }

                    public long nextLong() {
                        int c = snext();
                        while (isSpaceChar(c)) {
                            c = snext();
                        }
                        int sgn = 1;
                        if (c == '-') {
                            sgn = -1;
                            c = snext();
                        }
                        long res = 0;
                        do {
                            if (c < '0' || c > '9')
                                throw new InputMismatchException();
                            res *= 10;
                            res += c - '0';
                            c = snext();
                        } while (!isSpaceChar(c));
                        return res * sgn;
                    }

                    public int[] nextIntArray(int n) {
                        int a[] = new int[n];
                        for (int i = 0; i < n; i++) {
                            a[i] = nextInt();
                        }
                        return a;
                    }

                    public String readString() {
                        int c = snext();
                        while (isSpaceChar(c)) {
                            c = snext();
                        }
                        StringBuilder res = new StringBuilder();
                        do {
                            res.appendCodePoint(c);
                            c = snext();
                        } while (!isSpaceChar(c));
                        return res.toString();
                    }

                    public String nextLine() {
                        int c = snext();
                        while (isSpaceChar(c))
                            c = snext();
                        StringBuilder res = new StringBuilder();
                        do {
                            res.appendCodePoint(c);
                            c = snext();
                        } while (!isEndOfLine(c));
                        return res.toString();
                    }

                    public boolean isSpaceChar(int c) {
                        if (filter != null)
                            return filter.isSpaceChar(c);
                        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
                    }

                    private boolean isEndOfLine(int c) {
                        return c == '\n' || c == '\r' || c == -1;
                    }

                    public interface SpaceCharFilter {
                        public boolean isSpaceChar(int ch);
                    }
                }

            }, In this Programming Language: Java, Now tell me if this Code is compilable or not?