#include<bits/stdc++.h>

#define REP(i,s,n) for(int i=s;i<n;++i)
#define rep(i,n) REP(i,0,n)

using namespace std;

#define MAX 110

struct UnionFind {
  int par[MAX];
  void init() {
    rep(i,MAX) par[i] = i;
  }
  int find(int x) {
    if( x == par[x] ) return x;
    return par[x] = find(par[x]);
  }
  void unit(int x,int y) {
    x = find(x), y = find(y);
    if(x!=y) par[x] = y;
  }
};



//
struct SCC{
public:
  int V;
  vector<vector<int> > G, rG;
  vector<bool> used;
  vector<int> cmp, vs;
  
  SCC(int V=0):V(V) {
    G.resize(V,vector<int>()), rG.resize(V,vector<int>());
    cmp.resize(V), used.resize(V);
  }

  void add_edge(int s,int t) {
    G[s].push_back(t);
    rG[t].push_back(s);
  }

  void dfs(int v) {
    used[v] = true;
    rep(i,(int)G[v].size()) if( !used[G[v][i]] ) dfs(G[v][i]);
    vs.push_back(v);
  }

  void rdfs(int v,int k) {
    used[v] = true;
    cmp[v] = k;
    rep(i,(int)rG[v].size()) if( !used[rG[v][i]] ) rdfs(rG[v][i],k);
  }

  int scc() {
    rep(i,V) used[i] = false;
    vs.clear();
    rep(v,V) if( !used[v] ) dfs(v);
    rep(i,V) used[i] = false;
    int k = 0;
    for(int i=(int)vs.size()-1;i>=0;--i) if( !used[vs[i]] ) {
	rdfs(vs[i],k++);
      }
    return k;
  }
  
};

//

int N;
double p[MAX];
vector<int> G[MAX];
int in_degree[MAX];
bool used[MAX];

double getProb(vector<vector<int> > newG,vector<double> newp,int newN) {
  memset(in_degree, 0, sizeof in_degree);
  UnionFind uf;
  uf.init();
  rep(i,newN) {
    rep(j,(int)newG[i].size()) {
      uf.unit(i,newG[i][j]);
      ++in_degree[newG[i][j]];
    }
  }
  vector<double> ps;
  rep(i,newN) uf.find(i);
  set<int> group;
  rep(i,newN) group.insert(uf.find(i));
  for(set<int>::iterator it=group.begin();it!=group.end();it++) {
    int gid = *it;
    vector<int> vec;
    rep(i,newN) if( uf.find(i) == gid ) {
      if( in_degree[i] == 0 ) {
	vec.push_back(i);
      }
    }
    if( (int)vec.size() ) {
      // the other
      double tmp = 1.0;
      rep(i,(int)vec.size()) {
	tmp *= ( 1.0 - newp[vec[i]] );
      }
      ps.push_back(tmp);
    } else assert(false);
    
  }
  double answer = 1.0;
  rep(i,(int)ps.size()) answer *= ps[i];
  return answer;
}

void compute() {
  UnionFind uf;
  uf.init();
  rep(i,N) {
    rep(j,(int)G[i].size()) {
      uf.unit(i,G[i][j]);
      ++in_degree[G[i][j]];
    }
  }
  vector<double> ps;
  rep(i,N) uf.find(i);
  set<int> group;
  rep(i,N) group.insert(uf.find(i));
  for(set<int>::iterator it=group.begin();it!=group.end();it++) {
    int gid = *it;
    //cout << "gid = " << gid << endl;
    vector<int> vec;
    rep(i,N) if( uf.find(i) == gid ) {
      if( in_degree[i] == 0 ) {
	vec.push_back(i);
      }
    }
    if( (int)vec.size() ) {
      // the other
      double tmp = 1.0;
      rep(i,(int)vec.size()) {
	tmp *= ( 1.0 - p[vec[i]] );
      }
      ps.push_back(tmp);
    } else {
      //cout << "group " << gid << " is loop" << endl;
      // loop  
      
      {
	vector<int> cand;
	rep(i,N) if( uf.find(i) == gid ) {
	  cand.push_back(i);
	}
	map<int,int> toIndex; // ?????????i??????scc??????????????????????????????
	map<int,int> rtoIndex;
	rep(i,(int)cand.size()) {
	  toIndex[cand[i]] = i;
	  rtoIndex[i] = cand[i];
	  //cout << cand[i] << " =toIndex=> " << i << endl;
	}
	SCC scc = SCC((int)cand.size());

	rep(i,N) if( uf.find(i) == gid ) {
	  rep(j,(int)G[i].size()) {
	    assert( uf.find(i) == uf.find(G[i][j]) );
	    assert( toIndex.count(i) );
	    assert( toIndex.count(G[i][j]) );
	    scc.add_edge(toIndex[i],toIndex[G[i][j]]);
	    //cout << "add edge " << toIndex[i] << "," << toIndex[G[i][j]] << endl;
	  }
	}
      
	int newN = scc.scc();
	vector<vector<int> > newG(newN,vector<int>());
	vector<double> newp(newN,1.0);

	//cout << "newN = " << newN << endl;

	rep(i,(int)scc.G.size()) {
	  rep(j,(int)scc.G[i].size()) {
	    if( scc.cmp[i] != scc.cmp[scc.G[i][j]] ) {
	      newG[scc.cmp[i]].push_back(scc.cmp[scc.G[i][j]]);
	      //cout << "(" << scc.cmp[i] << "=>" << scc.cmp[scc.G[i][j]] << ")" << endl;
	    }
	  }
	}
	//rep(i,(int)scc.G.size()) cout << "cmp[" << i << "] = " << scc.cmp[i] << endl;
	
	rep(i,(int)scc.G.size()) {
	  newp[scc.cmp[i]] *= p[rtoIndex[i]];
	  //cout << "newp["  << scc.cmp[i] << "] *= p[" << rtoIndex[i] << "]" << endl;
	  //cout << "=>" << newp[scc.cmp[i]] << endl;
	}
	ps.push_back(getProb(newG,newp,newN));
      }
    }
  }
  double answer = 1.0;
  rep(i,(int)ps.size()) answer *= ps[i];
  printf("%.10f\n",answer);
}

int main() {
  while( cin >> N, N ) {
  memset(in_degree,0,sizeof in_degree);
  memset(used,0,sizeof used);
    rep(i,MAX) G[i].clear();


    rep(i,N) {
      cin >> p[i];
      int M, tmp;
      cin >> M;
      rep(j,M) {
	cin >> tmp;
	--tmp;
	G[i].push_back(tmp);
      }
    }
    compute();
  }
  return 0;
}

Measured memory_bytes: 3472