Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
N,M = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
li = [0] * M
for i in range(M):
    B,C = [int(j) for j in input().split()]
    li[i] = [C,B]
li.sort()
li.reverse()
A.sort()
Ba = [0] * M
for i in range(M):
    Ba[i] = li[i][1]
from numpy import cumsum
from bisect import bisect_left
B_sum = list(cumsum(Ba))
count = B_sum[-1]
N = min(N,count)
for i in range(N):
    indexa = bisect_left(B_sum,i+1)
    if A[i] >= li[indexa][0]:
        break
    if A[i] < li[indexa][0]:
        A[i] = li[indexa][0]
print(sum(A))

Fixed submission:
n, m = map(int, input().split())
A = list(map(int, input().split()))
A = sorted(A)

cb_dict = {}
for _ in range(m):
    b, c = map(int, input().split())
    new = {c:b}
    if c in cb_dict.keys():
        cb_dict[c] += b
    else:
        cb_dict.update(new)

cb_dict = sorted(cb_dict.items(), key=lambda x:x[0], reverse=True)

now_c = 0
now_b = 0
for i in range(n):
    if A[i] >= cb_dict[now_c][0]:
        break
    else:
        A[i] = cb_dict[now_c][0]
        now_b += 1
        if now_b == cb_dict[now_c][1]:
            now_c += 1
            now_b = 0
        if now_c > len(cb_dict)-1:
            break

ans = sum(A)
print(ans)

Buggy python submission (verdict: Time Limit Exceeded):
N,M = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
A.sort()
li = [0] * M
for i in range(M):
    B,C= [int(j) for j in input().split()]
    lia = [C,B]
    li[i] = lia
li.sort()
seq = []
for i in range(M):
    lia = [li[i][0] for _ in range(li[i][1])]
    seq += lia
for i in range(min(N,len(seq))):
    k = (i+1)* (-1)
    if A[i] >= seq[k]:
        break
    else:
        A[i] = seq[k]
print(sum(A))

Fixed submission:
n, m = map(int, input().split())
A = list(map(int, input().split()))
A = sorted(A)

cb_dict = {}
for _ in range(m):
    b, c = map(int, input().split())
    new = {c:b}
    if c in cb_dict.keys():
        cb_dict[c] += b
    else:
        cb_dict.update(new)

cb_dict = sorted(cb_dict.items(), key=lambda x:x[0], reverse=True)

now_c = 0
now_b = 0
for i in range(n):
    if A[i] >= cb_dict[now_c][0]:
        break
    else:
        A[i] = cb_dict[now_c][0]
        now_b += 1
        if now_b == cb_dict[now_c][1]:
            now_c += 1
            now_b = 0
        if now_c > len(cb_dict)-1:
            break

