Problem: Nowadays, most of the internet advertisements are not statically linked to a web page. Instead, what will be shown to the person opening a web page is determined within 100 milliseconds after the web page is opened. Usually, multiple companies compete for each ad slot on the web page in an auction. Each of them receives a request with details about the user, web page and ad slot and they have to respond within those 100 milliseconds with a bid they would pay for putting an advertisement on that ad slot. The company that suggests the highest bid wins the auction and gets to place its advertisement. If there are several companies tied for the highest bid, the winner gets picked at random.

However, the company that won the auction does not have to pay the exact amount of its bid. In most of the cases, a second-price auction is used. This means that the amount paid by the company is equal to the maximum of all the other bids placed for this ad slot.

Let's consider one such bidding. There are n companies competing for placing an ad. The i-th of these companies will bid an integer number of microdollars equiprobably randomly chosen from the range between Li and Ri, inclusive. In the other words, the value of the i-th company bid can be any integer from the range [Li, Ri] with the same probability. 

Determine the expected value that the winner will have to pay in a second-price auction.

Input

The first line of input contains an integer number n (2 ≤ n ≤ 5). n lines follow, the i-th of them containing two numbers Li and Ri (1 ≤ Li ≤ Ri ≤ 10000) describing the i-th company's bid preferences.

This problem doesn't have subproblems. You will get 8 points for the correct submission.

Output

Output the answer with absolute or relative error no more than 1e - 9.

Examples

Input

3
4 7
8 10
5 5


Output

5.7500000000


Input

3
2 5
3 4
1 6


Output

3.5000000000

Note

Consider the first example. The first company bids a random integer number of microdollars in range [4, 7]; the second company bids between 8 and 10, and the third company bids 5 microdollars. The second company will win regardless of the exact value it bids, however the price it will pay depends on the value of first company's bid. With probability 0.5 the first company will bid at most 5 microdollars, and the second-highest price of the whole auction will be 5. With probability 0.25 it will bid 6 microdollars, and with probability 0.25 it will bid 7 microdollars. Thus, the expected value the second company will have to pay is 0.5·5 + 0.25·6 + 0.25·7 = 5.75.

Solution (in JAVA):

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

public class SecondPriceAuction {
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        
        int N = sc.nextInt();
        
        int[] L = new int[N];
        int[] R = new int[N];
        int[] O = new int[N];
        int[] range = new int[N];
        for (int i = 0; i < N; i++) {
        	L[i] = sc.nextInt();
        	R[i] = sc.nextInt();
        	O[i] = i;
        	range[i] = R[i] - L[i] + 1;
        }
        
        int[][] perms = getPermutations(N, N);
        
        int fac = 1;
        for (int i = 2; i <= N - 2; i++) {
        	fac *= i;
        }
        
