inputs: Solve in Python:
There are $n$ warriors in a row. The power of the $i$-th warrior is $a_i$. All powers are pairwise distinct.

You have two types of spells which you may cast:   Fireball: you spend $x$ mana and destroy exactly $k$ consecutive warriors;  Berserk: you spend $y$ mana, choose two consecutive warriors, and the warrior with greater power destroys the warrior with smaller power. 

For example, let the powers of warriors be $[2, 3, 7, 8, 11, 5, 4]$, and $k = 3$. If you cast Berserk on warriors with powers $8$ and $11$, the resulting sequence of powers becomes $[2, 3, 7, 11, 5, 4]$. Then, for example, if you cast Fireball on consecutive warriors with powers $[7, 11, 5]$, the resulting sequence of powers becomes $[2, 3, 4]$.

You want to turn the current sequence of warriors powers $a_1, a_2, \dots, a_n$ into $b_1, b_2, \dots, b_m$. Calculate the minimum amount of mana you need to spend on it.


-----Input-----

The first line contains two integers $n$ and $m$ ($1 \le n, m \le 2 \cdot 10^5$) — the length of sequence $a$ and the length of sequence $b$ respectively.

The second line contains three integers $x, k, y$ ($1 \le x, y, \le 10^9; 1 \le k \le n$) — the cost of fireball, the range of fireball and the cost of berserk respectively.

The third line contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le n$). It is guaranteed that all integers $a_i$ are pairwise distinct.

The fourth line contains $m$ integers $b_1, b_2, \dots, b_m$ ($1 \le b_i \le n$). It is guaranteed that all integers $b_i$ are pairwise distinct.


-----Output-----

Print the minimum amount of mana for turning the sequnce $a_1, a_2, \dots, a_n$ into $b_1, b_2, \dots, b_m$, or $-1$ if it is impossible.


-----Examples-----
Input
5 2
5 2 3
3 1 4 5 2
3 5

Output
8

Input
4 4
5 1 4
4 3 1 2
2 4 3 1

Output
-1

Input
4 4
2 1 11
1 3 2 4
1 3 2 4

Output
0
targets: n, m = list(map(int, input().split()))
x, k, y= list(map(int, input().split()))
start_ls = list(map(int, input().split()))
end_ls = list(map(int, input().split()))

len_start_ls = len(start_ls)
len_end_ls = len(end_ls)
mark = []

end_p = 0
curr = None
for item in start_ls:
    if end_p < (len_end_ls):
        if item == end_ls[end_p]:
            end_p += 1
            mark.append(0)
            curr = item
        else:
            if curr is not None:
                if item > curr:
                    mark.append(1)
                else:
                    mark.append(2)
            else:
                mark.append(1)
    else: 
        if curr is not None:
            if item > curr:
                mark.append(1)
            else:
                mark.append(2)
        else:
            mark.append(1)
        
if end_p < (len_end_ls):
    print(-1)
else:
    end_p = 0
    curr = None
    end_ls = end_ls[::-1]
    mark = mark[::-1]
    for idx, item in enumerate(start_ls[::-1]):
        if end_p < (len_end_ls):
            if item == end_ls[end_p]:
                end_p += 1
                curr = item
            else:
                if curr is not None:
                    if item < curr:
                        mark[idx] = 2
        else: 
            if curr is not None:
                if item < curr:
                    mark[idx] = 2
    mark = mark[::-1]
    
    if y*k >= x:
        smite = True
    else:
        smite = False

    segments = []
    segment = [0,True]
    for idx, item in enumerate(mark):
        if item != 0:
            segment[0] += 1
            if item == 1:
                segment[1] = False
        elif item == 0:
            if segment[0] != 0:
                segments.append(segment)
            segment = [0,True]

    if segment[0] != 0:
        segments.append(segment)
    
    poss = True
    res = 0
    for segment in segments:
        if segment[0] < k and not segment[1]:
            poss = False
            break
        elif segment[0] < k and segment[1]:
      ...