Problem: In a far away kingdom lives a very greedy king. To defend his land, he built n guard towers. Apart from the towers the kingdom has two armies, each headed by a tyrannical and narcissistic general. The generals can't stand each other, specifically, they will never let soldiers of two armies be present in one tower.

During defence operations to manage a guard tower a general has to send part of his army to that tower. Each general asks some fee from the king for managing towers. As they live in a really far away kingdom, each general evaluates his fee in the following weird manner: he finds two remotest (the most distant) towers, where the soldiers of his army are situated and asks for the fee equal to the distance. Each tower is represented by a point on the plane with coordinates (x, y), and the distance between two points with coordinates (x1, y1) and (x2, y2) is determined in this kingdom as |x1 - x2| + |y1 - y2|.

The greedy king was not exactly satisfied with such a requirement from the generals, that's why he only agreed to pay one fee for two generals, equal to the maximum of two demanded fees. However, the king is still green with greed, and among all the ways to arrange towers between armies, he wants to find the cheapest one. Each tower should be occupied by soldiers of exactly one army.

He hired you for that. You should find the minimum amount of money that will be enough to pay the fees. And as the king is also very scrupulous, you should also count the number of arrangements that will cost the same amount of money. As their number can be quite large, it is enough for the king to know it as a remainder from dividing by 109 + 7.

Two arrangements are distinct if the sets of towers occupied by soldiers of the first general are distinct.

Input

The first line contains an integer n (2 ≤ n ≤ 5000), n is the number of guard towers. Then follow n lines, each of which contains two integers x, y — the coordinates of the i-th tower (0 ≤ x, y ≤ 5000). No two towers are present at one point.

Pretest 6 is one of the maximal tests for this problem.

Output

Print on the first line the smallest possible amount of money that will be enough to pay fees to the generals. 

Print on the second line the number of arrangements that can be carried out using the smallest possible fee. This number should be calculated modulo 1000000007 (109 + 7).

Examples

Input

2
0 0
1 1


Output

0
2


Input

4
0 0
0 1
1 0
1 1


Output

1
4


Input

3
0 0
1000 1000
5000 5000


Output

2000
2

Note

In the first example there are only two towers, the distance between which is equal to 2. If we give both towers to one general, then we well have to pay 2 units of money. If each general receives a tower to manage, to fee will be equal to 0. That is the smallest possible fee. As you can easily see, we can obtain it in two ways.

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Towers implements Runnable {
    static final long MODULO = 1000000007;

    static class Point {
        int x;
        int y;
        int id;

        Point(int id) {
            this.id = id;
        }
    }

    static class PointWithData implements Comparable<PointWithData> {
        int data;
        Point point;

        PointWithData(int data, Point point) {
            this.data = data;
            this.point = point;
        }

        public int compareTo(PointWithData point) {
            return data - point.data;
        }
    }

    static class Result {
        final boolean any;
        final long amount;

        Result(boolean any, long amount) {
            this.any = any;
            this.amount = amount;
        }
    }

    static Result add(Result a, Result b) {
        if (!a.any) return b;
        if (!b.any) return a;
        return new Result(true, (a.amount + b.amount) % MODULO);
    }

    private void solve() throws IOException {
        int n = nextInt();
        Point[] p = new Point[n];
        for (int i = 0; i < n; ++i) {
            p[i] = new Point(i);
            p[i].x = nextInt();
            p[i].y = nextInt();
        }
        PointWithData[] plus = new PointWithData[n];
        for (int i = 0; i < n; ++i)
            plus[i] = new PointWithData(p[i].x + p[i].y, p[i]);
        Arrays.sort(plus);
        PointWithData[] minus = new PointWithData[n];
        for (int i = 0; i < n; ++i)
            minus[i] = new PointWithData(p[i].x - p[i].y, p[i]);
        Arrays.sort(minus);
        int left = -1;
        int right = 10001;
        while (right - left > 1) {
            int middle = (left + right) / 2;
            Result cur = numWays(p, plus, minus, middle);
            if (cur.any)
                right = middle;
            else
                left = middle;
        }
        writer.println(right);
        writer.println(numWays(p, plus, minus, right).amount);
    }

    private Result numWays(Point[] points, PointWithData[] plus, PointWithData[] minus, int maxDist) {
        if (plus[plus.length - 1].data - plus[0].data <= maxDist) {
            return handleMinus(points, minus, maxDist, new boolean[points.length], new boolean[points.length]);
        } else {
            Result res = new Result(false, 0);
            {
                boolean[] kill1 = new boolean[points.length];
                boolean[] kill2 = new boolean[points.length];
                for (PointWithData pp : plus) {
                    if (pp.data - plus[0].data > maxDist)
                        kill1[pp.point.id] = true;
                    if (plus[plus.length - 1].data - pp.data > maxDist)
                        kill2[pp.point.id] = true;
                }
                res = add(res, handleMinus(points, minus, maxDist, kill1, kill2));
            }
            {
                boolean[] kill1 = new boolean[points.length];
                boolean[] kill2 = new boolean[points.length];
                for (PointWithData pp : plus) {
                    if (pp.data - plus[0].data > maxDist)
                        kill2[pp.point.id] = true;
                    if (plus[plus.length - 1].data - pp.data > maxDist)
                        kill1[pp.point.id] = true;
                }
                res = add(res, handleMinus(points, minus, maxDist, kill1, kill2));
            }
            return res;
        }
    }

    private Result handleMinus(Point[] points, PointWithData[] minus, int maxDist, boolean[] skill1, boolean[] skill2) {
        if (minus[minus.length - 1].data - minus[0].data <= maxDist) {
            return handleResult(points, skill1, skill2);
        } else {
            Result res = new Result(false, 0);
            {
                boolean[] kill1 = skill1.clone();
                boolean[] kill2 = skill2.clone();
                for (PointWithData pp : minus) {
                    if (pp.data - minus[0].data > maxDist)
                        kill1[pp.point.id] = true;
                    if (minus[minus.length - 1].data - pp.data > maxDist)
                        kill2[pp.point.id] = true;
                }
                res = add(res, handleResult(points, kill1, kill2));
            }
            {
                boolean[] kill1 = skill1.clone();
                boolean[] kill2 = skill2.clone();
                for (PointWithData pp : minus) {
                    if (pp.data - minus[0].data > maxDist)
                        kill2[pp.point.id] = true;
                    if (minus[minus.length - 1].data - pp.data > maxDist)
                        kill1[pp.point.id] = true;
                }
                res = add(res, handleResult(points, kill1, kill2));
            }
            return res;
        }
    }

    private Result handleResult(Point[] points, boolean[] kill1, boolean[] kill2) {
        int p2 = 0;
        for (int i = 0; i < points.length; ++i) {
            if (kill1[i] && kill2[i]) return new Result(false, 0);
            if (!kill1[i] && !kill2[i]) ++p2;
        }
        long cnt = 1;
        for (int i = 0; i < p2; ++i) {
            cnt = (cnt * 2) % MODULO;
        }
        return new Result(true, cnt);
    }

    public static void main(String[] args) {
        new Towers().run();
    }

    BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter writer;

    public void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            writer = new PrintWriter(System.out);
            solve();
            reader.close();
            writer.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }
}