Problem: Many schoolchildren look for a job for the summer, and one day, when Gerald was still a schoolboy, he also decided to work in the summer. But as Gerald was quite an unusual schoolboy, he found quite unusual work. A certain Company agreed to pay him a certain sum of money if he draws them three identical circles on a plane. The circles must not interfere with each other (but they may touch each other). He can choose the centers of the circles only from the n options granted by the Company. He is free to choose the radius of the circles himself (all three radiuses must be equal), but please note that the larger the radius is, the more he gets paid. 

Help Gerald earn as much as possible.

Input

The first line contains a single integer n — the number of centers (3 ≤ n ≤ 3000). The following n lines each contain two integers xi, yi ( - 104 ≤ xi, yi ≤ 104) — the coordinates of potential circle centers, provided by the Company.

All given points are distinct.

Output

Print a single real number — maximum possible radius of circles. The answer will be accepted if its relative or absolute error doesn't exceed 10 - 6.

Examples

Input

3
0 1
1 0
1 1


Output

0.50000000000000000000


Input

7
2 -3
-2 -3
3 0
-3 -1
1 -2
2 -2
-1 0


Output

1.58113883008418980000

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Collection;
import java.io.IOException;
import java.util.Deque;
import java.io.UncheckedIOException;
import java.math.BigDecimal;
import java.io.Closeable;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.Comparator;
import java.util.ArrayDeque;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(null, new TaskAdapter(), "", 1 << 29);
        thread.start();
        thread.join();
    }

    static class TaskAdapter implements Runnable {
        @Override
        public void run() {
            InputStream inputStream = System.in;
            OutputStream outputStream = System.out;
            FastInput in = new FastInput(inputStream);
            FastOutput out = new FastOutput(outputStream);
            ESummerEarnings solver = new ESummerEarnings();
            solver.solve(1, in, out);
            out.close();
        }
    }

    static class ESummerEarnings {
        public double between(Pt a, Pt b, boolean next) {
            double res = a.angle - b.angle;
            if (next) {
                res += Math.PI * 2;
            }
            return res;
        }

        public void solve(int testNumber, FastInput in, FastOutput out) {
            int n = in.ri();
            Pt[] pts = new Pt[n];
            for (int i = 0; i < n; i++) {
                pts[i] = new Pt(in.ri(), in.ri());
            }
            Pt[] sorted = new Pt[(n - 1) * 2];
            MinQueue<Pt> mq = new MinQueue<>(n, Comparator.comparingLong(x -> -x.d2));
            double atleast = Math.PI / 3;
            long best = 0;
            for (int i = 0; i < n; i++) {
                int wpos = 0;
                for (int j = 0; j < n; j++) {
                    if (i == j) {
                        continue;
                    }
                    sorted[wpos++] = pts[j];
                }
                assert wpos == n - 1;
                for (int j = 0; j < n - 1; j++) {
                    Pt pt = sorted[j];
                    pt.angle = GeoConstant.theta(pt.x - pts[i].x, pt.y - pts[i].y);
                    pt.d2 = IntegerPoint2.dist2(pt, pts[i]);
                }
                Arrays.sort(sorted, 0, n - 1, Comparator.comparingDouble(x -> x.angle));
                for (int j = 0; j < n - 1; j++) {
                    sorted[j + n - 1] = sorted[j];
                }
                mq.clear();
                for (int j = 0, iter = 0; j < n - 1; j++) {
                    while (iter < i + n - 1 && between(sorted[iter], sorted[j], iter >= n - 1) <= Math.PI) {
                        sorted[iter].next = iter >= n - 1;
                        mq.add(sorted[iter]);
                        iter++;
                    }
                    while (!mq.isEmpty() && between(mq.first(), sorted[j], mq.first().next) < atleast) {
                        mq.removeFirst();
                    }
                    if (!mq.isEmpty()) {
                        best = Math.max(best, Math.min(sorted[j].d2, mq.query().d2));
                    }
                }
            }

            double ans = Math.sqrt(best);
            out.println(ans / 2);
        }

    }

    static class GeoConstant {
        public static double theta(double x, double y) {
            double theta = Math.atan2(y, x);
            if (theta < 0) {
                theta += Math.PI * 2;
            }
            return theta;
        }

    }

    static class MinQueue<T> {
        Deque<T> data;
        Deque<T> increasing;
        Comparator<T> comparator;

        public boolean isEmpty() {
            return data.isEmpty();
        }

        public MinQueue(int cap, Comparator<T> comparator) {
            data = new ArrayDeque<>(cap);
            increasing = new ArrayDeque<>(cap);
            this.comparator = comparator;
        }

        public void add(T x) {
            while (!increasing.isEmpty() && comparator.compare(x, increasing.peekLast()) < 0) {
                increasing.removeLast();
            }
            increasing.addLast(x);
            data.addLast(x);
        }

        public T removeFirst() {
            T head = data.removeFirst();
            if (increasing.peekFirst() == head) {
                increasing.removeFirst();
            }
            return head;
        }

        public void clear() {
            data.clear();
            increasing.clear();
        }

        public T query() {
            return increasing.peekFirst();
        }

        public T first() {
            return data.peekFirst();
        }

    }

    static class FastInput {
        private final InputStream is;
        private byte[] buf = new byte[1 << 13];
        private int bufLen;
        private int bufOffset;
        private int next;

        public FastInput(InputStream is) {
            this.is = is;
        }

        private int read() {
            while (bufLen == bufOffset) {
                bufOffset = 0;
                try {
                    bufLen = is.read(buf);
                } catch (IOException e) {
                    bufLen = -1;
                }
                if (bufLen == -1) {
                    return -1;
                }
            }
            return buf[bufOffset++];
        }

        public void skipBlank() {
            while (next >= 0 && next <= 32) {
                next = read();
            }
        }

        public int ri() {
            return readInt();
        }

        public int readInt() {
            int sign = 1;

            skipBlank();
            if (next == '+' || next == '-') {
                sign = next == '+' ? 1 : -1;
                next = read();
            }

            int val = 0;
            if (sign == 1) {
                while (next >= '0' && next <= '9') {
                    val = val * 10 + next - '0';
                    next = read();
                }
            } else {
                while (next >= '0' && next <= '9') {
                    val = val * 10 - next + '0';
                    next = read();
                }
            }

            return val;
        }

    }

    static class Pt extends IntegerPoint2 {
        double angle;
        boolean next;
        long d2;

        public Pt(long x, long y) {
            super(x, y);
        }

    }

    static class FastOutput implements AutoCloseable, Closeable, Appendable {
        private static final int THRESHOLD = 32 << 10;
        private final Writer os;
        private StringBuilder cache = new StringBuilder(THRESHOLD * 2);

        public FastOutput append(CharSequence csq) {
            cache.append(csq);
            return this;
        }

        public FastOutput append(CharSequence csq, int start, int end) {
            cache.append(csq, start, end);
            return this;
        }

        private void afterWrite() {
            if (cache.length() < THRESHOLD) {
                return;
            }
            flush();
        }

        public FastOutput(Writer os) {
            this.os = os;
        }

        public FastOutput(OutputStream os) {
            this(new OutputStreamWriter(os));
        }

        public FastOutput append(char c) {
            cache.append(c);
            afterWrite();
            return this;
        }

        public FastOutput append(double c) {
            cache.append(new BigDecimal(c).toPlainString());
            afterWrite();
            return this;
        }

        public FastOutput println(double c) {
            return append(c).println();
        }

        public FastOutput println() {
            return append('\n');
        }

        public FastOutput flush() {
            try {
//            boolean success = false;
//            if (stringBuilderValueField != null) {
//                try {
//                    char[] value = (char[]) stringBuilderValueField.get(cache);
//                    os.write(value, 0, cache.length());
//                    success = true;
//                } catch (Exception e) {
//                }
//            }
//            if (!success) {
                os.append(cache);
//            }
                os.flush();
                cache.setLength(0);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
            return this;
        }

        public void close() {
            flush();
            try {
                os.close();
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }

        public String toString() {
            return cache.toString();
        }

    }

    static class IntegerPoint2 {
        public final long x;
        public final long y;

        public IntegerPoint2(long x, long y) {
            this.x = x;
            this.y = y;
        }

        public IntegerPoint2() {
            this(0, 0);
        }

        public static long dist2(IntegerPoint2 a, IntegerPoint2 b) {
            long dx = a.x - b.x;
            long dy = a.y - b.y;
            return dx * dx + dy * dy;
        }

        public IntegerPoint2 clone() {
            try {
                return (IntegerPoint2) super.clone();
            } catch (CloneNotSupportedException e) {
                throw new RuntimeException(e);
            }
        }

        public String toString() {
            return String.format("(%d, %d)", x, y);
        }

    }
}