#include <bits/stdc++.h>
using namespace std;

const int MOD = 1e9 + 7;  // 结果取模的常数
int N;  // 节点数
vector<int> adj[1001];  // 邻接表，表示树的结构
int dp[1001][2];  // dp[u][0] -> 不选u时的最大收益，dp[u][1] -> 选u时的最大收益
int ways[1001][2];  // ways[u][0] -> dp[u][0]对应的方案数，ways[u][1] -> dp[u][1]对应的方案数

// 深度优先搜索，递归计算树的最大收益和方案数
void dfs(int u, int parent) {
    dp[u][0] = 0;  // 初始化：不选u时，最大收益为0
    dp[u][1] = 0;  // 初始化：选u时，最大收益为0
    ways[u][0] = 1;  // 初始化：不选u时，方案数为1
    ways[u][1] = 0;  // 初始化：选u时，方案数为0（初始状态下不可能选择u）

    // 遍历当前节点u的所有邻居v
    for (int v : adj[u]) {
        if (v == parent) continue;  // 防止回到父节点，树的深度优先搜索
        dfs(v, u);  // 递归遍历子节点

        // 更新当前节点u不选的情况
        dp[u][0] += max(dp[v][0], dp[v][1]);  // 最大收益是子节点不选或选的最大值
        if (dp[v][0] > dp[v][1]) {
            // 如果子节点v不选的最大收益大于选v的最大收益
            ways[u][0] = (1LL * ways[u][0] * ways[v][0]) % MOD;  // 方案数是子节点不选的方案数的积
        } else if (dp[v][0] < dp[v][1]) {
            // 如果子节点v选的最大收益大于不选v的最大收益
            ways[u][0] = (1LL * ways[u][0] * ways[v][1]) % MOD;  // 方案数是子节点选的方案数的积
        } else {
            // 如果子节点v的最大收益是相同的（即不选v和选v都有相同的收益）
            ways[u][0] = (1LL * ways[u][0] * (ways[v][0] + ways[v][1]) % MOD) % MOD;  // 方案数是两种选择的方案数之和
        }

        // 更新当前节点u选的情况
        dp[u][1] = dp[u][0] + 1;  // 选择u时的最大收益是子节点都不选时的最大收益 + 1
        ways[u][1] = ways[u][0];  // 选择u时的方案数是选择u时不选子节点的方案数
    }
}

int main() {
    cin >> N;  // 输入节点数
    for (int i = 1; i <= N; i++) {
        int u, m;  // u为当前节点，m为该节点的邻居数量
        cin >> u >> m;
        for (int j = 0; j < m; j++) {
            int v;  // 邻接的节点v
            cin >> v;
            adj[u].push_back(v);  // 添加边到邻接表
            adj[v].push_back(u);  // 因为是无向图，反向边也要添加
        }
    }

    // 从根节点1开始执行DFS
    dfs(1, -1);

    // 输出结果
    cout << dp[1][0] << endl;  // 从根节点开始，不选根节点时的最大收益
    cout << ways[1][0] << endl;  // 从根节点开始，不选根节点时的最大收益对应的方案数

    return 0;
}