#include <stdio.h>

/*
    defines
*/

#define MAX_SCHOOLS         100
#define CONNECT             1
#define DISCONNECT          0
#define INVALID_COMPONENT   -1

/*
    input and input related data
*/

int N;
int A[MAX_SCHOOLS + 1][MAX_SCHOOLS + 1];    /* these things are easily understood ... */

void input() {
    FILE * in = fopen("input.txt", "rt");
    fscanf(in, "%d", &N);
    for (int i = 1; i <= N; i++) {
        A[i][i] = CONNECT;
        int j; fscanf(in, "%d", &j);
        while (j) {
            A[i][j] = CONNECT;
            fscanf(in, "%d", &j);
        }
    }
    fclose(in);
}

/*
    solve function and solving related data
*/

int task1[MAX_SCHOOLS + 1];                 /* answer for the 1st task */
int marked[MAX_SCHOOLS + 1];                /* markers for the 1st task */

int n_components;                           /* number of strongly connected components */
int representer[MAX_SCHOOLS + 1];           /* vertex that represents the component */
int domain[MAX_SCHOOLS + 1];                /* component number of the vertex */

int inputs_c;                               /* number of pure inputs */
int inputs_l[MAX_SCHOOLS + 1];              /* the list of pure inputs */

int is_remained_input[MAX_SCHOOLS + 1];     /* whether the input should be linked at the end */
int is_output[MAX_SCHOOLS + 1];             /* whether the component is pure output */

int stack_c;                                /* number of elements in stack */
int stack_l[MAX_SCHOOLS + 1];               /* stack for dfs */

int locked[MAX_SCHOOLS + 1];                /* whether the component is locked */

int added_l;                                /* number of the links added */
int W[MAX_SCHOOLS + 1][MAX_SCHOOLS + 1];    /* matrix of the links added */

/* adds an unexisting link. the algorithm is bugful if already exists */

void add_link(int i, int j) {
    if ((W[representer[i]][representer[j]] == CONNECT) || (A[representer[i]][representer[j]] == CONNECT)) {
        printf("error: link (%d -> %d) already exists.\n", i, j);
    } else {
        added_l++;
        W[representer[i]][representer[j]] = CONNECT;
        is_output[i] = 0;
        is_remained_input[j] = 0;
    }
}

void solve() {

    /* floyd-warshall comes ... */
    
    for (int k = 1; k <= N; k++) {
        for (int i = 1; i <= N; i++)
            for (int j = 1; j <= N; j++)
                A[i][j] |= A[i][k] & A[k][j];
    }
    
    /* task 1 */
    
    for (int i = 1; i <= N; i++) {
        if (!marked[i]) {
            task1[i] = 1;
            for (int j = 1; j <= N; j++) {
                marked[j] |= A[i][j];
                task1[j] &= !A[i][j] | (i == j);
            }
        }
    }
    
    /* now we have the 1st task solved. let's compute the strongly connected components ... */
    
    n_components = 0;
    for (int i = 1; i <= N; i++) {
        if (domain[i] == 0) {
            representer[n_components++] = i;
            for (int j = 1; j <= N; j++)
                if (A[i][j] && A[j][i]) {
                    domain[j] = i;
                }
        }
    }
    
    /* ok. now we must now whether the component is pure input or pure output ... */
    
    for (int i = 0; i < n_components; i++) {
        int is_input = 1; is_output[i] = 1;
        for (int j = 0; j < n_components; j++) {
            if (i == j)
                continue;
                
            if (A[representer[i]][representer[j]]) {
                is_output[i] = 0;
            }
            if (A[representer[j]][representer[i]])
                is_input = 0;
        }
        is_remained_input[i] = is_input;
        if (is_input)
            inputs_l[inputs_c++] = i;
    }
    
    /*
        we`ll need two vertices on the One Great Cycle somewhere below ...
    */
    
    int cycle_in = INVALID_COMPONENT, cycle_out = INVALID_COMPONENT;
    
    /*
        well. we`ve just divided all the components into pure inputs, pure outputs and some other garbage.
        now we`ll construct a Large Hadron Collider. :) that will be some cycle through all the 
        pseudo-trees ...
    */
    
    int first_input = inputs_c == 0 ? INVALID_COMPONENT : inputs_l[inputs_c - 1];
    int prev_output = INVALID_COMPONENT;
    
    while (inputs_c > 0) {
        int input_c = inputs_l[--inputs_c];
        
        /* we`ll use depth-first search to go down locking passed vertices */
        int found_output = INVALID_COMPONENT;
        
        stack_l[stack_c++] = input_c;
        
        while (stack_c > 0) {
            int c = stack_l[--stack_c];
            
            locked[c] = 1;
            
            if (is_output[c]) {
                /* found some pure output. stopping dfs ... */
                found_output = c;
                stack_c = 0;
                break;
            } else {
                /* going further ... */
                for (int i = 0; i < n_components; i++)
                    if (!locked[i] && (A[representer[c]][representer[i]] == CONNECT))
                        stack_l[stack_c++] = i;
            }
        }
        
        /* link previous output (if any) to the input */
        if (found_output != INVALID_COMPONENT) {
            if (prev_output != INVALID_COMPONENT) {
                add_link(prev_output, input_c);

                cycle_in = input_c; cycle_out = prev_output;
            }
            prev_output = found_output;
        }
    }

    /* and link the last to the first if possible */
    if ((first_input != INVALID_COMPONENT) && (prev_output !=  first_input)) {
        add_link(prev_output, first_input);
        
        cycle_in = first_input; cycle_out = prev_output;
    }
        
    /*
        well, well, well, ... now we have the One Large Cycle and (maybe) some pure inputs and
        pure outputs. we should link them in pairs ...
    */
    
    for (int k = 0; k < n_components; k++)
        for (int p = 0; p < n_components; p++) {
            if (k == p)
                continue;
            if (is_output[k] && is_remained_input[p]) {
                add_link(k, p);
                
                cycle_in = p; cycle_out = k;
            }
        }
    
    /* and now link others to the One Large Cycle ... */
    
    for (int k = 0; k < n_components; k++) {
        if (is_output[k] && !is_remained_input[k]) {
            add_link(k, cycle_in);
        }
    }
    
    for (int k = 0; k < n_components; k++) {
        if (is_remained_input[k] && !is_output[k]) {
            add_link(cycle_out, k);
        }
    }
    
    /* we assume that the task is solved ;) */
}

/*
    just the output function
*/

void output() {
    FILE * out = fopen("output.txt", "wt");

    int counter = 0;
    for (int i = 1; i <= N; i++)
        counter += task1[i];
    fprintf(out, "%d\n", counter);
    
    fprintf(out, "%d\n", added_l);
    for (int i = 1; i <= N; i++)
        for (int j = 1; j <= N; j++) 
            if (W[i][j] == CONNECT)
                fprintf(out, "%d %d\n", i, j);
        
    fclose(out);
}

/*
    main function
*/

int main(void) {
    input();
    solve();
    output();

    return 0;
}