Harryxun/stf_run huggingface dataset:
n = len(S)

output = []
# prev = "R"
i = 0
while i < n:
    countR = 0
    countL = 0
    while i < n and S[i] == "R":
        countR += 1
        i += 1
    while i < n and S[i] == "L":
        countL += 1
        i += 1
    output += [0]*(countR-1) 
    if (countR + countL) % 2 == 0:
        output += [(countR + countL) // 2] * 2
    else:
        if countR < countL:
            output += [countL, countR]
        else:
            output += [countR, countL]
    output += [0]*(countL-1)
print(output)


### FIXED CODE ###

def main():
    S = input()
    n = len(S)
    i = 0
    res = []
    while i < len(S):
        countL, countR = 0, 0
        while i < n and S[i] == "R":
            countR += 1
            i += 1
        while i < n and S[i] == "L":
            countL += 1
            i += 1
        if (countL+countR) % 2 == 0:
            half = (countL+countR) // 2
            res += [0]*(countR-1) + [half]*2 + [0]*(countL-1)
        else:
            half1 = (countR+countL+1)//2
            half2 = (countR+countL) - half1
            if countR > countL:
                if (countR-1) % 2 == 0:
                    res += [0]*(countR-1) + [half1, half2] + [0]*(countL-1)
                else:
                    res += [0]*(countR-1) + [half2, half1] + [0]*(countL-1)
            else:
                if (countL-1) % 2 == 0:
                    res += [0]*(countR-1) + [half2, half1] + [0]*(countL-1)
                else:
                    res += [0]*(countR-1) + [half1, half2] + [0]*(countL-1)
    return res

if __name__ == '__main__':
    output = main()
    print(" ".join(map(str, output)))
s = int(input())
t = int(input())

from collections import Counter
SC = Counter(s)
TC = Counter(t)

SCV = SC.values()
TCV = TC.values()

SCV.sort()
TCV.sort()
ans = 1
for i in range(len(s)):
  if SCV[i] != TCV[i]:
    ans = 0

if ans == 1:
  print('Yes')
else:
  print('No')
    
    


### FIXED CODE ###

s=list(input())
t=list(input())
S=sorted(map(s.count,set(s)))
T=sorted(map(t.count,set(t)))
print("Yes" if S==T else "No")
s = input()
<_cnt = 0
>_cnt = 0
total = 0
for i in range(len(s)):
  if s[i] == '<' and >_cnt == 0:
    <_cnt += 1
  elif s[i] == '<' and >_cnt > 0:
    k = max(<_cnt, >_cnt)
    l = min(<_cnt, >_cnt)
    total += (k+1)*k//2 + l*(l-1)//2
    <_cnt = 1
    >_cnt = 0
  elif s[i] == '>':
    >_cnt += 1
k = max(<_cnt, >_cnt)
l = min(<_cnt, >_cnt)
total += (k+1)*k//2 + l*(l-1)//2
print(total)
    


### FIXED CODE ###

s = input()
right_cnt = 0
left_cnt = 0
total = 0
for i in range(len(s)):
  if s[i] == '<' and left_cnt == 0:
    right_cnt += 1
  elif s[i] == '<' and left_cnt > 0:
    k = max(right_cnt, left_cnt)
    l = min(right_cnt, left_cnt)
    total += (((k+1)*k) + (l*(l-1)))//2
    right_cnt = 1
    left_cnt = 0
  elif s[i] == '>':
    left_cnt += 1
k = max(right_cnt, left_cnt)
l = min(right_cnt, left_cnt)
total += (((k+1)*k) + (l*(l-1)))//2
print(total)
n = int(input())
a = int(input())
b = int(input())

if a == 1:
  print('Hello World')
else:
  print(a+b)

### FIXED CODE ###

n = int(input())

if n == 1:
  print('Hello World')
else:
  a = int(input())
  b = int(input())
  print(a+b)
import math
import os
import sys

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")

N, X = list(map(int, sys.stdin.readline().split()))
S = list(map(int, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7

S.sort()


# @lru_cache(maxsize=None)
# def test2(x, si):
#     # S[si] を最初にとったとき、最終的な数値の期待値
#     if si == 0:
#         return x % S[si]
# 
#     ret = 0
#     for j in range(si):
#         ret += test2(x % S[si], si=j)
#     return ret / si


# dp = np.zeros((N, X + 1))
# dp[0] = np.arange(X + 1) % S[0]
# for i in range(1, N):
#     for x in range(X + 1):
#         dp[i][x] = np.mean(dp[:i, x % S[i]])
# print(dp[:, X].sum() * math.factorial(N) / N % MOD)


dp = np.arange(X + 1) % S[0]
for i in range(1, N):
    dp += dp[np.arange(X + 1) % S[i]] / i
print(dp[X] * math.factorial(N) / N % MOD)


### FIXED CODE ###

import math
import os
import sys

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")

N, X = list(map(int, sys.stdin.readline().split()))
S = list(map(int, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7


def mod_invs(max, mod):
    """
    逆元のリスト 0 から max まで
    :param max:
    :param mod:
    :return:
    """
    invs = [1] * (max + 1)
    for x in range(2, max + 1):
        invs[x] = (-(mod // x) * invs[mod % x]) % mod
    return invs


S.sort()

invs = mod_invs(N, MOD)
dp = np.arange(X + 1) % S[0]
for i in range(1, N):
    dp += dp[np.arange(X + 1) % S[i]] * invs[i]
    dp %= MOD
print(int(dp[X] * math.factorial(N) % MOD * invs[N] % MOD))
#配列の準備
＃インプット分を数値型に変換後、スプリットで各変数に持たせる

a,b,c,d=map(int,input().split())  

＃abs関数で引数を絶対値とする。
if abs(c-a)>d:  
  if abs(a-b)>d or abs(b-c)>d:  
    print("No")  
  else:  
    print("Yes")  
else:  
  print("Yes")  

### FIXED CODE ###

#配列の準備
# ンプット分を数値型に変換後、スプリットで各変数に持たせる

a,b,c,d=map(int,input().split())
# abs関数で引数を絶対値とする。

if abs(c-a)>d:
  if abs(a-b)>d or abs(b-c)>d:
    print("No")
  else:
    print("Yes")
else:
  print("Yes")
N = int(input())
listN = sorted(N)
if listN.count(7) >= 1:
    print("Yes")
else:
    print("No")


### FIXED CODE ###

N = int(input())
listN = sorted(str(N))
if listN.count("7") >= 1:
    print("Yes")
else:
    print("No")
number = input()
print("%d",number**3)

### FIXED CODE ###

number = int(input())
print(number**3)
import sys
import time
import math
import itertools as it
def inpl():
    return list(map(int, input().split()))
st = time.perf_counter()
# ------------------------------

N, M = inpl()
H = inpl()
dp = [True] * M
for _ in range(M):
    A, B = inpl()
    if H[A-1] > H[B-1]:
        dp[B-1] = False
    elif H[A-1] < H[B-1]:
        dp[A-1] = False
    else:
        dp[A-1] = False
        dp[B-1] = False
ans = 0
for i in dp:
    if i == True:
        ans += 1
print(ans)

# ------------------------------
ed = time.perf_counter()
print('time:', ed-st, file=sys.stderr)


### FIXED CODE ###

import sys
import time
import math
import itertools as it
def inpl():
    return list(map(int, input().split()))
st = time.perf_counter()
# ------------------------------

N, M = inpl()
H = inpl()
dp = [True] * N
for _ in range(M):
    A, B = inpl()
    if H[A-1] > H[B-1]:
        dp[B-1] = False
    elif H[A-1] < H[B-1]:
        dp[A-1] = False
    else:
        dp[A-1] = False
        dp[B-1] = False
ans = 0
for i in dp:
    if i:
        ans += 1
print(ans)

# ------------------------------
ed = time.perf_counter()
print('time:', ed-st, file=sys.stderr)
import math
N = int(input())
print(math.veil(N/2))

### FIXED CODE ###

import math
N = int(input())
print(math.ceil(N/2))
#!/usr/bin/env python3

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

def gcd(n,m):
    if m == 0:
        return n
    else:
        return gcd(m,n%m)

def lcm(n,m):
    return n*m//gcd(n,m)

n,m = LI()
a = LI()
b = [i//2 for i in a]
for i in range(n):
    if b[i] % 2 == 0:
        print(0)
        quit()

la = lcm(a[0],a[1])
lb = lcm(b[0],b[1])
for i in range(2,n):
    la = lcm(la,a[i])
    lb = lcm(lb,b[i])


if lb > m:
    print(0)
else:
    ans = (m-lb)//la+1
    print(ans)

### FIXED CODE ###

#!/usr/bin/env python3

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

def gcd(n,m):
    if m == 0:
        return n
    else:
        return gcd(m,n%m)

def lcm(n,m):
    return n*m // gcd(n,m)


n,m = LI()
a = LI()
b = [i//2 for i in a]

lb = 1
for i in b:
    lb = lcm(lb,i)
    if lb > m:
        print(0)
        quit()

for i in b:
    if lb//i % 2 == 0:
        ans = 0
        break
else:
    if lb > m:
        ans = 0
    else:
        ans = (m//lb + 1)//2
print(ans)
from collections import defaultdict as de
s=de(int)
n=int(input())
a=sorted([list(map(int,input().split()))+[0]for i in range(n)])
for i in range(n):
    for j in range(n):
        if i!=j:
            s[(a[i][0]-a[j][0],a[i][1]-a[j][1])]+=1
print(n-max(s.values()))


### FIXED CODE ###

from collections import defaultdict as de
s=de(int)
n=int(input())
a=sorted([list(map(int,input().split()))for i in range(n)])
for i in range(n):
    for j in range(i):
        s[(a[i][0]-a[j][0],a[i][1]-a[j][1])]+=1
print(n-max(s.values(),default=0))
num = int(input())
List = input().split(" ")
height = [int(n) for n in List]
dp = [0 for n in range(10 ** 5 * 2)]
a = 0
while dp[num-1] == 0:
  a+= 1
  if a == 1:
    dp[a] = abs(height[a]-height[a-1])
  else:
    dp[a] = min(abs(height[a]-height[a-1])+dp[a-1],abs(height[a]-height[a-2])+dp[a-2])
print(dp[num-1])

### FIXED CODE ###

num = int(input())
List = input().split(" ")
height = [int(n) for n in List]
dp = [0 for n in range(10 ** 5 * 2)]
a = 0
while dp[num-1] == 0:
  a+= 1
  if a == num:
    break
  if a == 1:
    dp[a] = abs(height[a]-height[a-1])
  else:
    dp[a] = min(abs(height[a]-height[a-1])+dp[a-1],abs(height[a]-height[a-2])+dp[a-2])
print(dp[num-1])
N = int(input())
edge = [[] for _ in range(N)]
cnt = [[0,i] for i in range(N)]

for i in range(N-1):
    a, b = map(int, input().split())
    a, b = a-1, b-1
    edge[a].append(b)
    edge[b].append(a)
    cnt[a][0] += 1
    cnt[b][0] += 1

cnt.sort()
C = list(map(int, input().split()))
C.sort()
nodes = [0] * N
for idx, (c, i) in enumerate(cnt):
    nodes[i] = C[idx]

#print(nodes)

ans = []

def dfs(v, pv, w):
    ans.append(min(w, nodes[v]))
    for nv in edge[v]:
        if pv == nv: continue
        dfs(nv, v, nodes[v])

dfs(0, 0, 0)
print(sum(ans))
print(*nodes, sep=" ")


### FIXED CODE ###

import sys
sys.setrecursionlimit(10**9)

N = int(input())
edge = [[] for _ in range(N)]
cnt = [[0,i] for i in range(N)]

for i in range(N-1):
    a, b = map(int, input().split())
    a, b = a-1, b-1
    edge[a].append(b)
    edge[b].append(a)
    cnt[a][0] += 1
    cnt[b][0] += 1


cnt.sort(reverse=True)
start = cnt[0][1]
C = list(map(int, input().split()))
C.sort(reverse=True)
nodes = [0] * N

#print(nodes)
cidx = -1
ans = []
def dfs(v, pv, w):
    global cidx
    cidx += 1
    nodes[v] = C[cidx]
    ans.append(min(w, C[cidx]))
    for nv in edge[v]:
        if pv == nv: continue
        dfs(nv, v, C[cidx])

dfs(start, 0, 0)
print(sum(ans))
print(*nodes, sep=" ")
a, b, c, d = map(int, input().split())
print(max(min(b, d) - max(a, c), 0))

### FIXED CODE ###

a, b, c, d = map(int, input().split())
if a < c:
        if b < c:
                print(0)
        if c <= b <= d:
                print(abs(b-c))
        if d < b:
                print(abs(d-c))
if c <= a:
        if d < a:
                print(0)
        if a <= d <= b:
                print(abs(d-a))
        if b < d:
                print(abs(b-a))
a=raw_input().split()
if a[0]<a[1]:
    print("a < b")
elif a[0]>a[1]:
    print("a > b")
else:
    print("a == b")


### FIXED CODE ###

a,b=map(int,input().split())
if a<b:
    print("a < b")
elif a>b:
    print("a > b")
else:
    print("a == b")
N, A, B = [int(n) for n in input().split()]
if A == 0:
    print(0)
else:
    C = [1]*A+[0]*B
    ans = C*(N//(A+B))+C[:N%(A+B)]
    print(sum(ans))

### FIXED CODE ###

N, A, B = [int(n) for n in input().split()]
if A == 0:
    print(0)
else:
    C, D = divmod(N, A+B)
    print(A*C+min(A, D))
#!/usr/bin/env python3

def main():
    n, q = map(int, input().split())
    adj = [[] for i in range(n)]
    for i in range(n - 1):
        a, b = map(int, input().split())
        adj[a - 1].append(b - 1)
        adj[b - 1].append(a - 1)
    add_node = [0 for i in range(n)]
    for i in range(q):
        p, x = map(int, input().split())
        add_node[p - 1] += x
    counter = [0 for i in range(n)]
    visited = [False for i in range(n)]
    dfs(0, adj, visited, counter, 0, add_node)
    print(" ".join(str(x) for x in counter))

def dfs(i, adj, visited, counter, add, add_node):
    visited[i] = True
    add += add_node[i]
    counter[i] += add
    for j in adj[i]:
        if not visited[j]:
            dfs(j, adj, visited, counter, add, add_node)

if __name__ == "__main__":
    main()


### FIXED CODE ###

#!/usr/bin/env python3

import sys

def dfs(i, p, add):
    add += add_node[i]
    counter[i] += add
    for j in adj[i]:
        if j != p:
            dfs(j, i, add)

sys.setrecursionlimit(10 ** 6)
n, q = map(int, input().split())
adj = [[] for i in range(n)]
for i in range(n - 1):
    a, b = map(int, sys.stdin.readline().split())
    adj[a - 1].append(b - 1)
    adj[b - 1].append(a - 1)
add_node = [0 for i in range(n)]
for i in range(q):
    p, x = map(int, sys.stdin.readline().split())
    add_node[p - 1] += x
counter = [0 for i in range(n)]
dfs(0, -1, 0)
print(" ".join(str(x) for x in counter))
N = int(input())
q = [0]*11
i = 10
n = N
cflag = 0
str = []
while i != -1:
    q[i] = n // 26 ** i
    mod = n % 26 ** i
    n = mod
    i -= 1
for i in range(11):
    if q[i] == 0 and q[i+1] == 0:
        break
    elif q[i] == 0:
        str.append("z")
        cflag = 1
    elif q[i] == 1 and q[i+1] == 0 and cflag == 1:
        break
    elif q[i] == 1 and cflag == 1:
        str.append ("z")
    else:
        str.append(chr(q[i] + 96 -cflag))
        cflag = 0

i = len(str) -1
while i >= 0:
    if[str] == '':
        i-=1
        continue
    elif i == 0:
        print(str[i])
        break
    else:
        print(str[i], end="")
        i -= 1



### FIXED CODE ###

N = int(input())
q = [0]*13
i = 10
n = N
cflag = 0
zflag = 0
str = []
while i != -1:
    q[i] = n // 26 ** i
    mod = n % 26 ** i
    n = mod
    i -= 1
for i in range(12):
    if q[i] == 0:
        zflag = 1
        for j in range(i,13) :
            if q[j] != 0:
                zflag = 0
                break
        if zflag == 1:
             break
        elif cflag == 1:
            str.append("y")
            cflag = 1
        else:
            str.append("z")
            cflag = 1
    elif q[i] == 1 and cflag == 1:
        zflag = 1
        for j in range(i+1,13):
            if q[j] != 0:
                zflag = 0
                break
        if zflag == 1:
            break
        else:
            str.append ("z")
            cflag = 1
    else:
        str.append(chr(q[i] + 96 -cflag))
        cflag = 0

i = len(str) -1
while i >= 0:
    if[str] == '':
        i-=1
        continue
    elif i == 0:
        print(str[i])
        break
    else:
        print(str[i], end="")
        i -= 1
N, M = map(int, input().split())
has_broken = [True, True, False] + [False for _ in range(N)]
prev_a = int(input())
has_broken[prev_a+2] = True
for _ in range(M-1):
    a = int(input())
    has_broken[a+2] = True


# dp[i] := i段目にたどり着く移動方法の総数
# 一歩で1段か2段上れるのだから、dp[i]は前段と前々段へたどり着く方法の和
# dp[i] = dp[i-1] + dp[i-2]
# dp配列は-1段目と-2段目の分大きくなっています
dp = [0 for _ in range(N+3)]
# 一段目初期化
dp[2] = 1

for i in range(2, N+3):
    if not has_broken[i]:
        dp[i] += dp[i-1] + dp[i-2]

print(dp[N+2]%1000000007)

### FIXED CODE ###

import sys


input = sys.stdin.readline

N, M = map(int, input().split())
has_broken = [1]*(N+1)
for _ in range(M):
    has_broken[int(input())] = 0

dp = [1]*(N+1)
dp[1] = 1 if has_broken[1] == 1 else 0
MOD = 10**9+7
for i in range(2, N+1):
    dp[i] = has_broken[i]*(dp[i-1] + dp[i-2])

print(dp[N]%MOD)
s = input()
t = input()
print(t+s)

### FIXED CODE ###

s, t = input().split()
print(t+s)
A,B,K = map(int, raw_input().split())
  
for i in range(A,B+1):
    if (i >= A and i <= A + K - 1) or (i >= B - K + 1 and i <= B):
        print(i)
        

### FIXED CODE ###

A,B,K = map(int, raw_input().split())
  
for i in range(K):
    if A + i >= A and A + i <= B:
        print(A + i)
for i in range(K):
    if B - K + 1 + i >= A and B - K + 1 + i <= B and B - K + 1 + i > A + K -1:
        print(B - K + 1 + i)
#ABC063C
N = int(input())
s = [int(input()) for _ in range(N)]
ans = -1
s.sort()
for _ in range(N+1):
    ans = sum(s)
    if ans % 10 != 0:
        ans = max(ans, sum(s))
        break
    else:
        if (ans - s[0])%10 == 0:
            s.pop(1)
        else:
            s.pop(0)
        if len(s) == 0:
            ans = 0
            break
print(ans)

### FIXED CODE ###

#ABC063C
N = int(input())
s = [int(input()) for _ in range(N)]
ans = -1
s.sort()
for _ in range(N+1):
    ans = sum(s)
    if ans % 10 != 0:
        break
    elif len(s) == 0:
        ans = 0
        break
    elif len(s) >= 2:
        del_ok = False
        for i in range(1, len(s)):
            if s[0]%10 == 0 and s[i]%10 != 0:
                s.pop(i)
                del_ok = True
                break
        if not del_ok:
            s.pop(0)
    else:
        s.pop(0)
print(ans)
c = t - a - b
d = t - a - g
f = t - d - e
i = t - g - h

print("{} {} {}".format(a,b,c))
print("{} {} {}".format(d,e,f))
print("{} {} {}".format(g,h,i))


### FIXED CODE ###

# A B c
# d E f
# g h i

a = int(input())
b = int(input())
e = int(input())
g = a + b - e
h = a + e - g
t = b + e + h
c = t - a - b
d = t - a - g
f = t - d - e
i = t - g - h
print("{} {} {}".format(a,b,c))
print("{} {} {}".format(d,e,f))
print("{} {} {}".format(g,h,i))
n, k = map(int, input().split())
d_list = []
A_list  =[]
nuske = np.zeros(n)
print(nuske)
import numpy as np
for _ in range(k): 
    d = input()
    a = list(map(int, input().split()))
    for i in a:
        nuske[i-1] +=1

p =0

for i in range(len(nuske)):
    if nuske[i] ==0:
        p+=1

print(p)


### FIXED CODE ###

n, k = map(int, input().split())
A_list  =[]
import numpy as np
nuske = np.zeros(n)

for _ in range(k): 
    d = input()
    a = list(map(int, input().split()))
    for i in a:
        nuske[ i-1] +=1

p =0

for i in range(len(nuske)):
    if nuske[i] ==0:
        p+=1

print(p)
if int(input())>=8 and int(input())>=8: print('Yay!')
else: print(':(')

### FIXED CODE ###

a,b = list(map(int, input().split()))
if a<=8 and b<=8: print('Yay!')
else: print(':(')
s=input()
count=0
for i in range(len(s)):
  if s[i]=='R':
    count+=1
    max1=count
  elif s[i]=='S':
    count=0
print(max1)

### FIXED CODE ###

s=input()
count=0
max=0
for i in range(len(s)):
  if s[i]=='R':
    count+=1
    max=count
  elif s[i]=='S':
    count=0
      
print(max)
n=int(input())
l=list(map(int, input().split()))
l=sorted([x for x in set(l) if l.count(x)<4])
ans=0
x=[]
for i in range(n):
    for j in range(i+1,n):
        for k in range(j+1,(n-sum((x>l[j]+l[i]) for x in l))):
            if (l[i]<(l[j]+l[k])and l[j]<(l[i]+l[k]) and x.count([l[i],l[j],l[k]])==0):
                x.append([l[i],l[j],l[k]])
                ans+=1

print(ans)


### FIXED CODE ###

def triangles(a): 
    n = len(a) 
    a.sort() 
    count = 0
    for i in range(0,n-2):
        k=i+2
        for j in range(i+1,n): 
            while (k < n and a[i] + a[j] > a[k]): 
                k += 1
            if(k>j): 
                count += k - j - 1
    return count
n=int(input())
a=list(map(int,input().split()))
print(triangles(a))
import math


def get_inputs():
    inputs = input().split(" ")
    monsters_num, diff, attack = int(inputs[0]), int(inputs[1]), int(inputs[2])
    monsters = []
    for monster in range(monsters_num):
        inputs = input().split(" ")
        coordinate, health = int(inputs[0]), int(inputs[1])
        monsters.append({"coordinate": coordinate, "health": health})
    return monsters, diff, attack, monsters_num


def between_coordinates(monster, coordinate, diff):
    if (coordinate - diff <= monster["coordinate"] <= coordinate) or (
            coordinate <= monster["coordinate"] <= coordinate + diff):
        return True
    return False


def sort_monsters_coordinates(monsters):
    return sorted(monsters, key=lambda k: k['coordinate'])


def get_alive_monsters(monsters):
    return [monster for monster in monsters if monster["health"] > 0]


def attack_leftmost_monster(coordinate, monsters, attack, diff):
    bombs_num = 0
    if len(monsters) == 0:
        return 0
    leftmost_monster = monsters.pop(0)
    needed_attacks = math.ceil(leftmost_monster["health"] / attack)
    bombs_num += needed_attacks
    for monster in monsters:
        if between_coordinates(monster, coordinate, diff):
            monster["health"] -= (needed_attacks * attack)
    monsters = get_alive_monsters(monsters)
    return monsters, bombs_num


def get_max_health(monsters):
    if len(monsters) == 0:
        return 0

    max_health = - math.inf
    for monster in monsters:
        if monster["health"] >= max_health:
            max_health = monster["health"]
    return max_health


monsters, diff, attack, monsters_num = get_inputs()
if len(monsters) > 0:
    monsters = sort_monsters_coordinates(monsters)
else:
    print(0)

coordinate = monsters[0]["coordinate"] + diff
total_bombs_num = 0

while len(monsters) > 0 and coordinate <= monsters[-1]["coordinate"] - diff:
    monsters, bombs_num = attack_leftmost_monster(coordinate, monsters, attack, diff)
    total_bombs_num += bombs_num
    if len(monsters) > 0:
        coordinate = monsters[0]["coordinate"] + diff
        
print(total_bombs_num + math.ceil(get_max_health(monsters) / attack))

### FIXED CODE ###

from sys import stdin
import math

def main():
    H,A = map(int,stdin.readline().split())
    res = H/A
    print(math.ceil(res))
main()
A,B,C,D=map(int,input().split())
if A<=C:
  if D<=B:
    t=B-C
  else:
    t=D-C
else:
  if D<=B:
    t=B-A
  else:
    t=D-A
  t=D-A
if t<=0:
  print(0)
else:
  print(t)

### FIXED CODE ###

N=int(input())
if N==1:
  print('Hello World')
  exit()
else:
  A=int(input())
  B=int(input())
  print(A+B)
c=list(map(int, input().split()))
c = str(c)
c = c.find(0)
print(c)

### FIXED CODE ###

c=list(map(int, input().split()))
for i in range(len(c)):
    if(c[i]==0):
        a = i+1
        print(a)
import math
def calc_pattern(stairs):
    if stairs<=4:
        return stairs
    d=stairs//2+1
    l=[(math.factorial(i+(stairs-i*2))/math.factorial(i)/math.factorial(stairs-i*2))%1000000007  for i in range(d)]
    return (sum(l))%1000000007

N,M=map(int,input().split())
A=[-1]
A.extend([int(input()) for m in range(M)])
A.append(N+1)

s=1
for m in range(M+1):
    if A[m+1]==1 or A[m+1]==N-1:
        continue
    if A[m]+1==A[m+1]:
        print(0)
        exit()
    else:
        s*=calc_pattern(A[m+1]-1 - (A[m]+1))
        s%=1000000007
print(int(s))


### FIXED CODE ###

N,M=map(int,input().split())
A=[int(input()) for n in range(M)]
S=[1]*(N+1)
for a in A:
  S[a]=0
for i in range(2,N+1):
  S[i]=(S[i-1]+S[i-2])%1000000007*S[i]

print(S[-1])