#include <bits/stdc++.h>
using namespace std;

using i64 = long long;

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    
    auto solve = [&]() {
        int n, m, k;
        cin >> n >> m >> k;
        
        vector<int> s(m), t(m), w(m);
        vector<vector<int>> c(m), adj(n), radj(n);

        for (int i = 0; i < m; i++) {
            cin >> s[i] >> t[i] >> w[i];
            s[i]--, t[i]--;
            adj[s[i]].push_back(i);
            radj[t[i]].push_back(i);
            int k;
            cin >> k;
            c[i].resize(k);
            for (int j = 0; j < k; j++) {
                cin >> c[i][j];
                c[i][j]--;
            }
        }

        vector<vector<int>> deg(n);
        vector<vector<i64>> worst(n);

        for (int u = 0; u < n; u++) {
            vector<int> cols;
            for (auto i : adj[u]) {
                cols.insert(cols.end(), c[i].begin(), c[i].end());
            }
            sort(cols.begin(), cols.end());
            cols.erase(unique(cols.begin(), cols.end()), cols.end());
            int sz = cols.size();
            deg[u].resize(sz);
            worst[u].resize(sz);
            for (auto i : adj[u]) {
                for (auto &x : c[i]) {
                    x = lower_bound(cols.begin(), cols.end(), x) - cols.begin();
                    deg[u][x]++;
                }
            }
        } 

        constexpr i64 INF = 1e18;

        priority_queue<pair<i64, int>, vector<pair<i64, int>>, greater<>> h;
        vector<i64> dis(n, INF);
        h.emplace(0, n - 1);
        dis[n - 1] = 0;
        
        auto push = [&](i64 nd, int v) {
            if (nd < dis[v]) {
                h.emplace(nd, v);
                dis[v] = nd;
            }
        };

        while (!h.empty()) {
            auto [d, u] = h.top();
            h.pop();
            if (dis[u] != d) {
                continue;
            }

            for (auto i : radj[u]) {
                int v = s[i];
                for (auto x : c[i]) {
                    worst[v][x] = max(worst[v][x], d + w[i]);
                    deg[v][x]--;
                    if (deg[v][x] == 0) {
                        push(worst[v][x], v);
                    }
                }
            }
        }

        if (dis[0] == INF) {
            cout << "impossible\n";
        } else {
            cout << dis[0] << '\n';
        }
    };

    solve();

    return 0;
}