Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.

Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.  Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs b_{i} manapoints and changes the preparation time of each potion to a_{i} instead of x.  Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs d_{i} manapoints and instantly create c_{i} potions. 

Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.

Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.


-----Input-----

The first line of the input contains three integers n, m, k (1 ≤ n ≤ 2·10^9, 1 ≤ m, k ≤ 2·10^5) — the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.

The second line of the input contains two integers x and s (2 ≤ x ≤ 2·10^9, 1 ≤ s ≤ 2·10^9) — the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.

The third line contains m integers a_{i} (1 ≤ a_{i} < x) — the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.

The fourth line contains m integers b_{i} (1 ≤ b_{i} ≤ 2·10^9) — the number of manapoints to use the i-th spell of the first type.

There are k integers c_{i} (1 ≤ c_{i} ≤ n) in the fifth line — the number of potions that will be immediately created if the i-th spell of the second type is used. It's guaranteed that c_{i} are not decreasing, i.e. c_{i} ≤ c_{j} if i < j.

The sixth line contains k integers d_{i} (1 ≤ d_{i} ≤ 2·10^9) — the number of manapoints required to use the i-th spell of the second type. It's guaranteed that d_{i} are not decreasing, i.e. d_{i} ≤ d_{j} if i < j.


-----Output-----

Print one integer — the minimum time one has to spent in order to prepare n potions.


-----Examples-----
Input
20 3 2
10 99
2 4 3
20 10 40
4 15
10 80

Output
20

Input
20 3 2
10 99
2 4 3
200 100 400
4 15
100 800

Output
200



-----Note-----

In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).

In the second sample, Anton can't use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20·10 = 200.

Difficulty: interview

Starter code:

Solutions:
n, m, k = list(map(int, input().split()))
x, s = list(map(int, input().split()))
t = list(map(int, input().split()))
pr = list(map(int, input().split()))
t2 = list(map(int, input().split()))
pr2 = list(map(int, input().split()))
mass1 = []
minans = 10**20
for i in range(m):
    mass1.append((pr[i], t[i]))
mass1.sort()
mass1 = [(0, x)] + mass1
pr2 = [0] + pr2
t2 = [0] + t2
uk1 = len(mass1) - 1
uk2 = 0
maxw = 0
for uk1 in range(len(mass1) - 1, -1, -1):
    if (s < mass1[uk1][0]):
        continue
    while (uk2 < len(pr2) and mass1[uk1][0] + pr2[uk2] <= s):
        maxw = max(maxw, t2[uk2])
        uk2 += 1
    uk2 -= 1
    minans = min(minans, (n - maxw) * mass1[uk1][1])
print(minans)


def main():
    read = lambda: list(map(int, input().split()))
    n, m, k = read()
    x, s = read()
    a = list(read())
    b = list(read())
    c = list(read())
    d = list(read())
    ans = n * x
    if min(b) <= s:
        Min2 = min(a[i] for i in range(m) if b[i] <= s)
        ans = min(ans, n * Min2)
    b = sorted([(b[i], i) for i in range(m)])
    j = 0
    Min = x
    for i in range(k - 1, -1, -1):
        while j < m and b[j][0] + d[i] <= s:
            Min = min(Min, a[b[j][1]])
            j += 1
        if d[i] > s: continue
        cur = (n - c[i]) * Min
        ans = min(ans, cur)
    print(ans)
main()


import bisect

n, m, k = map(int, input().split())
x, s = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
d = list(map(int, input().split()))

z1 = list(zip(a, b))
z2 = list(zip(c, d))

result = n * x

for ai, bi in z1:
    if bi > s:
        continue

    current = ai * n
    if current < result:
        result = current

    rest = s - bi
    idx = bisect.bisect_right(d, rest)
    if idx == 0:
        continue
    current = ai * (n - z2[idx-1][0])
    if current < result:
        result = current

for ci, di in z2:
    if di > s:
        continue
    current = x * (n - ci)
    if current < result:
        result = current

print(result)

