/*
 *  Forced Games (via mjd@cs.auckland.ac.nz)
 */
#include <iostream>
#include <vector>
#include <queue>
#include <sstream>

using namespace std;

typedef vector<int> NLIST;    		// node (neighbor) list
typedef vector< NLIST > ADJLIST;  	// graph data structure

class Game
{
  public:  

   ADJLIST adj;
   NLIST status;  // who can win or draw at vertex (1, 2 or 3)
   NLIST player;  // who owns vertex (1 or 2) 

   // creators + destroyers
   //
   Game(int n = 0) : adj(n), status(n), player(n) {}
   ~Game() {}

   // stream I/0
   //
   friend ostream& operator<<(ostream&, const Game&);
   friend istream& operator>>(istream&, Game&);

   bool setPlayers();  // returns false if not bipartite

   void setStatus();  // if connected + bipartite this should be fine.
   
   // mutators
   //
   bool addEdge(int u, int v)  // false if already exists
   {
     if ( isEdge(u,v) ) return false;
  
     adj[u].push_back(v);
     return true;
   }

   // accessors
   //
   int order() const 	// number of vertices
   { return adj.size(); }

   bool isEdge(int u, int v) const
   {
     int n = order();
     assert(u >= 0 && u < n);
     assert(v >= 0 && v < n);
     assert(u != v);
  
     for (int i=0; i<adj[u].size(); i++)
     {
       if (adj[u][i] == v) return true;
     }
     return false;
   }

   int degree(int u) const
   {
     return adj[u].size();
   }
};

bool Game::setPlayers()
{
  int n=order(), cnt = 0;
  for (int i=0; i<n; i++) { if (player[i]!=0) cnt++; }

  while (cnt < n)
  {
    int start_cnt = cnt;
    for (int i=0; i<n; i++)
    {
      if (player[i]==0) // in set
      {
        for (int j=0; j<degree(i); j++)
        if (player[adj[i][j]]) { player[i]=3-player[adj[i][j]]; cnt++; break; }
      }
      if (player[i]) // out set
      {
        for (int j=0; j<degree(i); j++)
        if (!player[adj[i][j]]) { player[adj[i][j]]=3-player[i]; cnt++; }
      }
    }
    if (start_cnt == cnt) cerr << "bad input (not connected?)\n" << *this;
  }

  for (int i=0; i<n; i++)
    for (int j=0; j<degree(i); j++)  //  check neighbors are other player
       if (player[i] == player[adj[i][j]]) return false;  // not bipartite
 
  return true;
}

void Game::setStatus()
{
  int n=order(), cnt = 0;
  for (int i=0; i<n; i++) { if (status[i]!=0) cnt++; }

  while (cnt < n)
  {
//cerr << "cnt = "<< cnt << endl;
    int start_cnt = cnt;
    for (int i=0; i<n; i++)
    {
      if (!status[i]) // self force win
      {
        if (player[i]==1)
        {
          for (int j=0; j<degree(i); j++)
          if (status[adj[i][j]]==1) { status[i]=1; cnt++; break; }
        }
        else // player = 2 
        {
          for (int j=0; j<degree(i); j++)
          if (status[adj[i][j]]==2) { status[i]=2; cnt++; break; }
        }  
      }

      if (!status[i]) // force loss
      {
        if (player[i]==1)
        {
          bool okay = false;
          for (int j=0; j<degree(i); j++)
          if (status[adj[i][j]]!=2) { okay = true; break; }
          if (!okay) { status[i]=2; cnt++; }
        }
        else // player = 2 
        {
          bool okay = false;
          for (int j=0; j<degree(i); j++)
          if (status[adj[i][j]]!=1) { okay = true; break; }
          if (!okay) { status[i]=1; cnt++; }
        }
      }
    }
    if (start_cnt == cnt) break;
  } 

  for (int i=0; i<n; i++) if (!status[i]) status[i]=3; // can't win, so draw
  return;
}


ostream& operator<<(ostream& o, const Game& G)
{
  int n=G.order();
  o << n << "\n";
  for (int i=0; i<n; i++) 
  {
    o << i << " (" << G.player[i] << "," << G.status[i] << ") : ";
    for (int j=0; j<G.adj[i].size(); j++) o << G.adj[i][j] << " ";
    o << "\n";
  }
  return o;
}

const static int LLEN=1024;
//
istream& operator>>(istream& in, Game& G) 
{
   char line[LLEN];
   int n; //in >> n;
   in.getline(line, LLEN);
   istringstream lineIn(line);
   lineIn >> n;
//  cerr << "n = " << n << '\n';

   G.adj.resize(n);
   G.status.resize(n);
   G.player.resize(n);
   for (int i=0; i<n; i++) 
   {
     G.adj[i].resize(0);
     G.status[i] = G.player[i] = 0;
   }

   for (int v1=0; v1<n; v1++)
   {
      in.getline(line, LLEN);    
//      cerr << "line: " << line << '\n';
      istringstream lineIn(line);

      int v2; while (lineIn>>v2)
      { 
//        cerr << "v2 = " << v2 << '\n';
        if (v2 == -1)
        { G.player[v1] = 2; G.status[v1] = 1; break; }
        else if (v2 == -2)
        { G.player[v1] = 1; G.status[v1] = 2; break; }
        else if (v2 == -3)
        { G.status[v1] = 3; break; }
        else G.addEdge(v1,v2);
      }
   }
   in.getline(line, LLEN);  // get trailing blank line
   return in;
}

int main()
{
  Game G;

  while (true)
  {
    cin >> G;
    int n = G.order();
    if (n==0) break; 
//cerr << G;
    if (! G.setPlayers() ) { cout << "Not bipartite\n\n"; continue; }
//cerr << G;
    G.setStatus();
//cerr << G;
    for (int i=0; i<n; i++) if (G.status[i]==1) cout << i << ' '; cout << endl;
    for (int i=0; i<n; i++) if (G.status[i]==2) cout << i << ' '; cout << "\n\n";
  }
}