import random

n, p, s, c = map(int, input().split())

DIM = (s+1)*(c+1)

def teamA2index(a,b):
    return a*(c+1) + b

def index2teamA(ind):
    return divmod(ind, c+1)

M = [[] for _ in range(DIM)]

for sA in range(s+1):
    for cA in range(c+1):
        for ds in range(-1,2):
            for dc in range(-1,2):
                sA2 = sA + ds
                cA2 = cA + dc

                if not (0 <= sA2 <= s and 0 <= cA2 <= c): continue

                j = teamA2index(sA, cA)
                i = teamA2index(sA2, cA2)

                ways_s = [1, s-sA, sA][ds]
                ways_c = [1, c-cA, cA][dc]

                M[i] += [(j, ways_c*ways_s)]

MOD = 10**9+7
def BM(s):
    n = len(s)
    C = [0]*n; B = [0]*n
    C[0] = B[0] = 1

    b = C[0]; L = 0; m = 1
    for i in range(n):
        d = s[i]
        for j in range(1, L+1):
            d = (d + C[j] * s[i-j]) % MOD
        if d == 0:
            m+=1
            continue
        T = C[:]; coef = d * pow(b,-1,MOD) % MOD

        for j in range(m,n):
            C[j] = (C[j] - coef * B[j-m]) % MOD

        if 2 * L > i:
            m+=1
            continue

        L = i + 1 - L; B = T; b = d; m = 1

    del C[L+1:]
    del C[0]
    C = [(-x)%MOD for x in C]
    return C

def LinearRec(trans, k):
    if not trans: return [0]
    n = len(trans)
    r = [0]*(n+1)
    b = [0]*(n+1)
    r[0] = b[1] = 1

    def combine(a, b):
        res = [0]*(2*n+1)
        for i in range(n+1):
            for j in range(n+1):
                res[i+j] = (res[i+j] + a[i]*b[j]) % MOD
        for i in range(2*n,n,-1):
            for j in range(n):
                res[i-1-j] = (res[i-1-j] + res[i]*trans[j]) % MOD
        del res[n+1:]
        return res
    
    k+=1

    while k:
        if k%2: r = combine(r,  b)
        b = combine(b, b)
        k//=2

    return r

def power(M, powk, v):
    n = len(M)
    needed = 2*n
    first = [None]*needed
    first[0] = v

    for i in range(1, needed):
        first[i] = [0]*n
        for j in range(n):
            for k, coeff in M[j]:
                first[i][k] = (first[i][k] + coeff * first[i-1][j]) % MOD

    w = [random.randint(0,MOD-1) for _ in range(n)]
    s = [sum(w[j]*first[i][j]%MOD for j in range(n))%MOD for i in range(needed)]

    trans = BM(s)

    rec = len(trans)

    c = LinearRec(trans, powk)

    ans = [0]*n

    for i in range(n):
        for j in range(rec):
            ans[i] = (ans[i] + c[j+1] * first[j][i]) % MOD

    return ans

ways = [0]*((s+1)*(c+1))
ways[-1] = 1

last = 1

probs = [input().split() for _ in range(p)] + [(n, 'A', s, c, s+c)]
for time, group, needS, needC, needB in probs:
    time, needS, needC, needB = map(int, [time, needS, needC, needB])

    ways = power(M, time - last, ways)
    last = time

    if group == 'A':
        for sA in range(s+1):
            for cA in range(c+1):
                if sA < needS or cA < needC or sA + cA < needB:
                    ways[teamA2index(sA, cA)] = 0
    else:
        for sA in range(s+1):
            for cA in range(c+1):
                if s-sA < needS or c-cA < needC or s-sA + c-cA < needB:
                    ways[teamA2index(sA, cA)] = 0


print(ways[-1])