847_K. Travel Cards
In the evening Polycarp decided to analyze his today's travel expenses on public transport.

The bus system in the capital of Berland is arranged in such a way that each bus runs along the route between two stops. Each bus has no intermediate stops. So each of the buses continuously runs along the route from one stop to the other and back. There is at most one bus running between a pair of stops.

Polycarp made n trips on buses. About each trip the stop where he started the trip and the the stop where he finished are known. The trips follow in the chronological order in Polycarp's notes.

It is known that one trip on any bus costs a burles. In case when passenger makes a transshipment the cost of trip decreases to b burles (b < a). A passenger makes a transshipment if the stop on which he boards the bus coincides with the stop where he left the previous bus. Obviously, the first trip can not be made with transshipment.

For example, if Polycarp made three consecutive trips: "BerBank" <image> "University", "University" <image> "BerMall", "University" <image> "BerBank", then he payed a + b + a = 2a + b burles. From the BerBank he arrived to the University, where he made transshipment to the other bus and departed to the BerMall. Then he walked to the University and returned to the BerBank by bus.

Also Polycarp can buy no more than k travel cards. Each travel card costs f burles. The travel card for a single bus route makes free of charge any trip by this route (in both directions). Once purchased, a travel card can be used any number of times in any direction.

What is the smallest amount of money Polycarp could have spent today if he can buy no more than k travel cards?

Input

The first line contains five integers n, a, b, k, f (1 ≤ n ≤ 300, 1 ≤ b < a ≤ 100, 0 ≤ k ≤ 300, 1 ≤ f ≤ 1000) where:

  * n — the number of Polycarp trips, 
  * a — the cost of a regualar single trip, 
  * b — the cost of a trip after a transshipment, 
  * k — the maximum number of travel cards Polycarp can buy, 
  * f — the cost of a single travel card. 



The following n lines describe the trips in the chronological order. Each line contains exactly two different words separated by a single space — the name of the start stop and the name of the finish stop of the trip. All names consist of uppercase and lowercase English letters and have lengths between 1 to 20 letters inclusive. Uppercase and lowercase letters should be considered different.

Output

Print the smallest amount of money Polycarp could have spent today, if he can purchase no more than k travel cards.

Examples

Input

3 5 3 1 8
BerBank University
University BerMall
University BerBank


Output

11


Input

4 2 1 300 1000
a A
A aa
aa AA
AA a


Output

5

Note

In the first example Polycarp can buy travel card for the route "BerBank <image> University" and spend 8 burles. Note that his second trip "University" <image> "BerMall" was made after transshipment, so for this trip Polycarp payed 3 burles. So the minimum total sum equals to 8 + 3 = 11 burles.

In the second example it doesn't make sense to buy travel cards. Note that each of Polycarp trip (except the first) was made with transshipment. So the minimum total sum equals to 2 + 1 + 1 + 1 = 5 burles.
```python
import heapq
import sys

num_trips, a, b, k, f = sys.stdin.readline().strip().split(" ")
a, b, k, f = int(a), int(b), int(k), int(f)
#print(a, b, k, f)
trips = []
for line in sys.stdin:
  trips.append(line.strip().split(" "))
  
"""
a = 5
b = 3
k = 1
f = 8

trips = [["BerBank", "University"],
["University", "BerMall"],
["University", "BerBank"],
["University", "BerBank"]]

"""

my_dict = dict()
for i in range(0, len(trips)):
  trip = trips[i]
  cost = 0
  if(i - 1 >= 0 and trips[i - 1][1] == trip[0]):
    cost = b;
  else:
    cost = a
  if (str(sorted(trip)) in my_dict):
    my_dict[str(sorted(trip))] += cost
  else:
    my_dict[str(sorted(trip))] = cost
    
heap = [(-1 * my_dict[x], x) for x in my_dict]
heapq.heapify(heap)

#print(heap)
total = sum(int(my_dict[x]) for x in my_dict)
for i in range(0, k):
  if(len(heap) > 0):
    cur_max = int(heapq.heappop(heap)[0]) * -1
    if (cur_max > f):
      total = total - (cur_max - f)

print(total)
	   				 		   		 	 		 	 	     	
```