import algorithm, hashes, macros, math, sequtils, sets, strutils, tables, times, unicode

macro unpack(rhs: seq, cnt: static[int]): auto =
  let t = genSym(); result = quote do:(let `t` = `rhs`;())
  if NimMinor <= 17:
    for i in 0..<cnt: result[0][1].add(quote do:`t`[`i`])
  else:
    for i in 0..<cnt: result[1].add(quote do:`t`[`i`])

template input(T: typedesc, cnt: Natural = 1): untyped =
  let line = stdin.readLine.split(" ")
  when T is int:         line.map(parseInt).unpack(cnt)
  elif T is float:       line.map(parseFloat).unpack(cnt)
  elif T is string:      line.unpack(cnt)
  elif T is char:        line.mapIt(it[0]).unpack(cnt)
  elif T is seq[int]:    line.map(parseint)
  elif T is seq[float]:  line.map(parseFloat)
  elif T is seq[string]: line
  elif T is seq[char]:   line.mapIt(it[0])

proc `%=`(n: var int, m: int)  = n = n mod m
proc `//=`(n: var int, m: int) = n = n div m
proc `<<=`(n: var int, m: int) = n = n shl m
proc `>>=`(n: var int, m: int) = n = n shr m
proc `<?=`(n: var int, m: int) = n = min(n, m)
proc `>?=`(n: var int, m: int) = n = max(n, m)
proc newSeq2[T](n1, n2: Natural): seq[seq[T]] = newSeqWith(n1, newSeq[T](n2))
proc newSeq3[T](n1, n2, n3: Natural): seq[seq[seq[T]]] = newSeqWith(n1, newSeqWith(n2, newSeq[T](n3)))

# -------------------------------------------------- #

const modulus = 10 ^ 9 + 7

type Matrix[T] = seq[seq[T]]

proc initMatrix[T](n: int, m: int): Matrix[T] =
  newSeqWith(n, newSeq[T](m))

proc mul[T](A: Matrix[T], B: Matrix[T]): Matrix[T] =
  var n = A.len()
  var m = B[0].len()
  var l = A[0].len()
  var C = initMatrix[T](A.len(), B[0].len())
  for i in countup(0, n - 1):
    for k in countup(0, l - 1):
      for j in countup(0, m - 1):
        C[i][j] = (C[i][j] + A[i][k] * B[k][j]) mod modulus
  return C

proc pow[T](A: Matrix[T], n: int): Matrix[T] =
  var n = n
  var A = A
  var B = initMatrix[T](A.len(), A.len())
  for i in countup(0, A.len() - 1):
    B[i][i] = 1
  while n > 0:
    if (n and 1) == 1:
      B = B.mul(A)
    A = A.mul(A)
    n = n shr 1
  return B

# -------------------------------------------------- #

proc main() =
  var N = input(int)
  var A = initMatrix[int](1, 2)
  A[0][0] = 1; A[0][1] = 0;
  var B = initMatrix[int](2, 2)
  B[0][0] = 1; B[0][1] = 1;
  B[1][0] = 1; B[1][1] = 0;
  var C = mul(A, pow(B, N))
  echo C[0][0] * C[0][1] mod modulus

main()