n, m, k = list(map(int, input().split()))
x, s = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
d = list(map(int, input().split()))
a.append(x)
b.append(0)
ans = x * n
for i in range(m + 1):
	if b[i] <= s:
		l = -1
		r = k
		while l < r - 1:
			y = l + (r - l) // 2
			if d[y] <= s - b[i]:
				l = y
			else:
				r = y
		ans1 = 0
		if l > -1:
			ans1 = a[i] * max(0, n - c[l])
		else:
			ans1 = a[i] * n
		if ans1 < ans:
			ans = ans1
print(ans)


from bisect import bisect_right

n, m, k = [int(x) for x in input().split()]
x,s = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
c = [int(x) for x in input().split()]
d = [int(x) for x in input().split()]
ans = n * x
for i in range(m):
    if b[i] <= s:
        cur_s = s - b[i]
        j = bisect_right(d, cur_s) - 1
        if j != -1:
            if (n-c[j])*a[i] < ans:
                ans = (n-c[j])*a[i]
        else:
            if (n)*a[i] < ans:
                ans = (n)*a[i]

for i in range(k):
    if d[i] <= s:
        if (n - c[i]) * x < ans:
            ans = (n - c[i]) * x
print(ans)


def main():
    from bisect import bisect
    n, m, k = list(map(int, input().split()))
    t, s = list(map(int, input().split()))  # time per stuff,mana
    aa = list(map(int, input().split()))  # x->t[i] for stuff
    aa.append(t)
    bb = list(map(int, input().split()))  # price of t[i]
    bb.append(0)
    cc = [0, *list(map(int, input().split())), 0]  # num of instant
    dd = [0, *list(map(int, input().split())), s + 1]  # price of instant
    res = []
    for t, b in zip(aa, bb):
        b = s - b
        if b >= 0:
            i = bisect(dd, b)
            if b < dd[i]:
                i -= 1
            x = n - cc[i]
            if x <= 0:
                res = [0]
                break
            res.append(x * t)
    print(min(res))


def __starting_point():
    main()

__starting_point()

n, m, k = map(int, input().split())
x, s = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
d = list(map(int, input().split()))

ans = n * x
for i in range(m):
    l = 0
    r = k
    while (r - l > 1):
        mid = l + (r - l) // 2
        if (d[mid] <= s - b[i]):
            l = mid
        else:
            r = mid
    if (d[l] <= s - b[i]):
        t = a[i] * (n - c[l])
        ans = min(ans, t)
for i in range(k):
    if (d[i] <= s):
        ans = min(ans, x * (n - c[i]))
for i in range(m):
    if (b[i] <= s):
        ans = min(ans, a[i] * n)
print(ans)

n, m, k = map(int, input().split())
x, s = map(int, input().split())
res = n * x
ft = [[0] * 2 for i in range(m)]
st = [[0] * 2 for i in range(k)]
tmparr = list(map(int, input().split()))
for i in range(m):
    ft[i][0] = tmparr[i]
tmparr = list(map(int, input().split()))
for i in range(m):
    ft[i][1] = tmparr[i]
tmparr = list(map(int, input().split()))
for i in range(k):
    st[i][0] = tmparr[i]
tmparr = list(map(int, input().split()))
for i in range(k):
    st[i][1] = tmparr[i]
for i in range(m):
    nows = s - ft[i][1]
    if (nows < 0):
        continue
    nowr = n * ft[i][0]
    if (nows >= st[0][1]):
        l = 0
        r = k
        while r - l > 1:
            m = (l + r) // 2
            if (st[m][1] <= nows):
                l = m
            else:
                r = m
        nowr -= ft[i][0] * st[l][0]
    res = min(res, nowr)
for i in range(k):
    if (st[i][1] <= s):
        res = min(res, x * (n - st[i][0]))
print(res)

#!/usr/bin/env python3

from sys import stdin
from bisect import bisect_right


def main():
    n, m, k = stdin_get_ints_from_line() # amount to brew, first cast count, second cask count 2*10^9, 2*10^5, 2*10^5
    x, s = stdin_get_ints_from_line() # time to brew, mana amount

    a = stdin_get_ints_list_from_line() # time to brew with ai first cast 2*10^9
    b = stdin_get_ints_list_from_line() # cost of first cast 2*10^9
    c = stdin_get_ints_list_from_line() # amount to brew instantly 2*10^9
    d = stdin_get_ints_list_from_line() # cost of second cast 2*10^9

    result = n * x

    key = bisect_right(d, s)

    if key != 0:
        spell2_only_result = (n - c[key-1]) * x
        if spell2_only_result < result:
            result = spell2_only_result

    for key, val in enumerate(b):
        if val <= s:
            if a[key] < x:
                cost_left = s - val
                amount_second = 0

                key2 = bisect_right(d, cost_left)

                if key2 != 0:
                    amount_second = c[key2-1]

                r = (n-amount_second) * a[key]

                if r < result:
                    result = r
                if result <= 0:
                    break

    print(result) if result > 0 else print(0)


