#include <bits/stdc++.h>
#define rep(i,n) for (int (i)=0;(i)<(n);++(i))
using namespace std;
typedef long long ll;
template <class T> inline void chmax(T &a, T b) { a=max(a,b); }
template <class T> inline void chmin(T &a, T b) { a=min(a,b); }
const int INF = 1e9+5;
const ll LINF = 1LL<<60;

template <int MOD>
class Modular {
public:
  long long val;
  Modular(long long v=0) : val(v%MOD) { if (val<0) val+=MOD; }
  long long getmod() { return MOD; }

  Modular operator-() const { return val>0 ? MOD-val : 0; }
  Modular& operator++() { *this+=1; return *this; }
  Modular& operator--() { *this-=1; return *this; }
  Modular operator++(int) { long long t=val; *this+=1; return t; }
  Modular operator--(int) { long long t=val; *this-=1; return t; }

  Modular operator+(const Modular &r) const { return Modular(*this)+=r; }
  Modular operator-(const Modular &r) const { return Modular(*this)-=r; }
  Modular operator*(const Modular &r) const { return Modular(*this)*=r; }
  Modular operator/(const Modular &r) const { return Modular(*this)/=r; }

  Modular& operator+=(const Modular &r) { val+=r.val; if (val>=MOD) val-=MOD; return *this; }
  Modular& operator-=(const Modular &r) { val-=r.val; if (val<0) val+=MOD; return *this; }
  Modular& operator*=(const Modular &r) { val*=r.val; val%=MOD; return *this; }
  Modular& operator/=(const Modular &r) {
    long long a=r.val, m=MOD, u=0, v=1;
    while (a!=0) {
      long long t=m/a;
      m-=t*a; swap(a,m);
      u-=t*v; swap(u,v);
    }
    assert(m==1);
    val = (val*u % MOD + MOD) % MOD;
    return *this;
  }

  bool operator==(const Modular &r) { return this->val == r.val; }
  bool operator!=(const Modular &r) { return this->val != r.val; }

  friend ostream& operator<<(ostream& os, const Modular<MOD> &x) { return os << x.val; }
  friend Modular<MOD> pow(const Modular<MOD> &a, long long n) {
    assert(n>=0);
    Modular<MOD> x=a, t=1;
    while (n>0) {
      if (n&1) t*=x;
      x*=x;
      n>>=1;
    }
    return t;
  }
};

template <typename T>
class BiCoef {
private:
  vector<T> _fac, _finv, _inv;

public:
  BiCoef() {}
  BiCoef(int n) { init(n); }
  void init(int n) {
    _fac.resize(n,1); _finv.resize(n,1); _inv.resize(n,1);
    int MOD = _fac[0].getmod();
    _inv[0] = 0;
    for (int i=2; i<=n; ++i) {
      _fac[i] = _fac[i-1]*i;
      _inv[i] = -_inv[MOD%i]*(MOD/i);
      _finv[i] = _finv[i-1]*_inv[i];
    }
  }

  T c(int n, int k) const {
    if (n<k || n<0 || k<0) return 0;
    return _fac[n]*_finv[k]*_finv[n-k];
  }
  T p(int n, int k) const {
    if (n<k || n<0 || k<0) return 0;
    return _fac[n]*_finv[n-k];
  }
  T h(int n, int k) const {
    if (n==0 && k==0) return 1;
    return c(n+k-1,k);
  }
  T fac(int n) const { if (n<0) return 0; assert(n<_fac.size()); return _fac[n]; }
  T finv(int n) const { if (n<0) return 0; assert(n<_finv.size()); return _finv[n]; }
  T inv(int n) const { if (n<0) return 0; assert(n<_inv.size()); return _inv[n]; }
};

const int MOD = 1000000007;
using mint = Modular<MOD>;
BiCoef<mint> bc;

int main() {
  int t;
  cin>>t;
  bc.init(2100000);
  rep(q,t) {
    string s;
    cin>>s;
    char c=s[0];
    int i;
    for (i=2; i<s.size(); i++) if (s[i]==',') break;
    int n=stoi(s.substr(2,i-2));
    int k=stoi(s.substr(i+1,s.size()-i-2));
    mint ans;
    if (c=='C') ans=bc.c(n,k);
    if (c=='P') ans=bc.p(n,k);
    if (c=='H') ans=bc.h(n,k);
    cout << ans << '\n';
  }
  return 0;
}