        double ev = 0;
        for (int b = 1; b <= 10000; b++) {
        	for (int s = 0; s < N; s++) {
        		double[][] tbl = new double[N][];
        		for (int i = 0; i < N; i++) {
        			tbl[i] = getProbs(L[i], R[i], i, b, s);
        		}
        		double pb = 0;
        		for (int[] perm : perms) {
        			double rest = 1;
        			for (int i = 2; i < N; i++) {
        				rest *= tbl[perm[i]][0];
        			}
            		pb += tbl[perm[0]][1] * tbl[perm[1]][2] * rest;
        		}
        		ev += pb * b;
        	}
        }
        System.out.println(ev / fac);
        
//        int[][] perms = getPermutations(N, N);
//		double ev = 0;
//        for (int[] perm : perms) {
//        	for (int x = L[perm[0]]; x <= R[perm[0]]; x++) {
//        		double tmp = (double)(R[perm[1]] - x) / range[perm[1]];
////        		if (R[perm[1]] >= x && L[perm[1]] <= x && perm[1] < perm[0]) {
////        			tmp += 1.0 / range[perm[1]];
////        		}
//        		double inner = Math.min(tmp, 1.0);
//        		double p2 = Math.max(inner, 0.0);
//        		double prodP = 1.0;
//        		for (int k = 2; k < N; k++) {
//        			double tmpK = (double)(x - L[perm[k]] + 1) / range[perm[k]];
////        			if (R[perm[k]] >= x && L[perm[k]] <= x && perm[k] < perm[0]) {
////        				tmpK += 1.0 / range[perm[k]];
////        			}
//        			double innerK = Math.min(tmpK, 1.0);
//        			double pK = Math.max(innerK, 0.0);
//        			prodP *= pK;
//        		}
//        		ev += x * p2 * prodP / range[perm[0]];
//        		System.out.format("perm = %s, x = %d, p2 = %f, prodP = %f, ev = %f\n", Arrays.toString(perm), x, p2, prodP, ev);
//        	}
//        }
//        if (N >= 2) {
//	        for (int[] perm : perms) {
//	        	for (int x = L[perm[0]]; x <= R[perm[0]]; x++) {
//	        		double prodP = 1.0;
//	        		if (L[perm[1]] <= x && x <= R[perm[1]] && perm[0] < perm[1]) {
//	        			for (int k = 2; k < N; k++) {
//	        				double tmpK = (double)(x - L[perm[k]]) / range[perm[k]];
//	        				double innerK = Math.min(tmpK, 1.0);
//	            			double pK = Math.max(innerK, 0.0);
//	            			prodP *= pK;
//	        			}
//	        			ev -= (double)x * prodP / (range[perm[0]] * range[perm[1]]);
//	        			System.out.format("2) perm = %s, x = %d, ev = %f\n", Arrays.toString(perm), x, ev);
//	        		}
//	        	}
//	        }
//        }
//        if (N >= 3) {
//	        for (int[] perm : perms) {
//	        	for (int x = L[perm[0]]; x <= R[perm[0]]; x++) {
//	        		if (L[perm[1]] <= x && x <= R[perm[1]] && L[perm[2]] <= x && x <= R[perm[2]] && perm[0] < perm[1] && perm[1] < perm[2]) {
//	        			ev += (double)x / (range[perm[0]] * range[perm[1]] * range[perm[2]]);
//	        			System.out.format("3) perm = %s, x = %d, ev = %f\n", Arrays.toString(perm), x, ev);
//	        		}
//	        	}
//	        }
//        }
//        if (N >= 4) {
//	        for (int[] perm : perms) {
//	        	for (int x = L[perm[0]]; x <= R[perm[0]]; x++) {
//	        		if (L[perm[1]] <= x && x <= R[perm[1]] && L[perm[2]] <= x && x <= R[perm[2]] && L[perm[3]] <= x && x <= R[perm[3]]) {
//	        			ev -= (double)x / (range[perm[0]] * range[perm[1]] * range[perm[2]] * range[perm[3]]);
//	        			System.out.format("4) perm = %s, x = %d, ev = %f\n", Arrays.toString(perm), x, ev);
//	        		}
//	        	}
//	        }
//        }
////        if (N >= 5) {
////	        for (int[] perm : perms) {
////	        	for (int x = L[perm[0]]; x <= R[perm[0]]; x++) {
////	        		if (L[perm[1]] <= x && x <= R[perm[1]] && L[perm[2]] <= x && x <= R[perm[2]] && L[perm[3]] <= x && x <= R[perm[3]]&& L[perm[4]] <= x && x <= R[perm[4]]) {
////	        			ev += (double)x / (range[perm[0]] * range[perm[1]] * range[perm[2]] * range[perm[3]] * range[perm[4]]);
////	        			System.out.format("5) perm = %s, x = %d, ev = %f\n", Arrays.toString(perm), x, ev);
////	        		}
////	        	}
////	        }
////        }
//        System.out.println(ev);
    }
    
    public static double[] getProbs(int lo, int hi, int idx, int v, int sub) {
    	double[] p = new double[3];
    	int r = hi - lo + 1;
    	p[0] = Math.min(1, Math.max(0, (double)(v - lo) / r));
    	p[1] = (lo <= v && v <= hi) ? (1.0 / r) : 0;
    	p[2] = Math.min(1, Math.max(0, (double)(hi - v) / r));
    	if (idx < sub) {
    		p[0] += p[1];
    		p[1] = 0;
    	} else if (idx > sub) {
    		p[2] += p[1];
    		p[1] = 0;
    	}
    	return p;
    }

    /**
     * Method for computing permutations.  Returns an array of int[], which contains k elements from { 0, 1, ..., n - 1 }.
     * Each int[] will be sorted in ascending order, and they array of int[] will be sorted ascending as well.
     */
    public static int[][] getPermutations(int n, int k)
    {
        ArrayList<int[]> lst = new ArrayList<int[]>();
        int[] arr = new int[k];
        boolean[] used = new boolean[n];
        permutationHelper(n, k, 0, arr, used, lst);
        return lst.toArray(new int[0][]);
    }

    /**
     * Helper method for computing permutations.  Used by GetPermutations(...).
     */
    private static void permutationHelper(int n, int k, int t, int[] curr, boolean[] used, ArrayList<int[]> lst)
    {
        if (t == k)
        {
            int[] copy = new int[k];
            System.arraycopy(curr, 0, copy, 0, k);
            lst.add(copy);
            return;
        }

        for (int i = 0; i < n; i++)
        {
            if (used[i])
                continue;

            curr[t] = i;
            used[i] = true;
            permutationHelper(n, k, t + 1, curr, used, lst);
            used[i] = false;
        }
    }

    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        int nextInt() {
            return Integer.parseInt(next());
        }
        
        int[] nextIntArray(int n) {
        	int[] arr = new int[n];
        	for (int i = 0; i < n; i++) {
        		arr[i] = nextInt();
        	}
        	return arr;
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        String nextLine() {
            String str = "";
            try { str = br.readLine(); }
            catch (IOException e) { e.printStackTrace(); }
            return str;
        }
    }
}