def stdin_get_ints_from_line():
    return (int(x) for x in stdin.readline().strip().split(' '))


def stdin_get_ints_list_from_line():
    return list(int(x) for x in stdin.readline().strip().split(' '))


def stdin_get_string_from_line():
    return stdin.readline().strip()


def __starting_point():
    main()

__starting_point()

import bisect

n, m, k = map(int, input().split(' '))
x, s = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
b = list(map(int, input().split(' ')))
c = list(map(int, input().split(' ')))
d = list(map(int, input().split(' ')))
a.append(x)
b.append(0)
ans = n * x
for i in range(m+1):
    if b[i] <= s:
        j = bisect.bisect_right(d, s - b[i])
        if j > 0:
            j -= 1
            ans = min(ans, (n-c[j])*a[i])
        else:
            ans = min(ans, n*a[i])
print(ans)

n,m,k = [int(i) for i in input().split()]
x,s = [int(i) for i in input().split()]
a_t = [int(i) for i in input().split()]
a_m = [int(i) for i in input().split()]
b_p = [int(i) for i in input().split()]
b_m = [int(i) for i in input().split()]

min_time = n * x

a_t.append(x)
a_m.append(0)

for i in range(m+1):
    re_mana = s - a_m[i]
    if re_mana < 0:
        continue
    inf = -1
    sup = k
    while inf<sup-1:
        #print(inf,sup)
        mid = (inf+sup)//2
        if b_m[mid] <= re_mana:
            inf = mid
        else:
            sup = mid 
    if inf<=-1:
        min_time = min(min_time,n*a_t[i])
    else:
        min_time = min(min_time,max(0,n-b_p[inf])*a_t[i])



print(min_time)


n,m,k = [int(i) for i in input().split()]
x,s = [int(i) for i in input().split()]
a_t = [int(i) for i in input().split()]
a_m = [int(i) for i in input().split()]
b_p = [int(i) for i in input().split()]
b_m = [int(i) for i in input().split()]

min_time = n * x

for i in range(m):
    re_mana = s - a_m[i]
    if re_mana < 0:
        continue
    inf = -1
    sup = k
    while inf<sup-1:
        #print(inf,sup)
        mid = (inf+sup)//2
        if b_m[mid] <= re_mana:
            inf = mid
        else:
            sup = mid
    if inf==-1:
        min_time = min(min_time,n*a_t[i])
    else:
        min_time = min(min_time,max(0,n-b_p[inf])*a_t[i])

for i in range(k):
    if s>=b_m[i]:
        min_time = min(min_time,max(0,(n-b_p[i]))*x)
print(min_time)


import math
n, m, k = list(map(int,input().split()))
x, s = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
c = list(map(int,input().split()))
d = list(map(int,input().split()))
a.insert(0,x)
b.insert(0,0)
c.insert(0,0)
d.insert(0,0)
ans = 1<<100
for it in range(m+1):
    mana = s-b[it]
    if mana<0: continue
    lo, hi = 0, k
    while lo!=hi:
        mid = math.ceil((lo+hi)/2)
        if d[mid]<=mana: lo = mid
        else: hi = mid-1
    ans = min(ans,(n-c[lo])*a[it])
print(ans)


from sys import stdin, stdout
n, m, k = list(map(int,stdin.readline().split()))
x, s = list(map(int,stdin.readline().split()))
a = list(map(int,stdin.readline().split()))
b = list(map(int,stdin.readline().split()))
c = list(map(int,stdin.readline().split()))
d = list(map(int,stdin.readline().split()))
a.insert(0,x)
b.insert(0,0)
c.insert(0,0)
d.insert(0,0)
ans = 1<<100
for it in range(m+1):
    mana = s-b[it]
    if mana<0: continue
    lo, hi = 0, k
    while lo!=hi:
        mid = (lo+hi+1)//2
        if d[mid]<=mana: lo = mid
        else: hi = mid-1
    ans = min(ans,(n-c[lo])*a[it])
