public class Euler554 {
    static final int kMod = 100000007;
    static final int kFibLimit = 90;
    static final int kDefaultBlockSize = 100000;

    static long modPow(long base, long exp, long mod) {
        long result = 1;
        long cur = base % mod;
        while (exp > 0) {
            if ((exp & 1) != 0)
                result = (result * cur) % mod;
            cur = (cur * cur) % mod;
            exp >>= 1;
        }
        return result;
    }

    static class BlockFactorial {
        int mod;
        int blockSize;
        int[] blockFact;

        BlockFactorial(int mod, int blockSize) {
            this.mod = mod;
            this.blockSize = blockSize;
            int maxN = mod - 1;
            int numBlocks = (maxN + blockSize - 1) / blockSize;
            blockFact = new int[numBlocks + 1];
            blockFact[0] = 1;

            long cur = 1;
            for (int b = 1; b <= numBlocks; b++) {
                int start = (b - 1) * blockSize + 1;
                int end = Math.min(b * blockSize, maxN);
                for (int x = start; x <= end; x++) {
                    cur = (cur * x) % mod;
                }
                blockFact[b] = (int) cur;
            }
        }

        int factorialMod(int n) {
            if (n < 0 || n >= mod)
                return 0;
            if (n == 0)
                return 1;

            int b = n / blockSize;
            long cur = blockFact[b];
            int start = b * blockSize + 1;
            for (int x = start; x <= n; x++) {
                cur = (cur * x) % mod;
            }
            return (int) cur;
        }

        int binomSmall(int n, int k) {
            if (k < 0 || k > n)
                return 0;
            if (k == 0 || k == n)
                return 1;

            long nf = factorialMod(n);
            long kf = factorialMod(k);
            long nkf = factorialMod(n - k);
            long den = (kf * nkf) % mod;
            long invDen = modPow(den, mod - 2, mod);
            return (int) ((nf * invDen) % mod);
        }

        int binomLucas(long n, long k) {
            if (k > n)
                return 0;
            long nn = n;
            long kk = k;
            long result = 1;
            while (nn > 0 || kk > 0) {
                int ni = (int) (nn % mod);
                int ki = (int) (kk % mod);
                if (ki > ni)
                    return 0;
                result = (result * binomSmall(ni, ki)) % mod;
                nn /= mod;
                kk /= mod;
            }
            return (int) result;
        }

        int centralBinom(long n) {
            return binomLucas(2 * n, n);
        }
    }

    static int cMod(long n, BlockFactorial bf) {
        long central = bf.centralBinom(n);
        long nMod = n % kMod;
        long n2Mod = (nMod * nMod) % kMod;
        long correction = (3 * n2Mod + 2 * nMod + 7) % kMod;

        long ans = (8 * central) % kMod;
        ans = (ans - correction + kMod) % kMod;
        return (int) ans;
    }

    public static String solve() {
        BlockFactorial bf = new BlockFactorial(kMod, kDefaultBlockSize);
        long[] f = new long[kFibLimit + 1];
        f[1] = 1;
        f[2] = 1;
        for (int i = 3; i <= kFibLimit; i++) {
            f[i] = f[i - 1] + f[i - 2];
        }

        long answer = 0;
        for (int i = 2; i <= kFibLimit; i++) {
            answer = (answer + cMod(f[i], bf)) % kMod;
        }

        return Long.toString(answer);
    }

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