public class Euler629 {
    static final int MOD = 1000000007;
    static final int X = 256;

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

    static int modSub(int a, int b) {
        int s = a - b;
        if (s < 0)
            s += MOD;
        return s;
    }

    static int[] partitionsMod(int n) {
        int[] dp = new int[n + 1];
        dp[0] = 1;
        for (int s = 1; s <= n; s++) {
            for (int sum = s; sum <= n; sum++) {
                dp[sum] = modAdd(dp[sum], dp[sum - s]);
            }
        }
        return dp;
    }

    static int losingPartitionsXor0(int n, int[] sg) {
        int[][] dp = new int[n + 1][X];
        dp[0][0] = 1;
        for (int s = 1; s <= n; s++) {
            int g = sg[s];
            for (int sum = s; sum <= n; sum++) {
                int[] cur = dp[sum];
                int[] prev = dp[sum - s];
                for (int x = 0; x < X; x++) {
                    cur[x ^ g] = modAdd(cur[x ^ g], prev[x]);
                }
            }
        }
        return dp[n][0];
    }

    static int[] sgK2(int n) {
        int[] sg = new int[n + 1];
        for (int s = 2; s <= n; s++) {
            sg[s] = (s % 2 == 0) ? 1 : 0;
        }
        return sg;
    }

    static int[] sgK3(int n) {
        int[] sg = new int[n + 1];
        for (int s = 2; s <= n; s++) {
            boolean[] seen = new boolean[X];
            for (int a = 1; a <= s - 1; a++) {
                seen[sg[a] ^ sg[s - a]] = true;
            }
            for (int a = 1; a <= s - 2; a++) {
                for (int b = 1; b <= s - a - 1; b++) {
                    int c = s - a - b;
                    seen[sg[a] ^ sg[b] ^ sg[c]] = true;
                }
            }
            int g = 0;
            while (g < X && seen[g])
                g++;
            sg[s] = g;
        }
        return sg;
    }

    static int[] sgK4(int n) {
        int[] sg = new int[n + 1];
        for (int s = 2; s <= n; s++) {
            sg[s] = s - 1;
        }
        return sg;
    }

    static int f(int n, int[] sg, int partitionsN) {
        int losing = losingPartitionsXor0(n, sg);
        return modSub(partitionsN, losing);
    }

    static int gFunc(int n) {
        if (n < 2)
            return 0;
        int[] part = partitionsMod(n);
        int Pn = part[n];

        int[] sg2 = sgK2(n);
        int[] sg3 = sgK3(n);
        int[] sg4 = sgK4(n);

        int f2 = f(n, sg2, Pn);
        int ans = f2;
        if (n >= 3)
            ans = modAdd(ans, f(n, sg3, Pn));
        if (n >= 4) {
            long term = (long) (n - 3) * f(n, sg4, Pn) % MOD;
            ans = modAdd(ans, (int) term);
        }
        return ans;
    }

    public static String solve() {
        return Integer.toString(gFunc(200));
    }

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