stdout.write(str(ans)+'\n')


import bisect
(n,m,k), (x,s), a, b, c, d = (list(map(int, input().split())) for _ in range(6))
a, b = list(a) + [x], list(b) + [0]
c, d = list(map(list, (c, d)))

ans = n * x
for i in range(m + 1):
    if b[i] <= s:
        j = bisect.bisect_right(d, s - b[i])
        if j > 0:
            j -= 1
            ans = min(ans, (n - c[j]) * a[i])
        else:
            ans = min(ans, n * a[i])
print(ans)


import bisect 

def anton_and_magic_potions():

	no_potions, no_fst_spell, no_snd_spell = [int(x) for x in input().split(' ')]
	initial_time, mana = [int(x) for x in input().split(' ')]
	first_spell = [int(x) for x in input().split(' ')]
	mana_first_spell = [int(x) for x in input().split(' ')]
	potions_second_spell = [int(x) for x in input().split(' ')]
	mana_second_spell = [int(x) for x in input().split(' ')]

	first_spell.append(initial_time)
	mana_first_spell.append(0)

	total_time = no_potions * initial_time

	for i in  range(no_fst_spell + 1):

		if mana_first_spell[i] > mana:
			continue

		pos2 = bisect.bisect_right(mana_second_spell, mana -mana_first_spell[i]) - 1
		if pos2 >=0:
			no_potions2 = no_potions - potions_second_spell[pos2]
			res = no_potions2 * first_spell[i]
		else:
			res = no_potions * first_spell[i]
		total_time = min(total_time, res)


	print(total_time)

anton_and_magic_potions()

n,m,k = list(map(int,input().split()))
x,s = list(map(int,input().split()))
k += 1 
m += 1
a = [x] + [int(x) for x in input().split()]
b = [0] + [int(x) for x in input().split()]
c = [0] + [int(x) for x in input().split()]
d = [0] + [int(x) for x in input().split()]
fir = []
for i in range(m): 
	fir.append([a[i],b[i]])
fir.sort(key = lambda x : x[1])
ans = n * x
for i in range(m):
	left = s - fir[i][1]
	if (left < 0) : break
	while(d[k-1] > left) : k -= 1
	now = (n - c[k-1]) * fir[i][0]
	ans = min(ans,now)
print(ans)



n,m,k = list(map(int,input().split()))
x,s = list(map(int,input().split()))
a_time = list(map(int,input().split()))
a_cost = list(map(int,input().split()))
b_num = list(map(int,input().split()))
b_cost = list(map(int,input().split()))

def binary_search(manapoints):
    nonlocal  k,b_cost
    l = 0;  r = k-1;  pos = -1
    while (l <= r):
        mid = int((l+r)/2)
        if (b_cost[mid] <= manapoints):
            l = mid+1;  pos = mid;
        else :
            r = mid-1
    return pos
res = n*x
pos = binary_search(s)
if (pos >= 0):  res = min(res,(n-b_num[pos])*x);
for i in range(m):
    if (a_cost[i] > s): continue;
    rest = s-a_cost[i]
    pos = binary_search(rest)
    if (pos >= 0):  res = min(res,(n-b_num[pos])*a_time[i])
    else : res = min(res,n*a_time[i])
print(res)

n,m,k = map(int, input().split())
x,s = map(int, input().split())

a = [x] + list(map(int, input().split()))
b = [0] + list(map(int, input().split()))
c = [0] + list(map(int, input().split()))
d = [0] + list(map(int, input().split()))

ab = list(zip(a,b))
ab.sort(key=lambda x:-x[1])

ans = x*n
ind = 0

for ai,bi in ab:
    while ind<k+1 and d[ind]<=(s-bi): ind+=1
    if ind==0: continue
    tmp = (n-c[ind-1])*ai
    ans = min(ans, tmp)

print(ans)

n,m,k = map(int, input().split())
x,s = map(int, input().split())

