#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; (i) < int(n); ++ (i))
#define loop(i,a,n) for (int i = (a); (i) < int(n); ++ (i))
#define ll long long
#define ld long double
#define EPS 0.0000000001
#define INF 1e9
#define MOD 0
//#define int ll
using namespace std;
// set of vertices
using vgrp_t = std::vector<int>;

// graph (adjacency list)
using graph_t = std::vector<vgrp_t>;

graph_t reverse_graph(graph_t const &g) {
    graph_t rg(g.size());
    for (int i = 0; i < static_cast<int>(g.size()); i++) {
        for (int to : g[i]) rg[to].push_back(i);
    }
    return rg;
}

std::vector<std::pair<int, int>> make_numbering(graph_t const &g) {
    // std::pair<int, int> = { order in postorder DFS, vertex number }
    // order | -1 => not yet visited
    //       | -2 => now searching
    std::vector<std::pair<int, int>> numbering(g.size(),
                                               std::make_pair(-1, 0));

    std::function<int(int, int)> dfs = [&](int v, int num) {
        // if v is already visited, do nothing.
        if (numbering[v].first != -1) return num;
        numbering[v].first = -2;
        for (int to : g[v]) num = dfs(to, num);
        numbering[v] = std::make_pair(num, v);
        return num + 1;
    };

    int num = 0;
    for (int i = 0; i < static_cast<int>(g.size()); i++) {
        if (numbering[i].first == -1) num = dfs(i, num);
    }

    return numbering;
}

class strongly_connected_components_t {
  private:
    std::vector<int> scc_of_;
    int size_;

  public:
    strongly_connected_components_t(std::vector<int> scc_of, int size)
        : scc_of_(scc_of)
        , size_(size) {}
    int size() const { return size_; }
    int scc_of(int v) const { return scc_of_[v]; }
};

strongly_connected_components_t
decompose_impl(graph_t const &rg,
               std::vector<std::pair<int, int>> const &numbering) {
    std::vector<int> scc_of(rg.size(), -1);

    // mark a strongly connected components beginning from vertex v with
    // `num`.
    std::function<void(int, int)> dfs = [&](int v, int num) {
        scc_of[v] = num;
        // add not yet decomposed vertices in adjacent vertices
        for (int to : rg[v]) {
            if (scc_of[to] != -1) continue;
            dfs(to, num);
        }
    };

    int num = 0;
    for (auto const &p : numbering) {
        int v = p.second;
        if (scc_of[v] == -1) dfs(v, num++);
    }
    return strongly_connected_components_t(scc_of, num);
}

strongly_connected_components_t decompose_into_sccs(graph_t const &g) {
    auto numbering = make_numbering(g);
    std::sort(numbering.begin(), numbering.end(),
              std::greater<std::pair<int, int>>());
    return decompose_impl(reverse_graph(g), numbering);
}

signed main() {
    int N,fri,m;
    while(1) {
    cin >> N;
    if(N==0) break;
    vector<double> pos(N);
    graph_t ss(N);
    rep(i,N) {
        cin >> pos[i] >> m;
        rep(j,m) {
            cin >> fri;
            ss[i].push_back(fri-1);
        }
    }
    auto setted = decompose_into_sccs(ss);
    graph_t sg(setted.size());
    graph_t fg(setted.size());

    rep(i,N) sg[setted.scc_of(i)].push_back(i);

    rep(i,N) {
        rep(j,ss[i].size()) {
            if(setted.scc_of(i) != setted.scc_of(ss[i][j])) {
                fg[setted.scc_of(i)].push_back(setted.scc_of(ss[i][j]));
            }
        }
    }
    rep(i,fg.size()) {
        sort(fg[i].begin(),fg[i].end());
        fg[i].erase(unique(fg[i].begin(),fg[i].end()),fg[i].end());
    }
    double possibility;
    vector<bool> pointed(fg.size(),false);
    vector<double> possi(fg.size());
    rep(i,fg.size()) {
        possibility = 1;
        rep(j,sg[i].size()) {
            possibility *= pos[sg[i][j]];
        }
        rep(j,fg[i].size()) {
            pointed[fg[i][j]] = true;
        }
        possi[i] = 1- possibility;
    }
    double ans = 1;
    rep(i,pointed.size()) {
        if(!pointed[i]) ans *= possi[i];
    }
    cout << fixed << setprecision(9) << ans << endl;
    }
    return 0;
}


Measured memory_bytes: 3408