#include <algorithm>
#include <string>
#include <vector>
#include <queue>
#include <iostream>
#include <cmath>
#include <sstream>
#include <map>
#include <set>
#include <cstring>
#include <unordered_map>
using namespace std;
#define pb push_back
#define INF 1000000000
#define L(s) (int)((s).size())
#define FOR(i,a,b) for (int _n(b), i(a); i <= _n; i++)
#define FORD(i,a,b) for(int i=(a),_b=(b);i>=_b;i--)
#define rep(i,n) FOR(i,1,(n))
#define rept(i,n) FOR(i,0,(n)-1)
#define C(a) memset((a),0,sizeof(a))
#define ll long long
#define all(c) (c).begin(), (c).end()
#define SORT(c) sort(all(c))
#define VI vector<int>
#define ppb pop_back
#define mp make_pair
#define pii pair<int,int>
#define pdd pair<double,double>
#define x first
#define y second
#define MOD 1000000007

int cur[102], nx[102];
VI sm[102];
int ls[102];
unordered_map<unsigned ll, int> q;
int n;

inline void doit(int cnt) {
    rept(iter, cnt) {
        memmove(cur, nx, n * sizeof(int));
        q.clear();
        int k = 0;
        rept(i, n) {
            int c = 0;
            rept(j, L(sm[i])) {
                ls[c++] = cur[sm[i][j]];
            }
            sort(ls, ls + c);
            unsigned ll h = 1 + L(sm[i]);
            rept(j, c) {
                h = (h * 1234567891) ^ ls[j];
            }
            h = h * 1000000009 + cur[i];
            auto it = q.find(h);
            if (it != q.end()) {
                nx[i] = it->y;
            }
            else {
                q[h] = k++;
                nx[i] = k - 1;
            }
        }
    }
}

bool used[102];
class AutomorphicGraph
{
    public:
    int count( int n, vector <int> a, vector <int> b )
    {
        ::n = n;
        rept(i, n) sm[i].clear();
        rept(i, L(a)) {
            sm[a[i]].pb(b[i]);
            sm[b[i]].pb(a[i]);
        }

        rept(i, n) nx[i] = L(sm[i]);
        int ans = 1;
        C(used);
        doit(5000);
        while (1) {
            doit(600);
            int mn = INF;
            rept(i, n) {
                if (used[i]) continue;
                mn = min(mn, nx[i]);
            }
            if (mn >= INF) break;
            int c = 0;
            rept(i, n) {
                if (!used[i] && nx[i] == mn) {
                    ++c;
                }
            }
            ans = (ll)ans * c % MOD;

            rept(i, n) {
                if (!used[i] && nx[i] == mn) {
                    used[i] = 1;
                    nx[i] = 101;
                    break;
                }
            }
        }
        return ans;
    }
};