a = [x] + list(map(int, input().split()))
b = [0] + list(map(int, input().split()))
c = [0] + list(map(int, input().split()))
d = [0] + list(map(int, input().split()))

ab = list(zip(a,b))
ab.sort(key=lambda x:-x[1])

ans = x*n
ind = 0

for ai,bi in ab:
    while ind<k+1 and d[ind]<=(s-bi): ind+=1
    if ind==0: continue
    ans = min(ans, (n-c[ind-1])*ai)

print(ans)

n, m, k = map(int, input().split())
x, s = map(int, input().split())
A = [x] + list(map(int, input().split()))
B = [0] + list(map(int, input().split()))
C = [0] + list(map(int, input().split()))
D = [0] + list(map(int, input().split()))
QW = list(zip(A, B))
QW.sort(key = lambda x : x[1])
A = [s[0] for s in QW]
B = [s[1] for s in QW]

Res = x * n

for i in range(1, k + 1):
    C[i] = max(C[i], C[i - 1])
l = k
e = 10**19

for i in range(m + 1):
    e = min(e, A[i])
    while l >= 0 and B[i] + D[l] > s:
        l -= 1
    if l >= 0:
        Res = min(Res, max(n - C[l], 0) * A[i])
    


print(Res)

n,m,k = (int(x) for x in input().split())
orig,s = (int(x) for x in input().split())
time1 = [orig] + [int(x) for x in input().split()]
cost1 = [0] + [int(x) for x in input().split()]
make2 = [0] + [int(x) for x in input().split()]
cost2 = [0] + [int(x) for x in input().split()]

ordcost1 = [ (x,i) for i,x in enumerate(cost1) ]
ordcost1.sort()
count = k
best = orig*n

for i in range(m+1):
	cost,ind = ordcost1[i]
	while count > -1 and cost2[count] + cost > s:
		count -= 1
	if count > -1 and time1[ind] * (n - make2[count]) < best:
		best = time1[ind] * (n - make2[count])

print(best)

class First:
    def __init__(self, seconds, cost):
        self.seconds = seconds
        self.cost = cost
class Second:
    def __init__(self, numCreated, cost):
        self.numCreated = numCreated
        self.cost = cost

def solve():
    potionCount, firstCount, secondCount = map(int, input().split())
    secondsOne, manaPoints = map(int, input().split())
    first = list()
    a, b = list(map(int, input().split())), list(map(int, input().split()))
    for i in range(firstCount):
        first.append(First(a[i], b[i]))
    first.append(First(secondsOne, 0))
    second = [Second(0, 0)]
    a, b = list(map(int, input().split())), list(map(int, input().split()))
    for i in range(secondCount):
        second.append(Second(a[i], b[i]))
    res = int(1e20)
    for f in first:
        low = 0
        high = len(second) - 1
        while low < high:
            mid = (low + high + 1) // 2
            if f.cost + second[mid].cost > manaPoints:
                high = mid - 1
            else:
                low = mid
        if f.cost + second[low].cost <= manaPoints:
            moar = max(0, potionCount - second[low].numCreated)
            time = moar * f.seconds
            res = min(res, time)
    print(res)
solve()

class First:
    def __init__(self, seconds, cost):
        self.seconds = seconds
        self.cost = cost
class Second:
    def __init__(self, numCreated, cost):
        self.numCreated = numCreated
        self.cost = cost

def solve():
    potionCount, firstCount, secondCount = map(int, input().split())
    secondsOne, manaPoints = map(int, input().split())
    first = list()
    a, b = list(map(int, input().split())), list(map(int, input().split()))
    for i in range(firstCount):
        first.append(First(a[i], b[i]))
    first.append(First(secondsOne, 0))
    second = [Second(0, 0)]
    a, b = list(map(int, input().split())), list(map(int, input().split()))
    for i in range(secondCount):
        second.append(Second(a[i], b[i]))
    res = int(1e20)
    for f in first:
        low = 0
        high = len(second) - 1
        while low < high:
            mid = (low + high + 1) // 2
            if f.cost + second[mid].cost > manaPoints:
                high = mid - 1
            else:
                low = mid
        if f.cost + second[low].cost <= manaPoints:
            moar = max(0, potionCount - second[low].numCreated)
            time = moar * f.seconds
            res = min(res, time)
    print(res)
solve()