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.
The first line contains two positive integers $n$ and $m$ ($1 \leq n \leq 5\,000$, $1 \leq m \leq 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 \leq a, b \leq 100$), denoting that in this supermarket, you are supposed to pay $a$ yuan for $b$ kilos of apples.
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.
3 5
1 2
3 4
1 3
1.66666667
2 1
99 100
98 99
0.98989899
50 37
78 49
96 4
86 62
28 4
19 2
79 43
79 92
95 35
33 60
54 84
90 25
2 25
53 21
86 52
72 25
6 78
41 46
3 68
42 89
33 35
57 43
99 45
1 82
38 62
11 50
55 84
1 97
12 67
51 96
51 7
1 100
79 61
66 54
97 93
52 75
80 54
98 73
29 28
73 96
24 73
3 25
1 29
43 50
97 95
54 64
38 97
68 16
22 68
25 91
77 13
0.37000000
5 1
5 100
55 6
53 27
57 53
62 24
0.05000000
10 7
83 93
90 2
63 51
51 97
7 97
25 78
17 68
30 10
46 14
22 28
0.50515464
1 100
100 1
10000.00000000
1 1
59 1
59.00000000
1 100
1 100
1.00000000
1 100
1 99
1.01010101
1 1
100 1
100.00000000
15 100
1 2
3 4
10 11
12 13
20 21
28 29
34 35
42 43
59 60
61 62
74 75
89 90
96 97
98 99
99 100
50.00000000
15 100
3 2
5 4
12 11
14 13
22 21
30 29
36 35
44 43
61 60
63 62
76 75
91 90
98 97
99 98
100 99
101.01010101
1 1
100 10
10.00000000
1 1
100 3
33.33333333
1 100
100 3
3333.33333333
1 100
100 1
10000.00000000
7 8
9 8
5 1
3 1
6 2
7 3
2 1
3 1
9.00000000
5 8
9 8
3 1
2 1
4 2
13 5
9.00000000
2 1
1 2
2 10
0.20000000
2 1
99 100
95 95
0.99000000
1 5
10 1
50.00000000
5 10
9 1
10 1
11 1
12 1
13 1
90.00000000
1 100
3 1
300.00000000
from collections import defaultdict, deque, Counter
from sys import stdin, stdout
from heapq import heappush, heappop
import math
import io
import os
import math
# import bisect

from bisect import bisect_left as lower_bound
from bisect import bisect_right as upper_bound
 
#?############################################################


def isPrime(x):
    for i in range(2, x):
        if i*i > x:
            break
        if (x % i == 0):
            return False
    return True

#?############################################################


def ncr(n, r, p):
    temp = (n*n)
    # temp =temp//2
    temp %= m
    return temp

#?############################################################


def primeFactors(n):
    l = []
    while n % 2 == 0:
        l.append(2)
        n = n / 2
    for i in range(3, int(math.sqrt(n))+1, 2):
        while n % i == 0:
            l.append(int(i))
            n = n / i
    if n > 2:
        l.append(n)
    return list(set(l))


#?############################################################

def power(x, y, p):
    res = 1
    x = x % p
    if (x == 0):
        return 0
    while (y > 0):
        if ((y & 1) == 1):
            res = (res * x) % p
        y = y >> 1
        x = (x * x) % p
    return res

#?############################################################


def sieve(n):
    prime = [True for i in range(n+1)]
    p = 2
    while (p * p <= n):
        if (prime[p] == True):
            for i in range(p * p, n+1, p):
                prime[i] = False
        p += 1
    return prime


#?############################################################

def digits(n):
    c = 0
    while (n > 0):
        n //= 10
        c += 1
    return c

#?############################################################


def ceil(n, x):
    if (n % x == 0):
        return n//x
    return n//x+1

#?############################################################


def mapin():
    return [int(x) for x in input().split()]


def sapin():
    return [int(x) for x in input()]

#?############################################################
class SegmentTree:
    def __init__(self, data, default=0, func=min):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()
 
        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])
 
    def __delitem__(self, idx):
        self[idx] = self._default
 
    def __getitem__(self, idx):
        return self.data[idx + self._size]
 
    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1
 
    def __len__(self):
        return self._len
 
    def query(self, start, stop):
        """func of data[start, stop)"""
        start += self._size
        stop += self._size
 
        res_left = res_right = self._default
        while start < stop:
            if start & 1:
                res_left = self._func(res_left, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res_right = self._func(self.data[stop], res_right)
            start >>= 1
            stop >>= 1
 
        return self._func(res_left, res_right)
 
    def __repr__(self):
        return "SegmentTree({0})".format(self.data)
store = defaultdict(lambda:[])
def ff(left, right, element):
    a = lower_bound(store[element], left)
    b = upper_bound(store[element], right)
    return b - a
 
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
t = 1
for _ in range(t):
    n, m = mapin()
    temp = []
    for i in range(n):
        a, b = [float(x) for x in input().split()]
        temp.append(a/b)
    temp.sort()
    print(m*temp[0])