import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;

public class Euler890 {

    static final long kMod = 1000000007L;

    static List<Integer> toBitsLSB(BigInteger n) {
        List<Integer> bits = new ArrayList<>();
        if (n.equals(BigInteger.ZERO)) {
            return bits;
        }
        while (n.compareTo(BigInteger.ZERO) > 0) {
            bits.add(n.testBit(0) ? 1 : 0);
            n = n.shiftRight(1);
        }
        return bits;
    }

    static long modAdd(long a, long b) {
        long s = a + b;
        if (s >= kMod) {
            s -= kMod;
        }
        return s;
    }

    static long modMul(long a, long b) {
        return (a * b) % kMod;
    }

    static long computePartitions(BigInteger n) {
        if (n.equals(BigInteger.ZERO)) {
            return 1;
        }

        List<Integer> bits = toBitsLSB(n);
        if (bits.size() == 1) {
            return 1;
        }

        int L = bits.size();

        long[] pow2 = new long[L + 3];
        pow2[0] = 1;
        for (int i = 1; i < pow2.length; ++i) {
            pow2[i] = modAdd(pow2[i - 1], pow2[i - 1]);
        }

        long[][] C = new long[L + 1][L + 1];
        for (int i = 0; i <= L; ++i) {
            C[i][0] = 1;
            for (int j = 1; j <= i; ++j) {
                C[i][j] = modAdd(C[i - 1][j - 1], C[i - 1][j]);
            }
        }

        long[][] w = new long[L + 1][];
        long[][] w2 = new long[L + 1][];
        for (int j = 0; j <= L; ++j) {
            w[j] = new long[j + 1];
            for (int m = 0; m <= j; ++m) {
                w[j][m] = modMul(C[j][m], pow2[j - m]);
            }
            w2[j] = new long[j + 2];
            w2[j][0] = w[j][0];
            for (int m = 1; m <= j; ++m) {
                w2[j][m] = modAdd(w[j][m], w[j][m - 1]);
            }
            w2[j][j + 1] = w[j][j];
        }

        long[] a = { 1 };

        for (int idx = 1; idx < L; ++idx) {
            int bit = bits.get(idx);
            int d = a.length - 1;

            long[] b = new long[d + 2];
            b[0] = a[0];
            for (int i = 1; i <= d; ++i) {
                b[i] = modAdd(a[i], a[i - 1]);
            }
            b[d + 1] = a[d];

            long[] nextA = new long[d + 2];

            for (int j = 0; j < d + 2; ++j) {
                int maxM = 0;
                if (bit == 0) {
                    maxM = Math.min(j, d + 1 - j);
                } else {
                    maxM = Math.min(j + 1, d + 1 - j);
                }

                long sum = 0;
                if (bit == 0) {
                    long[] wj = w[j];
                    for (int m = 0; m <= maxM; ++m) {
                        int i = j + m;
                        sum += modMul(b[i], wj[m]);
                        if (sum >= kMod) {
                            sum -= kMod;
                        }
                    }
                } else {
                    long[] w2j = w2[j];
                    for (int m = 0; m <= maxM; ++m) {
                        int i = j + m;
                        sum += modMul(b[i], w2j[m]);
                        if (sum >= kMod) {
                            sum -= kMod;
                        }
                    }
                }
                nextA[j] = sum;
            }

            a = nextA;
        }

        return a[0] % kMod;
    }

    public static String solve() {
        BigInteger n = BigInteger.valueOf(7).pow(777);
        return Long.toString(computePartitions(n));
    }

    public static void main(String[] args) {
        System.out.println(solve());
    }
}