Problem: We often go to supermarkets to buy some fruits or vegetables, and on the tag there prints the price for a kilo. But in some supermarkets, when asked how much the items are, the clerk will say that a yuan for b kilos (You don't need to care about what "yuan" is), the same as a/b yuan for a kilo.

Now imagine you'd like to buy m kilos of apples. You've asked n supermarkets and got the prices. Find the minimum cost for those apples.

You can assume that there are enough apples in all supermarkets.

Input

The first line contains two positive integers n and m (1 ≤ n ≤ 5 000, 1 ≤ m ≤ 100), denoting that there are n supermarkets and you want to buy m kilos of apples.

The following n lines describe the information of the supermarkets. Each line contains two positive integers a, b (1 ≤ a, b ≤ 100), denoting that in this supermarket, you are supposed to pay a yuan for b kilos of apples.

Output

The only line, denoting the minimum cost for m kilos of apples. Please make sure that the absolute or relative error between your answer and the correct answer won't exceed 10^{-6}.

Formally, let your answer be x, and the jury's answer be y. Your answer is considered correct if \frac{|x - y|}{max{(1, |y|)}} ≤ 10^{-6}.

Examples

Input

3 5
1 2
3 4
1 3


Output

1.66666667


Input

2 1
99 100
98 99


Output

0.98989899

Note

In the first sample, you are supposed to buy 5 kilos of apples in supermarket 3. The cost is 5/3 yuan.

In the second sample, you are supposed to buy 1 kilo of apples in supermarket 2. The cost is 98/99 yuan.

Solution (in JAVA):

Solution:
    import java.io.*;
    import java.math.BigInteger;
    import java.math.RoundingMode;
    import java.text.DecimalFormat;
    import java.util.*;
    
    
   public class some {
    
        static double eps=(double)1e-6;
        static long mod=(int)1e9+7;
        static long d,x,y;
        static long  phi[],sumOfGCD[];
        public static void main(String args[]){
            InputReader sc = new InputReader(System.in);
            OutputStream outputStream = System.out;
            PrintWriter out = new PrintWriter(outputStream);
            //---Code Begins Here--------
            
            int n = sc.nextInt();
            int m = sc.nextInt();
            double d = Double.MAX_VALUE;
            
            for(int i=0; i<n; i++)
            {
            	int a = sc.nextInt();
            	int b = sc.nextInt();
            	
            	double c = (a*1.0)/b;
            	if(c < d)
            		d = c;
            }
            System.out.println(d*m);
            
            //---The End-----------------
            out.close();
        }
        
        static long modInverse(long A,long M)
		{
		    return modularExpon(A,M-2,M);
		}
        static long modularExpon(long x,long n,long M)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result * x)%M;
		        x=(x*x)%M;
		        n=n/2;
		    }
		    return result%M;
		}
        static long[] dp = new long[10000001];
        
        static long[] initdp(long[] dp)
        {
        	for(int i=0; i<dp.length; i++)
        		dp[i] = -1;
        	return dp;
        }
        
        static long comb(long ans, long x, long mod)
        {
        	//System.out.println("x = " + x);
        	
        	if(x==0)
        	{
        		dp[(int)x]=1;
        		return 1;
        	}
        	
        	if(x<0 || x>ans)
        		return 0;
 
        	if(x>(ans-(ans/2)))
        		return comb(ans,ans-x,mod);
        	
        	if(dp[(int)x]!=-1)
        		return dp[(int)x];
        	
        	dp[(int)x] = (((ans-x+1+mod)%mod * comb(ans, x-1, mod)%mod)%mod * modInverse(x, mod)%mod)%mod;
        	return dp[(int)x];
        }
        
        
        private static long fact(long count) {
            long ans=1;
            for(int i=2;i<=count;i++)
                ans*=i;
            return ans;
        }
        static int[] spf(int n)
        {
            int spf[] = new int[n+1];
            Arrays.fill(spf,0);
            spf[1] = 1;
         
            for (int i = 2; i <= n; i++)
            {
                if (spf[i] == 0)
                {
                    spf[i] = i;
                    for (int j = 2*i; j <= n; j += i)
                        if (spf[j] == 0)
                           spf[j] = i;
                    
                }  
            }
            return spf;
        }
        
        static int[] sieve(int n)
            {
                int prime[] = new int[n+1];
                for(int i=0;i<n;i++)
                    prime[i] = 1;
                prime[0]=0;
                prime[1]=0;
                for(int p = 2; p*p <=n; p++)
                {
                    // If prime[p] is not changed, then it is a prime
                    if(prime[p] == 1)
                    {
                        // Update all multiples of p
                        for(int i = p*2; i <= n; i += p)
                            prime[i] = 0;
                    }
                
                }
                return prime;
            }
        
        
        public static void computeTotient(int n)
        {
            phi = new long[n+1];
            for (int i=1; i<=n; i++)
                phi[i] = i;
         
            for (int p=2; p<=n; p++)
            {
                // If phi[p] is not computed already,
                // then number p is prime
                if (phi[p] == p)
                {
                    // Phi of a prime number p is
                    // always equal to p-1.
                    phi[p] = p-1;
         
                    // Update phi values of all
                    // multiples of p
                    for (int i = 2*p; i<=n; i += p)
                    {
                       // Add contribution of p to its
                       // multiple i by multiplying with
                       // (1 - 1/p)
                       phi[i] = (phi[i]/p) * (p-1);
                    }
                }
            }
        }
        public static void sumOfGcdPairs(int MAX)
        {
            computeTotient(MAX);
            sumOfGCD = new long[MAX];
            for (int i=1; i<MAX; ++i)
            {
                // Iterate throght all the divisors
                // of i.
                for (int j=2; i*j<MAX; ++j)
                     sumOfGCD[i*j] += i*phi[j];
            }
         
            for (int i=2; i<MAX; i++)
                 sumOfGCD[i] +=  sumOfGCD[i-1];
        }
        
        static void extendedEuclid(long A, long B) {
            if(B == 0) {
                d = A;
                x = 1;
                y = 0;
            }
            else {
                extendedEuclid(B, A%B);
                long temp = x;
                x = y;
                y = temp - (A/B)*y;
            }
        }

        static int power(int x,int n)
        {
            if(n==0)
                return 1;
            else if(n%2 == 0)        //n is even
                return power(x*x,n/2);
            else                             //n is odd
                return x*power(x*x,(n-1)/2);
        }
         static long ce(long x)
            {
                if(x%2!=0)
                    return x/2+1;
                return x/2;
            }
        static boolean isSubSequence(String str1, String str2, int m, int n)
        {
           int j = 0;
           for (int i=0; i<n&&j<m; i++)
               if (str1.charAt(j) == str2.charAt(i))
                 j++;
         
           return (j==m);
        }
            
        static long fibo(long l) {
            if (l < 0) {
                throw new IllegalArgumentException("The fibo value cannot be negative");
            }
    
            if (l <= 1) return l;
    
            long[][] result = {{1, 0}, {0, 1}}; // identity matrix.
            long[][] fiboM = {{1, 1}, {1, 0}};
    
            while (l > 0) {
                if (l%2 == 1) {
                    multMatrix(result, fiboM);
                }
                l = l / 2;
                multMatrix(fiboM, fiboM);
            }
    
            return result[1][0];
        }
    
        private static void multMatrix(long[][] result, long[][] fiboM) {
            long a = (result[0][0]%mod * fiboM[0][0]%mod)%mod +  (result[0][1]%mod * fiboM[1][0]%mod)%mod;
            long b = (result[0][0]%mod * fiboM[0][1]%mod)%mod + ( result[0][1]%mod * fiboM[1][1]%mod)%mod;
            long c = (result[1][0]%mod * fiboM[0][0]%mod)%mod + ( result[1][1]%mod * fiboM[0][1]%mod)%mod;
            long d = (result[1][0]%mod * fiboM[0][1]%mod)%mod +  (result[1][1]%mod * fiboM[1][1]%mod)%mod;
    
            result[0][0] = a;
            result[0][1] = b;
            result[1][0] = c;
            result[1][1] = d;
        }
        
        
        static boolean isPal(String s)
        {
            for(int i=0, j=s.length()-1;i<=j;i++,j--)
            {
                if(s.charAt(i)!=s.charAt(j)) return false;
            }
            return true;
        }
        public static String rev(String s)
        {
            StringBuilder sb=new StringBuilder(s);
            sb.reverse();
            return sb.toString();
        }
            
        static long lcm(long a, long b)
        {
            return a * (b / gcd(a, b));
        }
        
        static long gcd(long a, long b)
        {
            while (b > 0)
            {
                long temp = b;
                b = a % b; // % is remainder
                a = temp;
            }
            return a;
        }
        static long modulo(long a,long b,long c) {
            long x=1;
            long y=a;
            while(b > 0){
                if(b%2 == 1){
                    x=(x*y)%c;
                }
                y = (y*y)%c; // squaring the base
                b /= 2;
            }
            return  x%c;
        }
        
        static int mergeSort(int arr[], int array_size)
        {
            int temp[] = new int[array_size];
            return _mergeSort(arr, temp, 0, array_size - 1);
        }
          
        /* An auxiliary recursive method that sorts the input array and
          returns the number of inversions in the array. */
        static int _mergeSort(int arr[], int temp[], int left, int right)
        {
          int mid, inv_count = 0;
          if (right > left)
          {
            /* Divide the array into two parts and call _mergeSortAndCountInv()
               for each of the parts */
            mid = (right + left)/2;
          
            /* Inversion count will be sum of inversions in left-part, right-part
              and number of inversions in merging */
            inv_count  = _mergeSort(arr, temp, left, mid);
            inv_count += _mergeSort(arr, temp, mid+1, right);
          
            /*Merge the two parts*/
            inv_count += merge(arr, temp, left, mid+1, right);
          }
          return inv_count;
        }
          
        /* This method merges two sorted arrays and returns inversion count in
           the arrays.*/
        static int merge(int arr[], int temp[], int left, int mid, int right)
        {
          int i, j, k;
          int inv_count = 0;
          
          i = left; /* i is index for left subarray*/
          j = mid;  /* j is index for right subarray*/
          k = left; /* k is index for resultant merged subarray*/
          while ((i <= mid - 1) && (j <= right))
          {
            if (arr[i] <= arr[j])
            {
              temp[k++] = arr[i++];
            }
            else
            {
              temp[k++] = arr[j++];
          
             /*this is tricky -- see above explanation/diagram for merge()*/
              inv_count = inv_count + (mid - i);
            }
          }
          
          /* Copy the remaining elements of left subarray
           (if there are any) to temp*/
          while (i <= mid - 1)
            temp[k++] = arr[i++];
          
          /* Copy the remaining elements of right subarray
           (if there are any) to temp*/
          while (j <= right)
            temp[k++] = arr[j++];
          
          /*Copy back the merged elements to original array*/
          for (i=left; i <= right; i++)
            arr[i] = temp[i];
          
          return inv_count;
        }
        
        
        
        
        public static void debug(Object... o) {
            System.out.println(Arrays.deepToString(o));
        }
        
        
        
        
        static class Pair implements Comparable<Pair>{
            int x;
            int y;
            Pair(int l,int i){
                x=l;
                y=i;
            }
            
            @Override
            public int compareTo(Pair o) {
                return Integer.compare(this.x, o.x);
            }
        }
    
        static class InputReader {
            public BufferedReader reader;
            public StringTokenizer tokenizer;
    
            public InputReader(InputStream inputstream) {
                reader = new BufferedReader(new InputStreamReader(inputstream));
                tokenizer = null;
            }
    
            public String nextLine(){
                String fullLine=null;
                while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                    try {
                        fullLine=reader.readLine();
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                    return fullLine;
                }
                return fullLine;
            }
            public String next() {
                while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                    try {
                        tokenizer = new StringTokenizer(reader.readLine());
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }
                return tokenizer.nextToken();
            }
            public long nextLong() {
                return Long.parseLong(next());
            }
            public int nextInt() {
                return Integer.parseInt(next());
            }
        }
        
    }