ans = sum(A)
print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
#template
def inputlist(): return [int(j) for j in input().split()]
from collections import Counter
#template
#issueから始める
R,G,B,N = inputlist()
ans = 0
for r in range(N//R + 1):
    for g in range(N//G + 1):
        b = N -(r*R+g*G)
        if b < 0:
            continue
        if b % B == 0:
            ans +=1
print(ans)

Fixed submission:
#template
def inputlist(): return [int(j) for j in input().split()]
from collections import Counter
#template
#issueから始める
R,G,B,N = inputlist()
ans = 0
for r in range(N//R + 1):
    for g in range(N//G + 1):
        b = N -(r*R+g*G)
        if b < 0:
            continue
        if b % B == 0:
            ans +=1
print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
#template
def inputlist(): return [int(k) for k in input().split()]
#template
H,W = inputlist()
graph = [0]*H
for i in range(H):
    graph[i] = list(input())
from collections import deque
que = deque()
seen = [[False]*W for _ in range(H)]
li = []
for x in range(H):
    for y in range(W):
        if graph[x][y] == '#':
            tp = (x,y)
            li.append(tp)
que.append(li)
dx = [1,0,-1,0]
dy = [0,1,0,-1]
count = 0
while len(que) != 0:
    l = que.popleft()
    lis = []
    for tup in l:
        xa = tup[0]
        ya = tup[1]
        for i in range(4):
            nx = xa + dx[i]
            ny = ya + dy[i]
            if nx >= H or ny >= W or nx < 0 or ny < 0:
                continue
            if graph[nx][ny] == '#':
                continue
            graph[nx][ny] = '#'
            lis.append((nx,ny))
    count+=1
    if len(lis) == 0:
        print(count-1)
        exit()
    que.append(lis)


Fixed submission:
#template
def inputlist(): return [int(k) for k in input().split()]
#template
H,W = inputlist()
graph = [0]*H
for i in range(H):
    graph[i] = list(input())
from collections import deque
que = deque()
seen = [[False]*W for _ in range(H)]
li = []
for x in range(H):
    for y in range(W):
        if graph[x][y] == '#':
            tp = (x,y)
            li.append(tp)
que.append(li)
dx = [1,0,-1,0]
dy = [0,1,0,-1]
count = 0
while len(que) != 0:
    l = que.popleft()
    lis = []
    for tup in l:
        xa = tup[0]
        ya = tup[1]
        for i in range(4):
            nx = xa + dx[i]
            ny = ya + dy[i]
            if nx >= H or ny >= W or nx < 0 or ny < 0:
                continue
            if graph[nx][ny] == '#':
                continue
            graph[nx][ny] = '#'
            lis.append((nx,ny))
    count+=1
    if len(lis) == 0:
        print(count-1)
        exit()
    que.append(lis)
Buggy python submission (verdict: Time Limit Exceeded):
import sys
input = sys.stdin.readline
N,W = [int(i) for i in input().split()]
weight = [0] * N
value= [0] * N
for i in range(N) :
    w,v = [int(i) for i in input().split()]
    value[i] = v
    weight[i] = w
dp = [[0] * (W+1) for _ in range(N+1)]
for i in range(N):
    for w in range(W+1) :
        if w >= weight[i] :
            dp[i+1][w] = max(dp[i][w-weight[i]]+value[i],dp[i][w])
        else :
            dp[i+1][w] = dp[i][w]
print(dp[N][W])

Fixed submission:
import sys
input = sys.stdin.readline
import numpy as np
N, W = map(int, input().split())
w, v = [], []
for i in range(N):
    a, b = map(int, input().split())
    w += [a]
    v += [b]

DP = np.zeros(W+1, dtype=int)
# i 円以下で買える商品の最大価値
for i in range(N):
    DP[w[i]:] = np.maximum(DP[:-w[i]]+ v[i], DP[w[i]:])
print(DP[-1])
Buggy python submission (verdict: Runtime Error):
def divisore(n):
    divisors=[]
    for i in range(1,int(n**0.5)+1):
        if n%i==0:
            divisors.append(i)
            if i!=n//i:
                divisors.append(n//i)
    divisors.sort(reverse=True)
    return divisors

n,m=map(int,input().split())
l=divisore(m)
for i in l:
  if m/n>=i:
  print(i)
  exit()

Fixed submission:
def divisore(n):
    divisors=[]
    for i in range(1,int(n**0.5)+1):
        if n%i==0:
            divisors.append(i)
            if i!=n//i:
                divisors.append(n//i)
    divisors.sort(reverse=True)
    return divisors

n,m=map(int,input().split())
l=divisore(m)
for i in l:
 if m//n>=i:
  print(i)
  exit()
Buggy python submission (verdict: Runtime Error):
import sys
import itertools
import numpy
input = sys.stdin.readline
Sa = input()
Ta = input()
S = ['0'] * len(Sa)
T = ['0'] * len(Ta)
for i in range(len(Sa)) :
    S[i] = Sa[i]
for i in range(len(Ta)) :
    T[i] = Ta[i]
ans = {}
for cs,ct in zip(S,T) :
    if cs not in ans.keys() and ct not in ans.values() :
        ans[cs] = ct
    else :
        if ans[cs] == ct :
            continue
        else :
            print("No")
            break
else :
    print("Yes")

Fixed submission:
import sys
import itertools
import numpy
input = sys.stdin.readline
Sa = input()
Ta = input()
S = ['0'] * len(Sa)
T = ['0'] * len(Ta)
for i in range(len(Sa)) :
    S[i] = Sa[i]
for i in range(len(Ta)) :
    T[i] = Ta[i]
ans = {}
for cs,ct in zip(S,T) :
    if cs not in ans.keys() and ct not in ans.values() :
        ans[cs] = ct
    else :
        try :
            if ans[cs] == ct :
                continue
            else :
                print("No")
                break
        except KeyError :
            print("No")
            break
else :
    print("Yes")
Buggy python submission (verdict: Runtime Error):
N = int(input())
li = []
w = input()
li.append(w)
k = 0
ans = "Yes"
for i in range(N) :
    word = input()
    for j in range(len(li)) :
        if li[j] == word :
            k = 1
            break
    last_word = li[-1]
    if last_word[-1] != word[0] :
        k = 1
    if k == 1 :
        ans = "No"
        break
    li.append(word)
print(ans)

Fixed submission:
N = int(input())
li = []
w = input()
li.append(w)
k = 0
ans = "Yes"
for i in range(N-1) :
    word = input()
    for j in range(len(li)) :
        if li[j] == word :
            k = 1
            break
    last_word = li[-1]
    if last_word[-1] != word[0] :
        k = 1
    if k == 1 :
        ans = "No"
        break
    li.append(word)
print(ans)
Buggy python submission (verdict: Runtime Error):
N,X = [int(i) for i in input().split()]
xa = [int(i) for i in input().split()]
from math import gcd
lia = [0]*N
for i in range(N):
    lia[i] = abs(X-xa[i])
ans = lia[0]
for i in range(1,N):
    ans = gcd(ans,lia[i])
print(ans)

Fixed submission:
import fractions
N,X = map(int,input().split())
x = list(map(int,input().split()))
distance = []
for i in range(N) :
    d = abs(x[i] - X)
    distance.append(d)
s = 1000000001
if N == 1 :
    s = distance[0]
else :
    for i in range(0,N-1) :
        s = min(fractions.gcd(distance[i],distance[i+1]),s)
print(s)

Buggy python submission (verdict: Runtime Error):
N,X = [int(i) for i in input().split()]
xa = [int(i) for i in input().split()]
from math import gcd
lia = [0]*N
for i in range(N):
    lia[i] = abs(X-xa[i])
ans = lia[0]
for i in range(1,N):
    ans = gcd(ans,lia[i])
print(ans)

Fixed submission:
import fractions
N,X = map(int,input().split())
x = list(map(int,input().split()))
distance = []
for i in range(N) :
    d = abs(x[i] - X)
    distance.append(d)
s = 1000000001
if N == 1 :
    s = distance[0]
else :
    for i in range(0,N-1) :
        s = min(fractions.gcd(distance[i],distance[i+1]),s)
print(s)
Buggy python submission (verdict: Runtime Error):
S = input()
K = int(input())
if S[0] == '1':
    print(S[1])
else :
    print(S[0])

Fixed submission:
s, k = input(), int(input())
ans = "1"
for i in range(k):
    if s[i]!="1":
        ans = s[i]
        break
print(ans)
Buggy python submission (verdict: Runtime Error):
import sys
import itertools
import numpy
input = sys.stdin.readline
N = int(input())
li = [int(i) for i in input().split()]
sum = 0
for i in range(N) :
    sum += li[i]- 1
print(sum)

Fixed submission:
import sys
import itertools
import numpy
input = sys.stdin.readline
N = int(input())
li = [int(i) for i in input().split()]
sum = 0
for i in range(N) :
    sum += li[i]- 1
print(sum)
Buggy python submission (verdict: Time Limit Exceeded):
def func(li,b) :
    sum = 0
    for i in range(len(li)) :
        sum+= abs(li[i] - b - i - 1)
    return sum
def binary_search(li) :
    left = -1000000001
    right = 1000000001
    while right - left > 1 :
        med = (right + left) // 2
        x = func(li,med)
        mdx = func(li,med-1)
        pdx = func(li,med+1)
        if mdx > x and pdx < x :
            left = med
            continue
        elif mdx < x and pdx > x :
            right = med
            continue
        elif mdx >= x and pdx >= x :
            return x
    else :
        return -1
import sys
input = sys.stdin.readline
N = int(input())
A =[int(i) for i in input().split()]
print(binary_search(A))

Fixed submission:
def func(li,b) :
    sum = 0
    for i in range(len(li)) :
        sum+= abs(li[i] - b - i - 1)
    return sum
def binary_search(li) :
    left = -1000000001
    right = 1000000001
    while right - left > 1 :
        med = (right + left) // 2
        x = func(li,med)
        mdx = func(li,med-1)
        pdx = func(li,med+1)
        if mdx > x and pdx < x :
            left = med
            continue
        elif mdx < x and pdx > x :
            right = med
            continue
        elif mdx >= x and pdx >= x :
            return x
    else :
        return -1
N = int(input())
A =[int(i) for i in input().split()]
print(binary_search(A))
Buggy python submission (verdict: Runtime Error):
H,W = [int(i) for i in input().split()]
pic = [list(input()) for _ in range(H)]
dx = [1,0,-1,0]
dy = [0,1,0,-1]
def dfs(x,y):
    pic[x][y] = "."
    for i in range(4):
        nx = x + dx[i]
        ny = y + dy[i]
        if nx < 0 or ny < 0 or nx >= W or ny >= H:
            continue
        if pic[nx][ny] == ".":
            continue
        dfs(nx,ny)
a = 1
ans = "Yes"
for i in range(H):
    for j in range(W):
        if pic[i][j] == "#":
            count = 0
            for k in range(4):
                nx = i + dx[k]
                ny = j + dy[k]
                if nx < 0 or ny < 0 or nx >= W or ny >= H:
                    continue
                if pic[nx][ny] == "#":
                    count+=1
            if count == 0:
                ans = "No"
                a = 0
                break
    if a == 0:
        break
print(ans)

Fixed submission:
h, w = list(map(int, input().split()))
graph = []
def check(s,t):
    if (0 <=  s <= w - 1) and (0 <= t <= h - 1):
        return True
    else:
        return False
def check_around(x,y):
    if check(x+1,y) and graph[y][x+1] == '#':
        return True
    if check(x,y+1) and graph[y+1][x] == '#':
        return True
    if check(x-1,y) and graph[y][x-1] == '#':
        return True
    if check(x,y-1) and graph[y-1][x] == '#':
        return True
    return False
for i in range(h):
    graph.append(list(input()))
for i in range(h):
    for j in range(w):
        if graph[i][j] == '#':
            if  not check_around(j,i):
                print("No")
                exit()
print("Yes")

Buggy python submission (verdict: Runtime Error):
H,W = [int(i) for i in input().split()]
li = ['0'] * H
for i in range(H) :
    li[i] = list(input())
dx = [1,0,-1,0]
dy = [0,1,0,-1]
counta = 0
count = 0
for i in range(H) :
    for j in range(W) :
        if li[i][j] == "#" :
            counta+=1
for i in range(H) :
    for j in range(W) :
        if li[i][j] == "#" :
            for k in range(4) :
                nx = i + dx[k]
                ny = j + dy[k]
                if nx < 0 or nx > W-1 or ny < 0 or ny > H-1 :
                    continue
                if li[nx][ny] == "#" :
                    count+=1
                    break
if count == counta:
    print("Yes")
else:
    print("No")

Fixed submission:
h, w = list(map(int, input().split()))
graph = []
def check(s,t):
    if (0 <=  s <= w - 1) and (0 <= t <= h - 1):
        return True
    else:
        return False
def check_around(x,y):
    if check(x+1,y) and graph[y][x+1] == '#':
        return True
    if check(x,y+1) and graph[y+1][x] == '#':
        return True
    if check(x-1,y) and graph[y][x-1] == '#':
        return True
    if check(x,y-1) and graph[y-1][x] == '#':
        return True
    return False
for i in range(h):
    graph.append(list(input()))
for i in range(h):
    for j in range(w):
        if graph[i][j] == '#':
            if  not check_around(j,i):
                print("No")
                exit()
print("Yes")
Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
li = list(map(int,input().split()))
lia = li[:]
for i in range(N) :
    del lia[i]
    lia.sort()
    ave = int((N-2)/2)
    a = lia[ave]
    lia = li[:]
    print(a)

Fixed submission:
N = int(input())
li = list(map(int,input().split()))
lia = li[:]
lia.sort()
index1 = int(N/2)
index2 = int((N-2)/2)
ave1 = lia[index2]
ave2 = lia[index1]
for i in range(N) :
    if li[i] <= ave1 :
        print(ave2)
    else :
        print(ave1)

Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
li = list(map(int,input().split()))
lia = li[:]
for i in range(N) :
    del lia[i]
    lia.sort()
    ave = int((N-2)/2)
    a = lia[ave]
    lia = li[:]
    print(a)

Fixed submission:
N = int(input())
li = list(map(int,input().split()))
lia = li[:]
lia.sort()
index1 = int(N/2)
index2 = int((N-2)/2)
ave1 = lia[index2]
ave2 = lia[index1]
for i in range(N) :
    if li[i] <= ave1 :
        print(ave2)
    else :
        print(ave1)
Buggy python submission (verdict: Runtime Error):
import sys
input = sys.stdin.readline
A,B,K = [int(i) for i in input().split()]
d = B - A + 1
li = [0] * d
count = 0
for i in range(d) :
    li[i] = A + count
    count+=1
if d > 2 * K + 1 :
    lia = [0] * 2 * K
    for i in range(K) :
        lia[i] = li[i]
    counta = 0
    for i in range(K,2 * K) :
        lia[i] = li[-K+counta]
        counta += 1
    for i in range(2 * K) :
        print(lia[i])
else :
    for i in range(d) :
        print(li[i])

Fixed submission:
A,B,K = map(int,input().split())
if (2*K)<(B-A+2):
  for i in range(A,A+K):
    print(i)
  for i in range(B-K+1,B+1):
    print(i)
else:
  for i in range(A,B+1):
    print(i)
Buggy python submission (verdict: Time Limit Exceeded):
#template
def inputlist(): return [int(k) for k in input().split()]
#template
def dijkstra(s,n,cost):
    #始点sから各頂点への最短距離
    #n:頂点数,　w:辺の数, cost[u][v] : 辺uvのコスト(存在しないときはinf)
    d = [float("inf")] * n
    used = [False] * n
    d[s] = 0

    while True:
        v = -1
        #まだ使われてない頂点の中から最小の距離のものを探す
        for i in range(n):
            if (not used[i]) and (v == -1):
               v = i
            elif (not used[i]) and d[i] < d[v]:
                v = i
        if v == -1:
               break
        used[v] = True

        for j in range(n):
               d[j] = min(d[j],d[v]+cost[v][j])
    return d

H,W = inputlist()
cost = [0]*10
for i in range(10):
    cost[i] = inputlist()
A = [0]*H
for i in range(H):
    A[i] = inputlist()

ans = 0

for x in range(H):
    for y in range(W):
        if A[x][y] == -1:
            continue
        d = dijkstra(A[x][y],10,cost)
        ans += d[1]
print(ans)

Fixed submission:
from scipy.sparse.csgraph import shortest_path
import numpy as np
H,W = [int(i) for i in input().split()]
c = [0] * 10
for i in range(10):
    c[i] = [int(j) for j in input().split()]
c = np.array(c)
path = shortest_path(c,'D')
A = [0] * H
for i in range(H):
    A[i] = [int(j) for j in input().split()]
ans = 0
for i in range(H):
    for j in range(W):
        if A[i][j] == 1 or A[i][j] == -1:
            continue
        ans += path[A[i][j]][1]
print(int(ans))
Buggy python submission (verdict: Runtime Error):
#template
def inputlist(): return [int(j) for j in input().split()]
from collections import Counter
#template
#issueから始める
class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]
N,M = inputlist()
ans = 0
ab = [0]*M
for i in range(M):
    ab[i] = inputlist()
for i in range(M):
    uf = UnionFind(N+1)
    for j in range(M):
        if j == i:
            continue
        uf.union(ab[j][0],ab[j][1])
    if uf.size(j) != N:
        ans +=1
print(ans)

Fixed submission:
N,M=[int(i) for i in input().split()]
graph = [[] for _ in range(N+1)]
from collections import deque
aa = [0] * M
bb = [0] * M
ans = 0
for i in range(M):
    a,b = [int(j) for j in input().split()]
    graph[a].append(b)
    graph[b].append(a)
    aa[i] = a
    bb[i] = b
import copy
grapha = copy.deepcopy(graph)
for k in range(M):
    graph[aa[k]].remove(bb[k])
    graph[bb[k]].remove(aa[k])
    seen = [False] * (N+1)
    from collections import deque
    que = deque()
    que.append(1)
    while len(que) != 0:
        x = que.popleft()
        seen[x] = True
        for i in graph[x]:
            if seen[i]:
                continue
            que.append(i)
            seen[i] = True
    for l in range(1,N+1):
        if seen[l]:
            continue
        ans +=1
        break
    graph = copy.deepcopy(grapha)
print(ans)
Buggy python submission (verdict: Runtime Error):
import sys
input = sys.stdin.readline
import numpy as np
N = int(input())
sum = 0
li = np.ones(100000010)
for i in range(N) :
    A = int(input())
    if li[A] == 1 :
        sum +=1
        li[A] = 0
    else :
        li[A] = 1
        sum -=1
print(sum)

Fixed submission:
n=int(input())
s=set()
for i in range(n):
    a=int(input())
    if a in s:
        s.remove(a)
    else:
        s.add(a)
print(len(s))

Buggy python submission (verdict: Runtime Error):
import sys
input = sys.stdin.readline
N = int(input())
sum = 0
li = [1] * 1000000100
for i in range(N) :
    A = int(input())
    if li[A] == 1 :
        sum +=1
        li[A] = 0
    else :
        li[A] = 1
        sum -=1
print(sum)

Fixed submission:
n=int(input())
s=set()
for i in range(n):
    a=int(input())
    if a in s:
        s.remove(a)
    else:
        s.add(a)
print(len(s))

Buggy python submission (verdict: Runtime Error):
import sys
input = sys.stdin.readline
N = int(input())
sum = 0
li = [1] * 100010
for i in range(N) :
    A = int(input())
    if li[A] == 1 :
        sum +=1
        li[A] = 0
    else :
        li[A] = 1
        sum -=1
print(sum)

Fixed submission:
n=int(input())
s=set()
for i in range(n):
    a=int(input())
    if a in s:
        s.remove(a)
    else:
        s.add(a)
print(len(s))

Buggy python submission (verdict: Runtime Error):
import sys
input = sys.stdin.readline
N = int(input())
sum = 0
li = [1] * 100010
for i in range(N) :
    A = int(input())
    if li[A] == 1 :
        sum +=1
        li[A] = 0
    else :
        li[A] = 1
        sum -=1
print(sum)

Fixed submission:
n=int(input())
s=set()
for i in range(n):
    a=int(input())
    if a in s:
        s.remove(a)
    else:
        s.add(a)
print(len(s))
Buggy python submission (verdict: Runtime Error):
N = int(input())
p = [int(i) for i in input().split()]
ans = 0
for i in range(N):
    if i+1 == p[i]:
        if i == N-1:
            l = p[i]
            k = l[i-1]
            p[i] = k
            p[i-1] = l
            ans +=1
        else:
            l = p[i]
            k = p[i+1]
            p[i] = k
            p[i+1] = l
            ans +=1
print(ans)


Fixed submission:
N = int(input())
p = [int(i) for i in input().split()]
ans = 0
for i in range(N):
    if i+1 == p[i]:
        if i == N-1:
            l = p[i]
            k = p[i-1]
            p[i] = k
            p[i-1] = l
            ans +=1
        if i != N-1:
            l = p[i]
            k = p[i+1]
            p[i] = k
            p[i+1] = l
            ans +=1
print(ans)