Problem: Little W and Little P decided to send letters to each other regarding the most important events during a day. There are n events during a day: at time moment t_i something happens to the person p_i (p_i is either W or P, denoting Little W and Little P, respectively), so he needs to immediately send a letter to the other person. They can send a letter using one of the two ways:

  * Ask Friendly O to deliver the letter directly. Friendly O takes d acorns for each letter.
  * Leave the letter at Wise R's den. Wise R values free space, so he takes c ⋅ T acorns for storing a letter for a time segment of length T. The recipient can take a letter from Wise R either when he leaves his own letter at Wise R's den, or at time moment t_{n + 1}, when everybody comes to Wise R for a tea. It is not possible to take a letter from Wise R's den at other time moments. The friends can store as many letters at Wise R's den as they want, paying for each one separately. 



Help the friends determine the minimum possible total cost of sending all letters.

Input

The first line contains three integers n, c, d (1 ≤ n ≤ 10^5, 1 ≤ c ≤ 10^2, 1 ≤ d ≤ 10^8) — the number of letters, the cost of storing a letter for one time unit at Wise R's den and the cost of delivering a letter via Friendly O.

The next n describe the events. The i-th of them contains an integer t_i and a character p_i (0 ≤ t_i ≤ 10^6, p_i is either W or P) — the time the i-th event happens and the person the event happens to.

The last line contains a single integer t_{n + 1} (0 ≤ t_{n+1} ≤ 10^6) — the time when everybody comes to Wise R for a tea and takes all remaining letters. 

It is guaranteed that t_i < t_{i + 1} for all i from 1 to n.

Output

Print a single integer — the minimum possible cost of delivery of all letters.

Examples

Input


5 1 4
0 P
1 W
3 P
5 P
8 P
10


Output


16


Input


10 10 94
17 W
20 W
28 W
48 W
51 P
52 W
56 W
62 P
75 P
78 P
87


Output


916

Note

One of optimal solutions in the first example:

  * At time moment 0 Little P leaves the letter at Wise R's den.
  * At time moment 1 Little W leaves his letter at Wise R's den and takes Little P's letter. This letter is at the den from time moment 0 to time moment 1, it costs 1 acorn.
  * At time moment 3 Little P sends his letter via Friendly O, it costs 4 acorns.
  * At time moment 5 Little P leaves his letter at the den, receiving Little W's letter which storage costs 4 acorns.
  * At time moment 8 Little P leaves one more letter at the den.
  * At time moment 10 Little W comes to the den for a tea and receives the two letters, paying 5 and 2 acorns.



The total cost of delivery is thus 1 + 4 + 4 + 5 + 2 = 16 acorns.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
struct line {
  long long k;
  long long b;
  line() : k(0), b(0) {}
  line(long long k, long long b) : k(k), b(b) {}
  long long get(long long x) const { return k * x + b; }
};
const int max_x = 100111;
const long long inf = 1000111222000111222LL;
struct tree {
  line a[4 * max_x];
  tree() {
    for (int i = 0; i < 4 * max_x; ++i) {
      a[i] = {0, inf};
    }
  }
  void update(int v, int l, int r, line &ln) {
    int mid = (l + r) / 2;
    if (a[v].get(mid) > ln.get(mid)) {
      swap(a[v], ln);
    }
    if (l == r) {
      return;
    }
    if (a[v].get(l) > ln.get(l)) {
      update(2 * v, l, mid, ln);
    }
    if (a[v].get(r) > ln.get(r)) {
      update(2 * v + 1, mid + 1, r, ln);
    }
  }
  long long get_min(int v, int l, int r, int x) {
    long long res = a[v].get(x);
    if (l == r) {
      return res;
    }
    int mid = (l + r) / 2;
    if (x <= mid) {
      res = min(res, get_min(2 * v, l, mid, x));
    } else {
      res = min(res, get_min(2 * v + 1, mid + 1, r, x));
    }
    return res;
  }
};
struct line_container {
  tree t;
  void add(line l) { t.update(1, 0, max_x - 1, l); }
  long long get_min(int x) { return t.get_min(1, 0, max_x - 1, x); }
};
const int max_n = 100111;
int n, c, d;
int t[max_n], tp[max_n], p[max_n];
long long cnt[2][max_n], sum[2][max_n], dp[max_n], val[max_n], val2[max_n],
    mn[2];
line_container l[2];
void get_all_p() {
  const int mxt = d / c;
  int pos = n;
  for (int i = n; i >= 0; --i) {
    while (pos > 0 && t[i] - t[pos - 1] <= mxt) {
      --pos;
    }
    p[i] = pos;
  }
}
void upd(int j) {
  val[j] = dp[j] + 1LL * c * t[j] + 1LL * d * cnt[tp[j]][j - 1];
  val[j] += 1LL * d * cnt[tp[j] ^ 1][p[j] - 1];
  val[j] += 1LL * c *
            (1LL * t[j] * (cnt[tp[j] ^ 1][j - 1] - cnt[tp[j] ^ 1][p[j] - 1]) -
             (sum[tp[j] ^ 1][j - 1] - sum[tp[j] ^ 1][p[j] - 1]));
  val2[j] = dp[j] + 1LL * c * t[j] + 1LL * d * cnt[tp[j]][j - 1];
  val2[j] +=
      1LL * c * (1LL * t[j] * cnt[tp[j] ^ 1][j - 1] - sum[tp[j] ^ 1][j - 1]);
  l[tp[j]].add({-1LL * c * t[j], val2[j]});
}
int main() {
  scanf("%d%d%d", &n, &c, &d);
  for (int i = 1; i <= n; ++i) {
    char ctp;
    scanf("%d %c", &t[i], &ctp);
    tp[i] = (ctp == 'W');
  }
  t[0] = -1000111222;
  ++n;
  scanf("%d", &t[n]);
  ++n;
  t[n] = t[n - 1];
  tp[n] = 1;
  for (int i = 1; i <= n; ++i) {
    cnt[tp[i]][i] = 1;
    sum[tp[i]][i] = t[i];
    sum[0][i] += sum[0][i - 1];
    cnt[0][i] += cnt[0][i - 1];
    sum[1][i] += sum[1][i - 1];
    cnt[1][i] += cnt[1][i - 1];
  }
  get_all_p();
  mn[0] = mn[1] = inf;
  upd(n);
  upd(n - 1);
  int pos = n;
  for (int i = n - 2; i >= 1; --i) {
    long long y =
        -1LL * c * t[i] - 1LL * d * cnt[tp[i] ^ 1][i] - 1LL * d * cnt[tp[i]][i];
    long long y2 = y + 1LL * d * cnt[tp[i]][i] + 1LL * c * sum[tp[i]][i];
    while (p[pos] >= i + 1) {
      mn[tp[pos]] = min(mn[tp[pos]], val[pos]);
      --pos;
    }
    dp[i] = mn[tp[i] ^ 1] + y;
    long long x = l[tp[i] ^ 1].get_min(cnt[tp[i]][i]);
    dp[i] = min(dp[i], x + y2);
    upd(i);
  }
  long long ans = inf;
  for (int i = 1; i <= n; ++i) {
    ans = min(ans, 1LL * (i - 1) * d + dp[i]);
  }
  printf("%I64d\n", ans);
  return 0;
}