#include "bits/extc++.h"

using namespace std;

template <typename T, typename... U>
void dbgh(const T& t, const U&... u) {
    cerr << t;
    ((cerr << " | " << u), ...);
    cerr << endl;
}

#ifdef DEBUG
#define dbg(...)                                           \
    cerr << "L" << __LINE__ << " [" << #__VA_ARGS__ << "]" \
         << ": ";                                          \
    dbgh(__VA_ARGS__)
#else
#define cerr   \
    if (false) \
    cerr
#define dbg(...)
#endif

#define endl "\n"
#define long int64_t
#define sz(x) int(std::size(x))

template <typename T>
ostream& operator<<(ostream& out, const vector<T>& arr) {
    out << "[";
    for (int i = 0; i < sz(arr); i++) {
        if (i) {
            out << ", ";
        }
        out << arr[i];
    }
    return out << "]";
}

bool on(int mask, int bit) {
    return (mask >> bit) & 1;
}

constexpr int MOD = 1e9 + 7;

struct mint {
    static int norm(long x) {
        x %= MOD;
        if (x < 0) {
            x += MOD;
        }
        return x;
    }

    static mint pow(mint base, long exp) {
        mint ans = 1;

        while (exp) {
            if (exp & 1) {
                ans *= base;
            }
            base *= base;
            exp >>= 1;
        }

        return ans;
    }

    static mint inv(mint x) {
        return mint::pow(x, MOD - 2);
    }

    int x;

    mint() : x(0) {}
    mint(long x) : x(norm(x)) {}

    friend ostream& operator<<(ostream& out, const mint& m) {
        return out << m.x;
    }

    static mint from_unchecked(int x) {
        mint m;
        m.x = x;
        return m;
    }

    mint operator-() const {
        if (!x) {
            return {};
        }
        return mint::from_unchecked(MOD - x);
    }

    mint& operator+=(const mint& m) {
        x += m.x;
        if (x >= MOD) {
            x -= MOD;
        }
        return *this;
    }
    mint& operator-=(const mint& m) {
        return *this += -m;
    }

    mint& operator*=(const mint& m) {
        x = int(long(x) * m.x % MOD);
        return *this;
    }
    mint& operator/=(const mint& m) {
        return *this *= mint::inv(m);
    }

    friend mint operator+(mint a, const mint& b) {
        return a += b;
    }
    friend mint operator-(mint a, const mint& b) {
        return a -= b;
    }
    friend mint operator*(mint a, const mint& b) {
        return a *= b;
    }
    friend mint operator/(mint a, const mint& b) {
        return a /= b;
    }
};

struct M {
    static constexpr int MAXN = 100;

    mint fact[MAXN], ifact[MAXN];

    M() {
        fact[0] = ifact[0] = 1;
        for (int i = 1; i < MAXN; i++) {
            fact[i] = fact[i - 1] * i;
        }
        ifact[MAXN - 1] = mint::inv(fact[MAXN - 1]);
        for (int i = MAXN - 2; i >= 1; i--) {
            ifact[i] = (i + 1) * ifact[i + 1];
        }
    }

    mint choose(int n, int k) const {
        return fact[n] * ifact[k] * ifact[n - k];
    }

    mint choose2(int n, int k) const {
        if (n < 0 || k < 0 || k > n) {
            return 0;
        }
        return choose(n, k);
    }

    mint sab2(int n, int s) const {
        return choose2(s + n - 1, s);
    }
} M;

struct Timer {
    clock_t start = clock();

    double elapsed_secs() const {
        return double(clock() - start) / CLOCKS_PER_SEC;
    }
};

constexpr int MAXN = 15;
long dp_ord[1 << MAXN] {}, dp_split[1 << MAXN][MAXN + 1] {},
    dp[1 << MAXN][MAXN + 1] {};

void solve() {
    Timer timer;
    int n, m, kv;
    cin >> n >> m >> kv;

    int graph[n] {};
    for (int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;
        u--;
        v--;
        graph[u] |= 1 << v;
    }

    int graph_u[1 << n] {};

    for (int i = 0; i < n; i++) {
        graph_u[1 << i] = graph[i];
    }
    for (int mask = 0; mask < (1 << n); mask++) {
        for (int i = 0; i < n; i++) {
            if (on(mask, i)) {
                graph_u[mask] |= graph_u[mask ^ (1 << i)];
            }
        }
    }

    // # of ways to permute submask to get dag in induced subgraph
    dp_ord[0] = 1;
    for (int mask = 1; mask < (1 << n); mask++) {
        for (int i = 0; i < n; i++) {
            if (!on(mask, i)) {
                continue;
            }

            int omask = mask ^ (1 << i);
            if (on(graph_u[omask], i)) {
                continue;
            }

            dp_ord[mask] += dp_ord[omask];
        }
        dp_ord[mask] %= MOD;
        dbg(mask, dp_ord[mask]);
    }

    // # of ways to split mask into submasks so mutually disjoint
    dp_split[0][0] = 1;
    for (int mask = 1; mask < (1 << n); mask++) {
        int m_desc = __builtin_ctz(mask), m_pop = __builtin_popcount(mask);

        for (int c1 = 1; c1 <= m_pop; c1++) {
            for (int smask = mask; smask; smask = (smask - 1) & mask) {
                int omask = mask ^ smask;
                if (!on(smask, m_desc) || (graph_u[omask] & smask) ||
                    (graph_u[smask] & omask)) {
                    continue;
                }

                dp_split[mask][c1] = (dp_split[mask][c1] +
                                      dp_ord[smask] * dp_split[omask][c1 - 1]) %
                                     MOD;
            }
            dbg(mask, c1, dp_split[mask][c1]);
        }
    }
    // cout << timer.elapsed_secs() << endl;

    for (int blocks = 1; blocks <= n; blocks++) {
        int empty = kv + 1 - blocks;
        if (empty < 0) {
            continue;
        }

        mint cans = 1;

        cans *= M.fact[blocks];
        cans *= M.sab2(blocks + 1, kv - (blocks - 1));
        dbg(blocks, dp[0][blocks]);
        dp[0][blocks] = cans.x;
    }

    for (int mask = 1; mask < (1 << n); mask++) {
        int m_pop = __builtin_popcount(mask);

        for (int smask = mask; smask; smask = (smask - 1) & mask) {
            int omask = mask ^ smask;
            if (graph_u[omask] & smask) {
                continue;
            }

            for (int c1 = 0; c1 <= n - m_pop; c1++) {
                long& cans = dp[mask][c1];

                int c_pop = __builtin_popcount(smask),
                    o_pop = n - __builtin_popcount(omask),
                    mx = min(o_pop - c1, c_pop);
                for (int c2 = 1; c2 <= mx; c2 += 2) {
                    cans =
                        (cans + dp_split[smask][c2] * dp[omask][c1 + c2]) % MOD;
                }
                for (int c2 = 2; c2 <= mx; c2 += 2) {
                    cans =
                        (cans - dp_split[smask][c2] * dp[omask][c1 + c2]) % MOD;
                }
            }
        }
    }

    cout << dp[(1 << n) - 1][0] * M.ifact[n] / M.sab2(n + 1, kv) << endl;
}

int main() {
    cin.tie(nullptr);
    cin.exceptions(ios::failbit);
    ios_base::sync_with_stdio(false);
    solve();
}