#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <stack>
#include <queue>
#include <functional>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <vector>
#include <array>
#include <tuple>
#include <utility>
#include <numeric>
#include <iomanip>
#include <cctype>
#include <cmath>
#include <assert.h>
using namespace std;

using ll = long long;
using ull = unsigned long long;
using PII = pair<int, int>;
using PLL = pair<ll, ll>;

template<typename T1, typename T2> ostream& operator<<(ostream& s, const pair<T1, T2>& p) {
    return s << "(" << p.first << ", " << p.second << ")";
}
template<typename T> ostream& operator<<(ostream& s, const vector<T>& v) {
    s << "[";
    for (int i = 0; i < v.size(); i++) s << (i == 0 ? "" : ", ") << v[i];
    s << "]";
    return s;
}

#define ALL(a) (a).begin(), (a).end()

using Weight = int;

// ??????????????????
struct Edge {
    int from, to;
    Weight weight;

    Edge() {}
    Edge(int to) : from(-1), to(to), weight(-1) {}
    Edge(int from, int to) : from(from), to(to), weight(-1) {}
    Edge(int from, int to, Weight weight) : from(from), to(to), weight(weight) {}

    bool operator<(const Edge& e) const {
        return (weight != e.weight) ? (weight < e.weight) : (from < e.from);
    }
    bool operator>(const Edge& e) const {
        return (weight != e.weight) ? (weight > e.weight) : (from > e.from);
    }
};

using Arc = Edge;
using Graph = vector<vector<Edge>>;
using DGraph = vector<vector<Arc>>;

using Tree = Graph;

// ?????????????????????????????¨????????????????????????!
using GArray = vector<Weight>;
using GMatrix = vector<GArray>;

// ??????4????????¢??°???????????°??????????????????????????§?????§?????????
void add_edge(Graph& g, int u, int v, Weight w = -1) {
    g[u].push_back(Edge(u, v, w));
    g[v].push_back(Edge(v, u, w));
}

void add_arc(DGraph& dg, int u, int v, Weight w = -1) {
    dg[u].push_back(Arc(u, v, w));
}

const int GM_INF = (1LL << 25);

void init_gmatrix(GMatrix& gm) {
    for (int u = 0; u < gm.size(); u++) {
        for (int v = 0; v < gm[u].size(); v++) {
            gm[u][v] = GM_INF;
        }
    }
}

void add_edge(GMatrix& gm, int u, int v, Weight w = -1) {
    gm[u][v] = w;
    gm[v][u] = w;
}

void add_arc(GMatrix& gm, int u, int v, Weight w = -1) {
    gm[u][v] = w;
}

// Kosaraju's algorithm
namespace SCC {
    const int MAX_V = 110;

    DGraph dgraph, rev_dgraph, new_dgraph;

    array<bool, MAX_V> used;
    array<int, MAX_V> new_id; // ????????????????????????????????£?????????????§£???????????????????????????

    vector<double> attr;
    vector<double> new_attr;

    vector<int> po_nodes;   // ??°????????????(postorder)??????????????????

    void dfs(int v) {
        used[v] = true;
        for (Arc e : dgraph[v]) {
            if (!used[e.to]) {
                dfs(e.to);
            }
        }
        po_nodes.push_back(v);
    }

    void rev_dfs(int v, int id) {
        used[v] = true;
        new_id[v] = id;
        for (Arc e : rev_dgraph[v]) {
            if (!used[e.to]) {
                rev_dfs(e.to, id);
            }
        }
    }

    // ?????????kosaraju????????¶?????¨!!
    DGraph& compose_dgraph(int num) {
        new_dgraph = DGraph(num);
        new_attr = vector<double>(num, 1.0);

        map<PII, int> map;

        for (int v = 0; v < dgraph.size(); v++) {
            int from_id = new_id[v];

            new_attr[from_id] *= attr[v];

            for (Arc e : dgraph[v]) {
                int to_id = new_id[e.to];

                PII ft = make_pair(from_id, to_id);

                // ???????????????????????¶
                if (from_id != to_id && map.count(ft) == 0) {
                    map[ft] = true;
                    new_dgraph[from_id].push_back(Arc(to_id));
                }
            }
        }
        return new_dgraph;
    }

    DGraph& kosaraju(DGraph& dg, vector<double>& p) {
        used.fill(false);
        po_nodes.clear();

        dgraph = dg;
        rev_dgraph = DGraph(dg.size());

        attr = p;

        // ????????????????????°??????????§????
        for (int v = 0; v < dgraph.size(); v++) {
            for (Arc e : dgraph[v]) {
                rev_dgraph[e.to].push_back(Arc(v));
            }
        }

        // ??°????????????????????????????????????
        for (int v = 0; v < dgraph.size(); v++) {
            if (!used[v]) {
                dfs(v);
            }
        }

        used.fill(false);

        int num = 0;    // ?????£?????????????????°
        for (int i = po_nodes.size() - 1; i >= 0; i--) {
            int v = po_nodes[i];
            if (!used[v]) {
                rev_dfs(v, num);
                num++;
            }
        }

        return compose_dgraph(num);
    }
};

const int MAX_N = 110;

array<bool, MAX_N> used;

void dfs(DGraph& dg, int v) {
    used[v] = true;
    for (Arc a : dg[v]) {
        if (!used[a.to]) {
            dfs(dg, a.to);
        }
    }
}

int main() {
    int n;
    while (cin >> n, n) {
        DGraph dg(n);
        vector<double> p(n);

        for (int i = 0; i < n; i++) {
            cin >> p[i];

            int m;
            cin >> m;
            for (int j = 0; j < m; j++) {
                int a;
                cin >> a;
                a--;

                add_arc(dg, i, a);
            }
        }

        used.fill(false);

        auto new_dg = SCC::kosaraju(dg, p);
        double ans = 1.0;
        for (int v = 0; v < new_dg.size(); v++) {
            if (!used[v]) {
                dfs(new_dg, v);
                ans *= (1 - SCC::new_attr[v]);
            }
        }
        cout << fixed << setprecision(10) << ans << endl;
    }

    return 0;
}

Measured memory_bytes: 3604