Arkady plays Gardenscapes a lot. Arkady wants to build two new fountains. There are n available fountains, for each fountain its beauty and cost are known. There are two types of money in the game: coins and diamonds, so each fountain cost can be either in coins or diamonds. No money changes between the types are allowed.

Help Arkady to find two fountains with maximum total beauty so that he can buy both at the same time.


-----Input-----

The first line contains three integers n, c and d (2 ≤ n ≤ 100 000, 0 ≤ c, d ≤ 100 000) — the number of fountains, the number of coins and diamonds Arkady has.

The next n lines describe fountains. Each of these lines contain two integers b_{i} and p_{i} (1 ≤ b_{i}, p_{i} ≤ 100 000) — the beauty and the cost of the i-th fountain, and then a letter "C" or "D", describing in which type of money is the cost of fountain i: in coins or in diamonds, respectively.


-----Output-----

Print the maximum total beauty of exactly two fountains Arkady can build. If he can't build two fountains, print 0.


-----Examples-----
Input
3 7 6
10 8 C
4 3 C
5 6 D

Output
9

Input
2 4 5
2 5 C
2 1 D

Output
0

Input
3 10 10
5 5 C
5 5 C
10 11 D

Output
10



-----Note-----

In the first example Arkady should build the second fountain with beauty 4, which costs 3 coins. The first fountain he can't build because he don't have enough coins. Also Arkady should build the third fountain with beauty 5 which costs 6 diamonds. Thus the total beauty of built fountains is 9.

In the second example there are two fountains, but Arkady can't build both of them, because he needs 5 coins for the first fountain, and Arkady has only 4 coins.

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

ns = {"__name__": "__main__"}
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = "import operator\nimport itertools\nimport bisect\n\ndef maxl(l, m, mx):\n    l.sort(key=operator.itemgetter(1))\n    \n    m1, m2 = 0, 0\n    pp = None\n    for b, p in l:\n        if p != pp:\n            if 2 * p > m:\n                break\n            if m1 and m2 and m1 + m2 > mx:\n                mx = m1 + m2\n            m1, m2 = b, 0\n            pp = p\n        else:\n            if b > m1:\n                m1, m2 = b, m1\n            elif b > m2:\n                m2 = b\n    if m1 and m2 and m1 + m2 > mx:\n         mx = m1 + m2\n         \n    lp = list(p for(b, p) in l)\n    lb = list(itertools.accumulate((b for (b, p) in l), max))\n    for i, ((b, p), mb) in enumerate(zip(l, lb)):\n        p1 = min(m - p, p - 1)\n        k = bisect.bisect_right(lp, p1, 0, i)\n        if k:\n            x = b + lb[k - 1]\n            if x > mx:\n                mx = x\n    return mx\n\n   \nfc = []\nfd = []\n\nn, c, d = list(map(int, input().split()))\nfor _ in range(n):\n    b, p, m = input().split()\n    b, p = int(b), int(p)\n    f, cd = (fc, c) if m == 'C' else (fd, d)\n    if p <= cd:\n        f.append((b, p))\n\nmx = 0\nif fc and fd:\n    bc, pc = max(fc, key=operator.itemgetter(0))\n    bd, pd = max(fd, key=operator.itemgetter(0))\n    mx = bc + bd\nmx = maxl(fc, c, mx)\nmx = maxl(fd, d, mx)\n\nprint(mx)\n"
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 13581