public class Euler739 {
    static final long kMod = 1000000007L;

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

    static long modPow(long base, long exp) {
        long result = 1L;
        while (exp > 0L) {
            if ((exp & 1L) != 0L) {
                result = mulMod(result, base);
            }
            base = mulMod(base, base);
            exp >>= 1L;
        }
        return result;
    }

    static class Pair {
        long a, b;

        Pair(long a, long b) {
            this.a = a;
            this.b = b;
        }
    }

    static Pair fibPair(long n) {
        if (n == 0L) {
            return new Pair(0L, 1L);
        }
        Pair p = fibPair(n >> 1L);
        long a = p.a;
        long b = p.b;

        long twoB = (2L * b) % kMod;
        long twoBMinusA = (twoB + kMod - a) % kMod;
        long c = mulMod(a, twoBMinusA);
        long d = (mulMod(a, a) + mulMod(b, b)) % kMod;

        if ((n & 1L) == 0L) {
            return new Pair(c, d);
        }
        return new Pair(d, (c + d) % kMod);
    }

    static long lucas(long n) {
        if (n == 0L) {
            return 2L;
        }
        Pair p = fibPair(n);
        long fn = p.a;
        long fn1 = p.b;
        long value = (2L * fn1) % kMod;
        value = (value + kMod - fn) % kMod;
        return value;
    }

    static void batchInvert(int[] values, int[] inverses, int[] prefix, int m) {
        if (m == 0)
            return;

        prefix[0] = values[0];
        for (int i = 1; i < m; ++i) {
            prefix[i] = (int) mulMod(prefix[i - 1], values[i]);
        }

        long suffixInv = modPow(prefix[m - 1], kMod - 2L);
        for (int i = m - 1; i >= 0; --i) {
            long left = (i == 0) ? 1L : prefix[i - 1];
            inverses[i] = (int) mulMod(suffixInv, left);
            suffixInv = mulMod(suffixInv, values[i]);
        }
    }

    public static String solve() {
        long n = 100000000L;
        long r = n - 1L;

        long t = r;
        long coeff = 1L;

        long lT = lucas(r);
        long lTPlus1 = lucas(r + 1L);

        long answer = 0L;

        int kBlock = 1000000;
        int[] denoms = new int[kBlock];
        int[] invDenoms = new int[kBlock];
        int[] prefix = new int[kBlock];

        while (t >= 1L) {
            long hi = t;
            long lo = (hi > kBlock) ? (hi - kBlock + 1L) : 1L;
            int m = (int) (hi - lo + 1L);

            for (int i = 0; i < m; ++i) {
                long curT = hi - i;
                if (curT == 1L) {
                    denoms[i] = 1;
                } else {
                    long u = r - curT + 1L;
                    denoms[i] = (int) mulMod(curT % kMod, u % kMod);
                }
            }

            batchInvert(denoms, invDenoms, prefix, m);

            for (int i = 0; i < m; ++i) {
                long curT = hi - i;

                answer += mulMod(coeff, lTPlus1);
                if (answer >= kMod) {
                    answer -= kMod;
                }

                if (curT == 1L) {
                    break;
                }

                long numA = curT - 1L;
                long numB = 2L * r - curT;
                long num = mulMod(numA % kMod, numB % kMod);

                coeff = mulMod(coeff, num);
                coeff = mulMod(coeff, invDenoms[i]);

                long nextLTPlus1 = lT;
                long nextLT = (lTPlus1 + kMod - lT) % kMod;
                lTPlus1 = nextLTPlus1;
                lT = nextLT;
            }

            if (lo == 1L) {
                break;
            }
            t = lo - 1L;
        }

        return Long.toString(answer);
    }

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