#include <iostream>
     
    //include
    //------------------------------------------
    #include <vector>
    #include <list>
    #include <map>
    #include <set>
    #include <deque>
    #include <stack>
    #include <queue>
    #include <bitset>
    #include <tuple>
    #include <algorithm>
    #include <functional>
    #include <numeric>
    #include <utility>
    #include <sstream>
    #include <iostream>
    #include <iomanip>
    #include <cstdio>
    #include <cmath>
    #include <cstdlib>
    #include <cctype>
    #include <string>
    #include <cstring>
    #include <ctime>
    #include <climits>
     
    using namespace std;
     
    //conversion
    //------------------------------------------
    inline int toInt(string s)
    {
        int v;
        istringstream sin(s);
        sin >> v;
        return v;
    }
    template <class T>
    inline string toString(T x)
    {
        ostringstream sout;
        sout << x;
        return sout.str();
    }
     
    //math
    //-------------------------------------------
    template <class T>
    inline T sqr(T x) { return x * x; }
     
    //typedef
    //------------------------------------------
    typedef vector<int> VI;
    typedef vector<VI> VVI;
    typedef vector<long long> VL;
    typedef vector<string> VS;
    typedef pair<int, int> PII;
    typedef long long LL;
     
    //container util
    //------------------------------------------
    #define ALL(a) (a).begin(), (a).end()
    #define RALL(a) (a).rbegin(), (a).rend()
    #define PB push_back
    #define MP make_pair
    #define SZ(a) int((a).size())
    #define EACH(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
    #define EXIST(s, e) ((s).find(e) != (s).end())
    #define SORT(c) sort((c).begin(), (c).end())
     
    //repetition
    //------------------------------------------
    #define FOR(i, a, b) for (int i = (a); i < (b); ++i)
    #define REP(i, n) FOR(i, 0, n)
     
    //constant
    //--------------------------------------------
    const double EPS = 1e-10;
    const double PI = acos(-1.0);
    const long long INFL = __LONG_LONG_MAX__ / 10;
    const int INFI = __INT_MAX__ / 10;
     
    //clear memory
    #define CLR(a) memset((a), 0, sizeof(a))
     
    uint64_t popcnt(uint64_t n)
    {
        uint64_t c = 0;
        c = (n & 0x5555555555555555) + ((n >> 1) & 0x5555555555555555);
        c = (c & 0x3333333333333333) + ((c >> 2) & 0x3333333333333333);
        c = (c & 0x0f0f0f0f0f0f0f0f) + ((c >> 4) & 0x0f0f0f0f0f0f0f0f);
        c = (c & 0x00ff00ff00ff00ff) + ((c >> 8) & 0x00ff00ff00ff00ff);
        c = (c & 0x0000ffff0000ffff) + ((c >> 16) & 0x0000ffff0000ffff);
        c = (c & 0x00000000ffffffff) + ((c >> 32) & 0x00000000ffffffff);
        return (c);
    }
     
    //debug
    // #define dump(x) cerr << #x << " = " << (x) << endl;
    // #define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
    //                       << " " << __FILE__ << endl;
     
    const int LimitN = 21;
    int A[LimitN][LimitN];
     
    int N;
    const int mod = 1e9 + 7;
     
    LL dp[LimitN + 1][1 << LimitN];
     
    int main()
    {
        ios::sync_with_stdio(false);
     
        cin >> N;
        REP(i, N)
        {
            REP(j, N)
            {
                int a;
                cin >> A[i][j];
            }
        }
     
        dp[0][0] = 1;
     
        FOR(i, 0, N)
        {
            FOR(msk, 0, 1 << N)
            if (i == popcnt(msk))
            {
                FOR(j, 0, N)
                if (!(msk & (1 << j)) && A[i][j] == 1)
                {
                    dp[i + 1][msk | (1 << j)] += dp[i][msk];
                    dp[i + 1][msk | (1 << j)] %= mod;
                }
            }
        }
     
        cout << dp[N][(1 << N) - 1] << endl;
    }

Measured memory_bytes: 309504