class Scanner {
    private var stack = [String]()
    private var index = 0
    
    func peek() -> String {
        if stack.count == index {
            stack += readLine()!.split(separator: " ").map{ String($0) }
        }
        return stack[index]
    }
    
    func next() -> String {
        let value = peek()
        index += 1
        return value
    }
    
    func nextInt() -> Int {
        return Int(next())!
    }
    
    func nextDouble() -> Double {
        return Double(next())!
    }
}

extension String {
    var characters: [Character] {
        self.map{ $0 }
    }
}

let mod = 1000000007

struct Modulo {
    let n: Int
    
    init(_ n: Int) {
        self.n = n
    }
    
    static func +(lhs: Self, rhs: Self) -> Self {
        return Modulo((lhs.n + rhs.n) % mod)
    }
    
    static func -(lhs: Self, rhs: Self) -> Self {
        return Modulo((lhs.n + mod - rhs.n) % mod)
    }
    
    static func *(lhs: Self, rhs: Self) -> Self {
        return Modulo((lhs.n * rhs.n) % mod)
    }
    
    static func +=(lhs: inout Self, rhs: Self) {
        lhs = lhs + rhs
    }
    
    static func -=(lhs: inout Self, rhs: Self) {
        lhs = lhs - rhs
    }
    
    static func *=(lhs: inout Self, rhs: Self) {
        lhs = lhs * rhs
    }
    
    func inverse() -> Self {
        // x * self = 1 (mod P) となるxを求める。
        // exists y, x * self - 1 = P*yと同値。
        // x*self - P*y = 1
        var x1 = 1, y1 = 0, z1 = n
        var x2 = 0, y2 = 1, z2 = -mod
        while z2 != 0 {
            let q = z1 / z2
            x1 -= x2 * q
            y1 -= y2 * q
            z1 -= z2 * q
            swap(&x1, &x2)
            swap(&y1, &y2)
            swap(&z1, &z2)
        }
        x1 %= mod
        if x1 < 0 {
            x1 += mod
        }
        return Modulo(x1)
    }
}

let sixth = Modulo(6).inverse()

struct Polynomial {
    let a: [Modulo]
    
    init(_ a: [Modulo]) {
        self.a = a
    }
    
    init(_ a: [Int]) {
        self.a = a.map(Modulo.init)
    }
    
    static var zero: Polynomial {
        get {
            Polynomial([0, 0, 0, 0, 0, 0])
        }
    }
    
    static var one: Polynomial {
        get {
            Polynomial([1, 0, 0, 0, 0, 0])
        }
    }
    
    subscript(index: Int) -> Modulo {
        a[index]
    }
    
    static func *(lhs: Self, rhs: Self) -> Self {
        var c = Array.init(repeating: Modulo(0), count: 11)
        for i in 0 ... 5 {
            for j in 0 ... 5 {
                c[i + j] += lhs[i] * rhs[j]
            }
        }
        for i in (6 ... 10).reversed() {
            for j in 0 ... 5 {
                c[i - 6 + j] += c[i] * sixth
            }
        }
        return Polynomial(Array(c[0 ... 5]))
    }
    
    func power(_ n: Int) -> Polynomial {
        if n == 0 { return .one }
        let value = power(n / 2)
        if n % 2 == 0 {
            return value * value
        } else {
            return value * value * self
        }
    }
}

var scanner = Scanner()
let N = scanner.nextInt()
print(Polynomial([0, 1, 0, 0, 0, 0]).power(N + 5)[5].n)