class Factorial():
    def __init__(self, mod=10**9 + 7):
        self.mod = mod
        self._factorial = [1]
        self._size = 1
    
    def __call__(self, n):
        '''n! % mod '''
        if n >= self.mod:
            return 0
        make(n)
        return self._factorial[n]
    
    def make(self, n):
        if n >= self.mod:
            n = self.mod
        if self._size < n+1:
            for i in range(self._size, n+1):
                self._factorial.append(self._factorial[-1]*i % self.mod)
        self._size = n+1

class Modinv():
    def __init__(self, mod=10**9 + 7):
        self.mod = mod
        self._modinv = [1]
        self._size = 1
    
    def __call__(self, n):
        '''n^-1 % mod '''
        n %= mod
        make(n)
        return self._modinv[n]
    
    def make(self, n):
        if self._size < n+1:
            for i in range(self._size, n+1):
                self._modinv.append(self.inverse(i))
        self._size = n+1
    
    @staticmethod
    def xgcd(a, b):
        x0, y0, x1, y1 = 1, 0, 0, 1
        while b != 0:
            q, a, b = a // b, b, a % b
            x0, x1 = x1, x0 - q * x1
            y0, y1 = y1, y0 - q * y1
        return a, x0, y0
    
    def inverse(self, a):
        g, x, y = xgcd(a, self.mod)
        assert g == 1, 'modular inverse does not exist'
        return x % mod

class Combination():
    def __init__(self, mod=10**9 + 7):
        self.mod = mod
        self._factorial = Factorial(mod)
        self._modinv = Modinv(mod)
    
    def __call__(self, n, r):
        ''' nCr % mod '''
        if not 0 <= r <= n:
            return 0
        a, b, c = map(self.factorial, (n, r, n-r))
        return a*self._modinv(b*c % mod) % mod
    
    def comb_with_repetition(self, n, r):
        ''' nHr % mod '''
        return self.__call__(n+r-1, r)
    
    def perm(self, n, r):
        ''' nPr % mod '''
        if not 0 <= r <= n:
            return 0
        a, b = map(self.factorial, (n, n-r))
        return a*self._modinv(b) % mod
comb = Combination()
perm = comb.perm
comb_with_repetition = comb.comb_with_repetition

from re import split
for _ in range(int(input())):
    q, n, r, *_ = split('[(,)]', input())
    if q == 'C':
        print(comb(n, r))
    elif q == 'P':
        print(perm(n, r))
    else:
        print(comb_with_repetition(n, r))