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

#define ARG4(_1,_2,_3,_4,...) _4

#define forn3(i,l,r) for (int i = int(l); i < int(r); ++i)
#define forn2(i,n) forn3 (i, 0, n)
#define forn(...) ARG4(__VA_ARGS__, forn3, forn2) (__VA_ARGS__)

#define ford3(i,l,r) for (int i = int(r) - 1; i >= int(l); --i)
#define ford2(i,n) ford3 (i, 0, n)
#define ford(...) ARG4(__VA_ARGS__, ford3, ford2) (__VA_ARGS__)

#define ve vector
#define pa pair
#define tu tuple
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define fs first
#define sc second
#define all(a) (a).begin(), (a).end()
#define sz(a) ((int)(a).size())

typedef long double ld;
typedef int64_t ll;
typedef uint64_t ull;
typedef uint32_t ui;
typedef uint16_t us;
typedef uint8_t uc;
typedef pa<int, int> pii;
typedef pa<int, ll> pil;
typedef pa<ll, int> pli;
typedef pa<ll, ll> pll;
typedef ve<int> vi;

const ld pi = 3.1415926535897932384626433832795l;

template<typename T> inline auto sqr (T x) -> decltype(x * x) {return x * x;}
template<typename T1, typename T2> inline bool umx (T1& a, T2 b) {if (a < b) {a = b; return 1;} return 0;}
template<typename T1, typename T2> inline bool umn (T1& a, T2 b) {if (b < a) {a = b; return 1;} return 0;}

struct Input {
        bool read () {
        }

        void init (const Input &input) {
                *this = input;
        }
};

struct Data: Input {
        void write () {
        }
};

struct Solution: Data {

        static const int MOD = 1000000007;
        static const int N = 60;

    int get_pow(int x, int st) {
        int res = 1;
        while (st) {
            if (st & 1) {
                res = 1ll * res * x % MOD;
            }
            st /= 2;
            x = 1ll * x * x % MOD;
        }
        return res;
    }

        int rev(int x) {
        return get_pow(x, MOD - 2);
    }

        int a[N + 1], b[N + 1], c[N + 1], d[N + 1][N + 1], cnt[N + 1];
    int part[N + 2], pbrt[N + 2];
    int pcnt;
    int fact[N + 1], rfact[N + 1];
    int gcd[N + 1][N + 1];
    int pow2[N * N];

        void calc_add(int coeff, int st) {
        cnt[n]++;
        a[n] = (a[n] + 1ll * coeff * pow2[st]) % MOD;
        if (part[0] != n) {
            int sub = 1;
            forn(i, pcnt) {
                sub = 1ll * sub * big[part[i]][pbrt[i]] % MOD;
            }
            a[n] = (a[n] + MOD - sub) % MOD;
        }
        }

    int big_binom(int n, int k) {
        n = (n + k - 1) % MOD;
        int res = rfact[k];
        forn(i, k) {
            res = 1ll * res * (n + MOD - i) % MOD;
        }
        return res;
    }

    int binom(int n, int k) {
        return 1ll * fact[n] * rfact[k] % MOD * rfact[n - k] % MOD;
    }

    int mult[N + 1][N + 1];
    int big[N + 1][N + 1];

    int left;
    int pr;
    int n;

        void rec(int coeff, int st = 0, int add = 0) {
        if (!left) {
            calc_add(coeff, st + add);
            return;
        }
        if (!pr) {
            return;
        }
        --pr;
        rec(coeff, st, add);
        ++pr;
        int old_pcnt = pcnt;
        part[pcnt++] = pr;
        int add_gcd = pr / 2;
        forn(i, old_pcnt) {
            add_gcd += pbrt[i] * gcd[part[i]][pr];
        }
        if (pr & 1) add = 1;
        for (int cnt = 1; cnt * pr <= left; ++cnt) {
            int ncoeff = 1ll * coeff * binom(left, cnt * pr) % MOD;
            ncoeff = 1ll * ncoeff * mult[cnt][pr] % MOD;
            pbrt[old_pcnt] = cnt;
            st += add_gcd + (cnt - 1) * pr;
            left -= cnt * pr;
            --pr;
            rec(ncoeff, st, add);
            ++pr;
            left += cnt * pr;
        }
        pcnt = old_pcnt;
        }

        Solution() {
                memset(a, 0, sizeof(a));
                memset(b, 0, sizeof(b));
                memset(c, 0, sizeof(c));
                memset(d, 0, sizeof(d));
        memset(cnt, 0, sizeof(cnt));
        pcnt = 0;
        fact[0] = rfact[0] = 1;
        forn (i, 1, N + 1) {
            fact[i] = 1ll * fact[i - 1] * i % MOD;
            rfact[i] = rev(fact[i]);
        }
        forn (len, 1, N + 1) {
            mult[0][len] = 1;
            for (int cnt = 1; cnt * len <= N; ++cnt) {
                mult[cnt][len] = 1ll * mult[cnt - 1][len] * fact[cnt * len - 1] % MOD;
                mult[cnt][len] = 1ll * mult[cnt][len] * rfact[(cnt - 1) * len] % MOD;
            }
        }
        forn(i, 1, N + 1) {
            forn(j, 1, N + 1) {
                gcd[i][j] = __gcd(i, j);
            }
        }
        pow2[0] = 1;
        forn(i, 1, N * N) {
            pow2[i] = (pow2[i - 1] * 2) % MOD;
        }
                forn (dn, 1, N + 1) {
            left = pr = n = dn;
                        rec(rfact[n]);
            forn(i, N + 1) {
                big[n][i] = big_binom(a[n], i);
            }
        }
        c[0] = MOD - 1;
        forn(i, 1, N + 1) {
            c[i] = (c[i - 1] + a[i]) % MOD;
        }
        cout << "static const int c[] = {0";
        forn(i, 1, N + 1) {
            cout << ", " << c[i];
        }
        cout << "};" << endl;
        }

        void solve () {
        }

        void clear () {
        }
};

Solution sol;

int main () {
        return 0;
}