Harryxun/stf_run huggingface dataset:
H = input()
W = input()
N = input()
M = max(H, W)
if N % M == 0:
  print(N // M)
else:
  print((N // M) + 1)

### FIXED CODE ###

H = int(input())
W = int(input())
N = int(input())
M = max(H, W)
if N % M == 0:
  print(N // M)
else:
  print((N // M) + 1)
import math
n = int(input())
print(n * 2 * math.p)

### FIXED CODE ###

from math import pi
n = int(input())
print(2 * pi * n)
num_list = list(map(int, input().split()))
N = num_list[0]
L = num_list[1]
S = [input(i) for i in range(N)]
for i in range(N):
        for j in range(N):
                if i < j:
                        for k in range(L):
                                if S[i][k] > S[j][k]:
                                        S[i], S[j] = S[j], S[i]
                                        break
                                else:
                                        continue
print(''.join(S))


### FIXED CODE ###

x = list(map(int, input().split()))
a = 0
for i in x:
        if i != 5 and i != 7:
                a = 1
        break
if a == 0:
        if sum(x) == 17:
                print('YES')
        else:
                print('NO')
else:
        print('NO')
D,T,S=map(int,input().split())
if T*S>D:
  print(Yes)
else:
  print(No)

### FIXED CODE ###

D,T,S=map(int,input().split())
if T*S>=D:
  print("Yes")
else:
  print("No")
N=int(input())
P=list(map(int,input().split()))
ans=1

for i in range(1,N):
  if P[i]!=1 and P[i]<=min(P[:i]):
    ans+=1
  elif P[i]==1:
    ans+=1
    break

for j in range(i+1,N):
  if P[j]==1:
    ans+=1

print(ans)

### FIXED CODE ###

N=int(input())
P=list(map(int,input().split()))

ans=0
val=P[0]
for i in range(N):
  if val>=P[i]:
    ans+=1
    val=P[i]
print(ans)
import sys
lst=[]
ans=0
for i in range(5):
  a=int(input())
  if a%10==0:
    ans+=a
  else:
    lst.append(a)
C=[[] for _ in range(len(lst))]   
for i in range(len(lst)):
  v=lst[i]
  c=v%10
  C[i]=[-c,v]
C=sorted(C)
for i in range(len(lst)-1):
  v=C[i][1]
  c=-C[i][0]
  ans+=(v+(10-c))
print(ans+C[-1][1])

### FIXED CODE ###

import sys
lst=[]
ans=0
for i in range(5):
  a=int(input())
  if a%10==0:
    ans+=a
  else:
    lst.append(a)
if len(lst)!=0:
  C=[[] for _ in range(len(lst))]   
  for i in range(len(lst)):
    v=lst[i]
    c=v%10
    C[i]=[-c,v]
  C=sorted(C)
  for i in range(len(lst)-1):
    v=C[i][1]
    c=-C[i][0]
    ans+=(v+(10-c))
  print(ans+C[-1][1])
else:
  print(ans)
x=int(input())

if x==3||x==5||x==7:
  print("YES"+"\n")
else:
  print("NO"+"\n")

### FIXED CODE ###

x=int(input())
 
if x==3 or x==5 or x==7:
  print("YES"+"\n")
else:
  print("NO"+"\n")
r = int(input())
return r * r


### FIXED CODE ###

r=int(input())
print(r*r)
n = int(input())
X = []
Y = []
H = []

for _ in range(n):
    x, y, h = map(int, input().split())
    X.append(x)
    Y.append(y)
    H.append(h)

for cx in range(101):
    for cy in range(101):
        flg = False
        # print(cx, cy)
        tmp = None
        for k in range(n):
            # print(tmp)
            if H[k] == 0 and tmp<abs(cx-X[k])+abs(cy-Y[k]):
                flg = True
                break
            elif H[k] == 0:
                continue
            elif not tmp:
                tmp = H[k]+abs(cx-X[k])+abs(cy-Y[k])
                continue
            elif tmp == H[k]+abs(cx-X[k])+abs(cy-Y[k]):
                continue
            else:
                flg = True 
                break
        if flg:
            continue
        else:
            print(cx, cy, tmp)
            exit()


### FIXED CODE ###

n = int(input())
data = []

for _ in range(n):
    x, y, h = map(int, input().split())
    data.append((x,y,h))

data.sort(key=lambda x:x[2], reverse=True)

for cx in range(101):
    for cy in range(101):
        flg = False
        # print(cx, cy)
        tmp = None
        for k in data:
            x = k[0]
            y = k[1]
            h = k[2]
            if not tmp:
                tmp = h+abs(cx-x)+abs(cy-y)
                continue
            if h == 0 and tmp>abs(cx-x)+abs(cy-y):
                flg = True
                break
            elif h == 0:
                continue
            elif tmp == h+abs(cx-x)+abs(cy-y):
                continue
            else:
                flg = True 
                break
        if flg:
            continue
        else:
            print(cx, cy, tmp)
            exit()
x=str(input())
l=str(len(s))
list=[s[0],l,s[l-1]]
print(''.join(list))

### FIXED CODE ###

s=str(input())
l=len(s)
li=str(l-2)
list=[s[0],li,s[l-1]]
print(''.join(list))
# -*- coding: utf-8 -*-
import numpy as np 
import math

def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])


    return arr

a,b = list(map(int,input().split()))
gcd = math.gcd(a,b)
# print(gcd)
# print(factorization(gcd))
print(len(factorization(gcd))+1)

### FIXED CODE ###

# -*- coding: utf-8 -*-
import numpy as np 
import math

#a,bの最大公約数
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])


    return arr

a,b = list(map(int,input().split()))
x = gcd(a,b)
# print(gcd)
# print(factorization(gcd))
print(len(factorization(x))+1)
input1 = list(map(int,input().split()))
K = input[0]
X = input[1]
if K * 500 >= X:
  print("Yes")
else:
  print("No")

### FIXED CODE ###

input1 = list(map(int,input().split()))
K = input1[0]
X = input1[1]
if K * 500 >= X:
  print("Yes")
else:
  print("No")
D, T, S = map(int, input().split)

if S*T >= D:
  print("Yes")
else:
  print("No")

### FIXED CODE ###

D, T, S = map(int, input().split())

if S*T >= D:
  print("Yes")
else:
  print("No")
S = input()
K = int(input())

if S[0] != '1':
  print(S[0])
elif S[0] == '1' and K >= 1:
  print(S[1])
else:
  print(1)

### FIXED CODE ###

# ans

S = input()
K = int(input())

if S[0:K].count('1') == K:
  print(1)
  exit()
  
for i in range(K):
  if S[i] != '1':
    print(S[i])
    exit()
A, B = map(int, input().split())
S = list(input())

if S[B] == '-':
    for i in range(8):
        if i == B:
            continue
        else:
            if S[i] == '-':
                print('No')
                exit()
    print('Yes')
else:
    print('No')


### FIXED CODE ###

A, B = map(int, input().split())
S = input()

fwd = S[0:A]
bwd = S[A+1:]
flag = 0
if fwd.isdigit() == True:
    if S[A] == '-':
        if bwd.isdigit() == True:
            flag = 1
if flag == 1:
    print('Yes')
else:
    print('No')
import queue
import copy
s=list()

N,M=map(int,raw_input().split())
n=[[0 for i in range(N)] for j in range(N)]
for i in range(M):
        a,b=map(int,raw_input().split())
        n[a-1][b-1]=1
        n[b-1][a-1]=1
arrived=[0 for i in range(N)]

arrived[0]=1
def solve(s,arrived):
        narrived=copy.deepcopy(arrived)
        global n
        global N
        op=False
        ans=0
        for i in range(N):
                arrived=copy.deepcopy(narrived)
                if(s[i]==1 and arrived[i]!=1):
                        op=True
                        arrived[i]=1
                        ans+=solve(n[i],arrived)
        
        if(sum(arrived)==N and op==False):
                return 1
        elif(op==False):
                return 0
        return ans
                        
print(solve(n[0],arrived))


### FIXED CODE ###

import copy
s=list()

N,M=map(int,raw_input().split())
n=[[0 for i in range(N)] for j in range(N)]
for i in range(M):
        a,b=map(int,raw_input().split())
        n[a-1][b-1]=1
        n[b-1][a-1]=1
arrived=[0 for i in range(N)]

arrived[0]=1
def solve(s,arrived):
        narrived=copy.deepcopy(arrived)
        global n
        global N
        op=False
        ans=0
        for i in range(N):
                arrived=copy.deepcopy(narrived)
                if(s[i]==1 and arrived[i]!=1):
                        op=True
                        arrived[i]=1
                        ans+=solve(n[i],arrived)
        
        if(sum(arrived)==N and op==False):
                return 1
        elif(op==False):
                return 0
        return ans
                        
print(solve(n[0],arrived))
# coding: utf8

if __name__ == "__main__":
    n = int(input())
    w = []
    flag = True
    for _ in range(n):
        a = input()
        last = w[len(w)-1]
        if a[0] != last[len(last)-1] and a in w:
            flag = False
            print("No")
            break
        w.append(a)
    if flag == True:
        print("Yes")



### FIXED CODE ###

# coding: utf8

if __name__ == "__main__":
    n = int(input())
    w = []
    flag = True
    for _ in range(n):
        a = input()
        if len(w) == 0:
            w.append(a)
            continue
        last = w[len(w)-1]
        if a[0] != last[len(last)-1] or a in w:
            flag = False
            break
        w.append(a)
    if flag == True:
        print("Yes")
    else:
        print("No")
t, x = map(input())
a = t / x
print (a)

### FIXED CODE ###

x, y = map (int, input().split())
a = x / y
print (a)
t = input()
for i in range(len(t)):
    if(t[i] == '?'):
        if(i == 0):
            if(t[i+1] == 'D'):  t = 'P' +t[1:]
            else: t ='D' +t[1:]
        elif(i == len(t) -1):
            t = t[:i] + 'D'
        else:
            if(t[i-1] == 'P'): t = t[:i] + 'D' +t[i+1:]
            elif(t[i+1] == 'D'):  t = t[:i] + 'P' +t[i+1:]
            elif(t[i+1] == '?'):  t = t[:i] + 'P' +t[i+1:]
            else: t = t[:i] + 'D' + t[i+1:]
print(t)

### FIXED CODE ###

t = input()
if(len(t) == 1):
    if (t[0] == '?'): t = "D"
if(t[0] == '?'):
    if  (t[1] == 'D'): t = "".join(['P' , t[1:]])
    elif(t[1] == '?'): t = "".join(['PD', t[2:]])
    else:              t = "".join(['D' , t[1:]])
if(t[-1] == '?'):
    t = "".join([t[:-1], 'D'])
for i in range(len(t)-1):
    if(t[i] == '?'):
        if(t[i-1] == 'P'):    t = "".join([t[:i], 'D' , t[i+1:]])
        elif(t[i+1] == 'D'):  t = "".join([t[:i], 'P' , t[i+1:]])
        elif(t[i+1] == 'P'):  t = "".join([t[:i], 'D' , t[i+1:]])
        elif(t[i+1] == '?'):  t = "".join([t[:i], 'PD', t[i+2:]])
print(t)
a,b = int(input())
print(a*b if a < 10 and b < 10 else -1)

### FIXED CODE ###

a,b = map(int,input().split())
print(a*b if a < 10 and b < 10 else -1)
def main():
    n = int(input())
    p_l = list(map(int, input().split()))
    cnt = 0
    for i in range(n):
        if p_l[i] == i + 1: continue
        else: cnt += 1
    if cnt > 2: print("NO")
    else: print("YES")
if __name__ == "__main__":
    main()

### FIXED CODE ###

def main():
    r = int(input())
    print( 3 * r ** 2)
if __name__ == "__main__":
    main()
S = input()
A = [chr(ord('a') + i) for i in range(26)]
c = 0

for i in range(26):
  if A[i] in S:
    continue
  else:
    print(A[i])
    c = 1
    break
if c = 0:
  print("None")

### FIXED CODE ###

S = input()
A = [chr(ord('a') + i) for i in range(26)]
c = 0

for i in range(26):
  if A[i] in S:
    continue
  else:
    print(A[i])
    c = 1
    break
if c == 0:
  print("None")
import java.util.*;

public class Main{
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		int a=sc.nextInt();
		int b=sc.nextInt();
		if (a<=b){
			System.out.println(a);
		}else{
			System.out.println(a-1);
		}
	}
}

### FIXED CODE ###

a,b=list(map(int,input().split()))

if b<a:
    print(a-1)
else:
    print(a)
H, W = map(int, input().split())
s = [list(input()) for _ in range(H)]
a = [[-1]*W for _ in range(H)]
for i in range(H):
  for j in range(W):
    if s[i][j] == ".":
      a[i][j] = 1
    dh = [-1,0,1,0]
    dw = [0,-1,0,1]
    for k in range(4):
      ii = i + dh[k]
      jj = j + dw[k]
      if 0 <= ii < W and 0 <= jj < H:
        if s[i][j] == "#" and s[ii][jj] == "#":
          a[i][j] = 1
          a[ii][jj] = 1
flag = True
for i in range(H):
  for j in range(W):
    if a[i][j] != 1:
      flag = False
      break
if flag:
  print("Yes")
else:
  print("No")

### FIXED CODE ###

H, W = map(int, input().split())
s = [list(input()) for _ in range(H)]
a = [[-1]*W for _ in range(H)]
for i in range(H):
  for j in range(W):
    if s[i][j] == ".":
      a[i][j] = 1
    dh = [-1,0,1,0]
    dw = [0,-1,0,1]
    for k in range(4):
      ii = i + dh[k]
      jj = j + dw[k]
      if 0 <= ii < H and 0 <= jj < W:
        if s[i][j] == "#" and s[ii][jj] == "#":
          a[i][j] = 1
          a[ii][jj] = 1
flag = True
for i in range(H):
  for j in range(W):
    if a[i][j] != 1:
      flag = False
      break
if flag:
  print("Yes")
else:
  print("No")
def solve(n, m, A, BC):
    A.sort()
    BC.sort(key=lambda bc: -bc[1])
    i = 0
    finished = False
    for b, c in BC:
        for j in range(b):
            if A[i + j] < c:
                A[i + j] = c
            else:
                finished = True
                break
        if finished:
            break
        i += b
        if i >= n:
            break
    return sum(A)

_n, _m = map(int, input().split())
_A = list(map(int, input().split()))
_BC = [list(map(int, input().split())) for _ in range(_m)]
print(solve(_n, _m, _A, _BC))

### FIXED CODE ###

def solve(n, m, A, BC):
    # https://atcoder.jp/contests/abc127/tasks/abc127_d
    A.sort()
    BC.sort(key=lambda bc: -bc[1])
    i = 0
    finished = False
    for b, c in BC:
        for j in range(b):
            if i + j >= n:
                finished = True
                break
            if A[i + j] < c:
                A[i + j] = c
            else:
                finished = True
                break
        if finished:
            break
        i += b
    return sum(A)

_n, _m = map(int, input().split())
_A = list(map(int, input().split()))
_BC = [list(map(int, input().split())) for _ in range(_m)]
print(solve(_n, _m, _A, _BC))
# E
import numpy as np
N = int(input()) 
A = list(map(int, input().split()))

lcm = np.lcm.reduce(A)

ans = 0
for i in A:
    ans += (lcm//i) % (10**9+7)

print(ans % (10**9+7))

### FIXED CODE ###

# E
from fractions import gcd

N = int(input()) 
A = list(map(int, input().split()))

value = 1
for a in A:
    value = value * a // gcd(value, a)

mod = 10**9+7

ans = 0
for i in A:
    ans += value // i

print(ans%mod)
#!/usr/bin/python3
# -*- coding:utf-8 -*-

import heapq
import numpy

def main():
  na, nb, nc, K = map(int, input().split())
  As = sorted(list(map(int, input().split())), reverse=True)
  Bs = sorted(list(map(int, input().split())), reverse=True)
  Cs = sorted(list(map(int, input().split())), reverse=True)
  
  scores = [(-(As[0]+Bs[0]+Cs[0]), 0, 0, 0)]
  used = numpy.zeros((na, nb, nc), dtype=numpy.int)
  used[0, 0, 0] = 1
  for _ in range(K):
    if len(scores) == 0:
      break
    (score, i, j, k) = heapq.heappop(scores)
    print(-score)
    if i + 1 < na and not used[i+1][j][k]:
      heapq.heappush(scores, (-(As[i+1]+Bs[j]+Cs[k]),   i+1, j,   k))
      used[i+1, j, k] = 1
    if j + 1 < nb and not used[i][j+1][k]:
      heapq.heappush(scores, (-(As[i]+Bs[j+1]+Cs[k]),   i,   j+1, k))
      used[i, j+1, k] = 1
    if k + 1 < nc and not used[i][j][k+1]:
      heapq.heappush(scores, (-(As[i]+Bs[j]+Cs[k+1]),   i,   j,   k+1))
      used[i, j, k+1] = 1

if __name__=='__main__':
  main()



### FIXED CODE ###

#!/usr/bin/python3
# -*- coding:utf-8 -*-

import heapq

def main():
  na, nb, nc, K = map(int, input().split())
  As = sorted(list(map(int, input().split())), reverse=True)
  Bs = sorted(list(map(int, input().split())), reverse=True)
  Cs = sorted(list(map(int, input().split())), reverse=True)
  
  scores = [(-(As[0]+Bs[0]+Cs[0]), 0, 0, 0)]
  used = [(0, 0, 0)]
  def push(i, j, k):
    heapq.heappush(scores, (-(As[i] + Bs[j] + Cs[k]), i, j, k))
    
  for _ in range(K):
    (score, i, j, k) = heapq.heappop(scores)
    print(-score)
    for di, dj, dk in [[1,0,0], [0,1,0], [0,0,1]]:
      if not (i+di < na and j+dj<nb and k+dk < nc):
        continue        
      if (i+di, j+dj, k+dk) not in used:
        push(i+di, j+dj, k+dk)
        used.append((i+di, j+dj, k+dk))

if __name__=='__main__':
  main()
MOD = 10 ** 9 + 7

def solve():
    N, M = map(int, input().split())
    A = [int(input()) for _ in range(M)]

    if M > 1:
        for i in range(M-1):
            if A[i]+1 == A[i+1]:
                return 0

    dp = [0] * (N+1)
    dp[1] = 0 if 1 in A else 1
    dp[2] = 0 if 2 in A else dp[1] + 1

    for i in range(3, N+1):
        if i in A:
            dp[i] = 0
        else:
            dp[i] = dp[i-1] + dp[i-2]

    return dp[N] % MOD

print(solve())

### FIXED CODE ###

MOD = 10 ** 9 + 7

def solve():
    N, M = map(int, input().split())
    A = [int(input()) for _ in range(M)]
    
    if N == 1 and M == 0:
        return 1
    elif N == 1 and M == 1 and A[0] == 0:
        return 0

    l = [1 for _ in range(N+1)]
    for a in A:
        l[a] = 0
        
    dp = [0 for i in range(N+1)]
    dp[1] = 0 if 1 in A else 1
    dp[2] = 0 if 2 in A else dp[1] + 1

    for i in range(3, N+1):
        if l[i] == 0:
            dp[i] = 0
        else:
            dp[i] = dp[i-1] + dp[i-2]
            dp[i] %= MOD

    return dp[N] % MOD

print(solve())
#生徒の人数を取得
N = int(input())
 
# 生徒の人数を3で割った商の小数点以下を切り捨てた数値を変数に格納
groupnum = math.floor(N / 3)
 
# 最大のグループ数の出力
print(groupnum)

### FIXED CODE ###

#生徒の人数を取得
N = int(input())
 
# 生徒人数を3で割った商の小数点を切り捨てた数値(最大のグループ数の出力)を変数に格納
print(N // 3)
def main():
    N = int(input())
    E = [set() for _ in range(N)]
    for _ in range(N - 1):
        a, b = [int(i) - 1 for i in input().split()]
        E[a].add(b)
        E[b].add(a)
    c = [0] * N
    clrs = max(len(i) for i in E)
    BAD = 1 << clrs - 1
    def color(n):
        t = set()
        for i in E[n]:
            t.add(c[i])
        for i in range(1, clrs + 1):
            if i in t:
                continue
            c[n] = i
            for j in E[n]:
                if c[j] == 0:
                    color(j)
            return
        raise
    color(0)
    print(clrs)
    for i in c:
        print(i)

main()


### FIXED CODE ###

import sys
sys.setrecursionlimit(10 ** 7)

def main():
    N = int(input())
    V = [set() for _ in range(N)]
    E = {}
    for j in range(N - 1):
        a, b = [int(i) - 1 for i in input().split()]
        V[a].add(j)
        V[b].add(j)
        E[(a, j)] = b
        E[(b, j)] = a
    C = [0] * (N - 1)
    clrs = max(len(i) for i in V)
    def color(n, p):
        for e in V[n]:
            if C[e] != 0:
                continue
            c = p + 1
            if c > clrs:
                c = 1
            C[e] = c
            color(E[(n, e)], c)
            p = c
    color(0, 0)
    print(clrs)
    for i in C:
        print(i)

main()
import math

def main():
    a, b = map(int, input().split())

    print(a*b//math.gcd(a, b))

if __name__ == '__main__':
    main()


### FIXED CODE ###

import fractions

def main():
    a, b = map(int, input().split())

    print(a*b//fractions.gcd(a, b))

if __name__ == '__main__':
    main()
while True:
    a, op, b = input().split()
    a, b = int(a), int(b)
    if op == '?':
        break
    elif op == '+':
        print(a+b)
    elif op == '-':
        print(a-b)
    elif op == '*':
        print(a*b)
    elif op == '/':
        print(a//b)

### FIXED CODE ###

import math 
r = float(input())
print(r*r*math.pi, 2*r*math.pi)
import sys
from itertools import combinations, permutations, product, combinations_with_replacement, accumulate
from heapq import heapify, heappop, heappush, heappushpop
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from math import sqrt, log, floor, ceil, factorial, cos, sin, pi, gcd
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
INF = float('inf')
LINF = 2**63-1
NIL = -LINF
MOD = 10**9+7
MGN = 4
def II(): return int(input())
def IF(): return float(input())
def IS(): return str(input())
def ILCI(n: int): return [II() for _ in range(n)]
def ILCF(n: int): return [IF() for _ in range(n)]
def ILI(): return list(map(int, input().split()))
def ILLI(n: int): return [[int(j) for j in input().split()] for i in range(n)]
def ILF(): return list(map(float, input().split()))
def ILLF(n: int): return [[float(j) for j in input().split()] for i in range(n)]
def LTOS(lst: list, sep: str = ' '): return sep.join(map(str, lst))
def DEC(lst: list): return list(map(lambda x: x-1, lst))
def INC(lst: list): return list(map(lambda x: x+1, lst))


def main():
    S = IS()

    ans = "Yes"
    if S[0] == S[1] and S[1] == S[2]:
        ans = "No"
    
    print(ans)


if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
INF = float('inf')
LINF = 2**63-1
NIL = -LINF
MOD = 10**9+7
MGN = 4
def II(): return int(input())
def IF(): return float(input())
def IS(): return str(input())
def ILCI(n: int): return [II() for _ in range(n)]
def ILCF(n: int): return [IF() for _ in range(n)]
def ILI(): return list(map(int, input().split()))
def ILLI(n: int): return [[int(j) for j in input().split()] for i in range(n)]
def ILF(): return list(map(float, input().split()))
def ILLF(n: int): return [[float(j) for j in input().split()] for i in range(n)]
def LTOS(lst: list, sep: str = ' '): return sep.join(map(str, lst))
def DEC(lst: list): return list(map(lambda x: x-1, lst))
def INC(lst: list): return list(map(lambda x: x+1, lst))


def main():
    S = IS()

    ans = "Yes"
    if S[0] == S[1] and S[1] == S[2]:
        ans = "No"
    
    print(ans)


if __name__ == '__main__':
    main()
import sys
input = sys.stdin.readline

n, m = map(int, input().split())
a = []
for _ in range(m):
    a.append(int(input()))

memo = {}


def step(now):
    if now in a:
        return 0
    # print(now)
    if now == n:
        return 1
    if now > n:
        return 0
    if now in memo.keys():
        return memo[now]
    memo[now] = step(now+1)+step(now+2)
    return memo[now]


print(step(0) % 1000000007)
# print(memo)

### FIXED CODE ###

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

n, m = map(int, input().split())
a = []
for _ in range(m):
    a.append(int(input()))
a=set(a)

memo = [0]*(n+1)
memo[0]=1
if not(1 in a):
    memo[1]=1

for i in range(2,n+1):
    #print(i)
    if i in a:
        continue
    #print(memo[i-1],memo[i-2])
    memo[i]=memo[i-2]+memo[i-1]
            

#print(memo)
print(memo[n]% 1000000007)
h,w=map(int,input().split())
if(h==1||w==1):
  print(1)
else:
  print(((w+1)//2)*((h+1)//2)+(w//2)*(h//2))

### FIXED CODE ###

h,w=map(int,input().split())
if(h==1 or w==1):
  print(1)
else:
  print(((w+1)//2)*((h+1)//2)+(w//2)*(h//2))
n,x = map(int,input().split())
l = list(map(int,input().split()))
i=0
suml=0
while suml<=x:
    suml=suml+l[i]
    i=i+1
print(i)

### FIXED CODE ###

n,x = map(int,input().split())
l = list(map(int,input().split()))
i=0
suml=0
if sum(l)<=x:
    print(len(l)+1)
else:
    while suml<=x:
        suml=suml+l[i]
        i=i+1
    print(i)
def next_num(n):
  if n%2:
    return 3*n+1
  else:
    return n/2

s = int(input())

n = s
for i in range(1000000):
  ind = [1,2,4].index(n)
  if n >= 0:
    print(ind+i+2)
    break
  n = next_num(n)


### FIXED CODE ###

def next_num(n):
  if n%2:
    return 3*n+1
  else:
    return n/2

s = int(input())

n = s
for i in range(1000000):
  if n in [1,2,4]:
    print(i+4)
    break
  n = next_num(n)