//#define _GLIBCXX_DEBUG
#include <iostream>
#include <cassert>
#include <cstdio>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <ctime>
#include <stack>
#include <list>
using namespace std;
typedef long long li;
typedef long double ld;
typedef vector<li> vi;
typedef pair<int, int> pi;

#define mp make_pair
#define pb push_back
#define all(s) s.begin(), s.end()
void precalc();
li solve();

int main() {
    FILE* x = freopen("input", "r", stdin);
#ifdef DEBUG

    clock_t start = clock();
#else
    x = freopen("output", "w", stdout);
#endif

        //cout << 1 << endl << 1000 << endl;
       // for(int i = 1; i < 1000; ++i)
         //   cout << i << " "<<(rand()%2?'<':'>') << ' ' << rand() % i << endl;
    (void)x;
    ios_base::sync_with_stdio(false);
    int t = 1;
    cin >> t;
    string s;
        precalc();
    getline(cin,s );
    for(int i = 1; i <= t; ++i){
        cout << "Case #" << i << ": " << solve() << '\n';
    }

#ifdef DEBUG
    cout << "\n\n\nTime:" << ((clock() - start) / 1.0 / CLOCKS_PER_SEC);
#endif
    return 0;
}


#define int li
const int mod = 1000000007;

vector<char> gr[1010];
vector<int> g[1010];

int c[1010][1010];

void precalc(){
    for(int i = 0; i <= 1005; ++i){
        c[i][0] = c[i][i] = 1;
        for(int j = 1; j < i; ++j){
            c[i][j] = c[i - 1][j] + c[i- 1][j - 1];
            c[i][j] %= mod;
        }
    }
}

vector<int> dfs(int v, int p){
    vector<int> cur(1, 1);

    for(size_t i = 0; i < g[v].size(); ++i){
        int to = g[v][i];
        if(to != p){
            vector<int> child = dfs(to, v);
            vector<int> next(cur.size() + child.size(), 0);

            if(gr[v][i]){
                for(size_t was = 0; was < cur.size(); ++was){
                    vector<int> prefsum(child.size(), 0);

                    for(size_t x = 0; x < child.size(); ++x){
                        prefsum[x] = child[x] * c[x + was + 1][was] % mod * c[next.size() - 2 - x - was][cur.size() - 1 - was] + (x > 0 ? prefsum[x - 1] : 0);
                        prefsum[x] %= mod;
                    }

                    for(size_t will = was + 1; will <= was + child.size(); ++will){
                        next [will] += cur[was] * prefsum[will - was - 1];
                        next [will] %= mod;
                    }
                }


            }
            else {
                for(size_t was = 0; was < cur.size(); ++was){
                    vector<li> sufsum(child.size() + 1, 0);

                    for(int x = child.size() - 1; x >= 0; --x){
                        sufsum[x] = child[x] * c[x + was][was] % mod * c[next.size() - 1 - x - was][cur.size() - 1 - was] + sufsum[x + 1];
                        sufsum[x] %= mod;
                    }

                    for(size_t will = was; will < was + child.size(); ++will){
                        next[will] += cur[was] * sufsum[will - was];
                        next[will] %= mod;
                    }
                }
            }

            cur = next;

        }

    }


    return cur;
}

li solve(){
    int n;
    cin >> n;
    for(int i = 0; i < n; ++i){
        gr[i].clear();
        g[i].clear();
    }

    for(int i = 1; i < n; ++i){
        char c;
        int a, b;
        cin >> a >>c>> b;
        if(c == '<'){
            swap(a, b);
        }
        g[a].pb(b);
        gr[a].pb(true);
        g[b].pb(a);
        gr[b].pb(false);
    }
    vector<int> c = dfs(0, -1);

    li ans = 0;
    for(size_t i = 0; i < c.size(); ++i){
        ans += c[i];
        //cerr << c[i] << ' ';
    }
    return ans % mod;

}