#include <iostream>

 #include <cstdio>

 using namespace std;

 #include <vector>

 #define loop(i, n) for (int i = 0; i < n; i++)

 #define loopfrom1(i, n) for (int i =1; i < n; i++)

 #define pb(a) push_back(a)

 #define SZ size()

 #define getint(n) scanf("%d", &n)

 #define MAXX 105

 #define looptill(i, n) for (int i = 0; i <= n; i++)

 vector<int> Graph[MAXX];

 bool visited[MAXX];

 int inaccessible;

 void dfs(int u)

 {

     int len = Graph[u].SZ;

     int v;

     loop(i, len)

     {

         v = Graph[u][i];

         if( ! visited[v] )

         {

             visited[v] = true;

             inaccessible --;

             dfs(v);

         }

     }

 }

 int main()

 {

     int number_of_nodes, total_nodes;

     int node1, node2;

     while(true)

     {

         getint(total_nodes);

         if(total_nodes == ) break;

         looptill(i, total_nodes)

         {

             Graph[i].clear();

         }

         while(true)

         {

             getint(node1);

             if(node1 == ) break;

             while(true)

             {

                 getint (node2);

                 if(node2 == ) break;

                 Graph[node1].pb(node2);

             }

         }

         getint(number_of_nodes);

         loop(t, number_of_nodes)

         {

             looptill(i, total_nodes)

             {

                 visited[i] = false;

             }

             getint(node1);

             inaccessible = total_nodes;

             dfs(node1);

             cout << inaccessible;

             for (int j = ; j <= total_nodes; j++)

             {

                 if( ! visited[j] )

                 {

                     cout <<" "<<j;

                 }

             }

             cout << endl;

         }

     }

     return ;

 }

 // @BEGIN_OF_SOURCE_CODE

 #include <iostream>

 #include <algorithm>

 #include <cstring>

 #include <string>

 #include <cctype>

 #include <vector>

 #include <map>

 #include <set>

 #include <math.h>

 #define For(a) for ( i = 0; i < a; i++ )

 #define Rep(a, b) for ( i = a; i <= b; i++ )

 #define N 1000000

 using namespace std;

 enum related_color {gray, white, black};

 bool matrix [ + ] [ + ];

 bool related_vertics [ + ];

 related_color color [ + ];

 int number_of_vertics_n;

 void reset_all (int n)

 {

     for ( int i = ; i < n; i++ ) {

         for ( int j = ; j < n; j++ )

             matrix [i] [j] = false;

     }

 }

 void dfs (int u)

 {

     color [u] = gray;

     for ( int i = ; i < number_of_vertics_n; i++ ) {

         if ( matrix [u] [i] ) {

             related_vertics [i] = true;

             if ( color [i] == white ) {

                 related_vertics [i] = true;

                 dfs (i);

             }

         }

     }

     color [u] = black;

 }

 int main ()

 {

     while ( scanf ("%d", &number_of_vertics_n) && number_of_vertics_n ) {

         reset_all (number_of_vertics_n);

         int starting_vertex;

         while ( scanf ("%d", &starting_vertex) && starting_vertex ) {

             int series_of_edges;

             while ( scanf ("%d", &series_of_edges) && series_of_edges ) {

                 matrix [starting_vertex - ] [series_of_edges - ] = true;

             }

         }

         int testCase;

         scanf ("%d", &testCase);

         while ( testCase-- ) {

             int query;

             scanf ("%d", &query);

             for ( int i = ; i < number_of_vertics_n; i++ ) {

                 related_vertics [i] = false;

                 color [i] = white;

             }

             dfs (query - );

             vector <int> v;

             for ( int i = ; i < number_of_vertics_n; i++ ) {

                 if ( !related_vertics [i] )

                     v.push_back (i + );

             }

             printf ("%d", v.size ());

             for ( unsigned int i = ; i < v.size (); i++ )

                 printf (" %d", v [i]);

             printf ("\n");

         }

         /*

         for ( int i = 0; i < number_of_vertics_n; i++ ) {

             for ( int j = 0; j < number_of_vertics_n; j++ )

                 related_vertics [j] = false;

             dfs (i);

             for ( int j = 0; j < number_of_vertics_n; j++ ) {

                 if ( related_vertics [j] )

                     matrix [i] [j] = true;

             }

         }

         */

     }

     return ;

 }

 // @END_OF_SOURCE_CODE