Harryxun/stf_run huggingface dataset:
from collections import Counter
n = int(input())
a = list(map(int, input().split()))
q = int(input())

ans = sum(a)
A = Counter(a).most_common()
d = [0] * 10**5+10
for i in range(len(A)):
    d[A[i][0]] = A[i][1]

B = []
C = []
for i in range(q):
    b, c = map(int, input().split())
    B.append(b)
    C.append(c)

for i in range(q):
    d[C[i]] += d[B[i]]
    cnt = d[B[i]]
    ans += (C[i]-B[i])*cnt
    print(ans)
    d[B[i]] = 0

### FIXED CODE ###

from collections import Counter
n = int(input())
a = list(map(int, input().split()))
q = int(input())

ans = sum(a)
A = Counter(a).most_common()
d = [0] * (10**5+10)
for i in range(len(A)):
    d[A[i][0]] = A[i][1]

B = []
C = []
for i in range(q):
    b, c = map(int, input().split())
    B.append(b)
    C.append(c)

for i in range(q):
    d[C[i]] += d[B[i]]
    cnt = d[B[i]]
    ans += (C[i]-B[i])*cnt
    print(ans)
    d[B[i]] = 0
s = list(input())
n = len(s)
ans = 1
# 区間は2以上の長さ
if n % 2 != 0:
    for i in range(1, n):
        a = s[n // 2]
        if s[n // 2 - 1 - i] != a or s[n // 2 + i] != a:
            print(n // 2 + i)
            exit()
else:
    for i in range(1, (n - 1) // 2 + 1):
        b = s[(n-1)//2]
        if s[(n - 1) // 2 - i] != b or s[(n - 1) // 2 + i] != b:
            print((n-1)//2+i)
            exit()
print(n)

### FIXED CODE ###

s = list(input())
n = len(s)
if n % 2 == 0:
    for i in range(n//2):
        a = s[n // 2]
        if s[n // 2 - 1 - i] != a or s[n // 2 + i] != a:
            print(n // 2 + i)
            exit()
else:
    for i in range(1, (n - 1) // 2 + 1):
        b = s[(n-1)//2]
        if s[(n - 1) // 2 - i] != b or s[(n - 1) // 2 + i] != b:
            print((n-1)//2+i)
            exit()
print(n)
n,c=map(int,input().split())
x=[0]
v=[]
for i in range(n):
    a,b=map(int,input().split())
    x.append(a)
    v.append(b)

x1=[x[i+1]-x[i] for i in range(len(x)-1)]
x2=[c-x[-1]]+x1[:0:-1]
h=[0]
for i,j in zip(x2,reversed(v)):
    h.append(h[-1]+j+-i)
t=[0]
for i,j in zip(x1,v):
    t.append(t[-1]+j-i)
hi=h.index(max(h[0:-1]))
ti=t.index(max(t[0:-1]))
tm=max(t[0:-1])
hm=max(h[0:-ti])
h2=[h[i]-x[i] for i in range(1,len(h))]
t2=[t[i]-x[-i-1] for i in range(1,len(h))]
#print(h,t)
#print(h2,t2)

#print(ti,hi)
print(max(max(t), max(h), hm+max(t2[0:-ti]),tm+max(h2[:-hi])))
#print(hm, tm, hm+max(t2[0:-ti]),tm+max(h2[:-hi]))

### FIXED CODE ###

n,c=map(int, input().split())
a=[[0,0]]+[list(map(int, input().split())) for i in range(n)]+[[c,0]]
m=[0]
h=[0]
mb=[0]
hb=[0]
for i in range(n+1):
    m.append(m[-1]-a[i+1][0]+a[i][0]+a[i+1][1])
    mb.append(m[-2]-a[i+1][0]+a[i][0]+a[i+1][1]-a[i+1][0])
    h.append(h[-1]-a[-i-1][0]+a[-i-2][0]+a[-i-2][1])
    hb.append(h[-2]-a[-i-1][0]+a[-i-2][0]+a[-i-2][1]-c+a[-i-2][0])

mm=[0]
for i in range(n):
    mm.append(max(mm[-1],m[i+1]))
hm=[0]
for i in range(n):
    hm.append(max(hm[-1],h[i+1]))
    
ans=max(hm[-1],mm[-1])
for i in range(1,n):
    ans=max(hb[i]+mm[-i-1], mb[i]+hm[-i-1],ans)
print(ans)
n = int(input())
a = list(map(int,input().split()))
a.sort(reverse = True)
p = 0

for i in range(n):
    j = i + 1
    for j in range(n):
        if i == j:
            pass
        elif a[i] % a[j] == 0:
            break
        else:
            pass
        if j == n - 1:
                p += 1

print(p)

### FIXED CODE ###

x1,x2,x3,x4,x5 = map(int,input().split())

if x1 == 0:
    print(1)
elif x2 == 0:
    print(2)
elif x3 == 0:
    print(3)
elif x4 == 0:
    print(4)
else:
    print(5)
import copy
import itertools

def funcF(p):
    return p

def funcG(p):
    return funcF(p) + p*p

N, M = (int(i) for i in input().split())
X = list(int(i) for i in input().split())
X.sort()

if N >= M:
    print ("0")
    exit()

# X[0] ... X[M-1] をN個のグループに分ける
# X[i]とX[i+1]の間でグループを分ける場合Cx=iとする（i = 0 .. M-2の個数(N-1)個のCombinationで求まる）

minS=max(X) - min(X)
for C in list(itertools.combinations(range(M-1), N-1)):
    tmpS = 0
    if C[0] > 0:
        tmpS += X[C[0]] - X[0]
    for i in range(N-2):
        if C[i+1] > C[i]+1:
            tmpS += X[C[i+1]] - X[C[i]+1]
    tmpS += X[M-1] - X[C[N-2]+1]
    if tmpS < minS:
        minS = tmpS

print("{}".format(minS))


### FIXED CODE ###

import copy
import itertools

def funcF(p):
    return p

def funcG(p):
    return funcF(p) + p*p

N, M = (int(i) for i in input().split())
X = list(int(i) for i in input().split())
X.sort()

if N >= M:
    print ("0")
    exit()

# X[0] ... X[M-1] をN個のグループに分ける
# X[i]とX[i+1]の間でグループを分ける場合Cx=iとする（i = 0 .. M-2の個数(N-1)個のCombinationで求まる）

# minS=max(X) - min(X)
# for C in list(itertools.combinations(range(M-1), N-1)):
#     tmpS = 0
#     if C[0] > 0:
#         tmpS += X[C[0]] - X[0]
#     for i in range(N-2):
#         if C[i+1] > C[i]+1:
#             tmpS += X[C[i+1]] - X[C[i]+1]
#     tmpS += X[M-1] - X[C[N-2]+1]
#     if tmpS < minS:
#         minS = tmpS

L=[]
for i in range(M-1):
    L.append(X[i+1] - X[i])
L.sort(reverse=True)
tmpL=0
for i in L[:N-1]:
    tmpL += i

print("{}".format(X[M-1]-X[0]-tmpL))
N = int(input())

n = N - int((len(str(N)) - 1) * '9')
tmp = (len(str(N)) - 1) * '9'
if len(str(n)) > (len(str(N)) - 1):
    tmp = str(n)[0] + tmp

res = 0
for t in tmp:
    res += int(t)

print(res)


### FIXED CODE ###

N = input()

f = int(N[0])
res = (len(N) - 1) * 9 + f - 1
s = 0
for i in N:
    s += int(i)

print(max(res, s))
N, K = map(int, input().split())
S = input()


def counthappy(s):
    happy = 0
    for i in range(0, len(s)):
        if i != 0 and s[i] == 'L':
            if s[i - 1] == 'L':
                happy += 1
        elif i != len(s) - 1 and s[i] == 'R':
            if s[i + 1] == 'R':
                happy += 1
    return happy


def replace(s, k_):
    for l in range(0, N - 1):
        for r in range(l + 1, N):
            part_l = s[0:l]
            part = s[l:r+1]
            part_r = s[r+1:N][::-1]

            part = part.replace('L', '-')
            part = part.replace('R', 'L')
            part = part.replace('-', 'R')
            s_ = part_l + part + part_r

            if k_ < K:
                replace(s_, k_ + 1)

            happy = counthappy(s_)
            global answer
            if answer < happy:
                answer = happy


answer = counthappy(S)
replace(S, 1)

print(answer)

### FIXED CODE ###

N, K = map(int, input().split())
S = input()


def counthappy(s):
    happy = 0
    for i in range(0, len(s)):
        if i != 0 and s[i] == 'L':
            if s[i - 1] == 'L':
                happy += 1
        elif i != len(s) - 1 and s[i] == 'R':
            if s[i + 1] == 'R':
                happy += 1
    return happy


flag = 0
S = S + 'J'
s_ = []
for i in range(0, N):
    if S[i] != S[i + 1]:
        s_.append(S[flag:i + 1])
        flag = i + 1

count = 0
for i in range(1, len(s_), 2):
    count += 1
    if s_[i][0] == 'L':
        s_[i] = s_[i].replace('L', 'R')
    elif s_[i][0] == 'R':
        s_[i] = s_[i].replace('R', 'L')

    if count == K:
        break

s_join = ''.join(s_)

happy = counthappy(s_join)
print(happy)
import math
from functools import reduce

def lcm_base(x, y):
    return (x * y) // math.gcd(x, y)

def lcm_list(a):
    return reduce(lcm_base, a, 1)

N = int(input())
a = list(map(int, input().split()))
ans = 0
num = lcm_list(a) - 1
for i in range(len(a)):
	ans += num % a[i]
print(ans)


### FIXED CODE ###

N = int(input())
a = list(map(int, input().split()))
ans = 0
for x in a:
	ans += x - 1
print(ans)
import math
(n, m) = map(int, input().split())
sm = int(math.sqrt(m)) + 1
for i in range(1, sm + 1):
    if m % i == 0 :
        params[i] = 1
        params[m // i] = 1
params = sorted(params)
mdn = m // n
maxans = 0
for i in params:
    if n > m / i:
        break
    maxans = i
print(maxans)

### FIXED CODE ###

import math
(n, m) = map(int, input().split())
sm = int(math.sqrt(m)) + 1
params = {m:1}
for i in range(1, sm + 1):
    if m % i == 0 :
        params[i] = 1
        params[m // i] = 1
params = sorted(params)
mdn = m // n
maxans = 0
for i in params:
    if n > m / i:
        break
    maxans = i
print(maxans)
A = int(input())
B = int(input())
if A == B:
	print "GREATER"
elif A < B:
	print "LESS"
else:
	print "EQUAL"

### FIXED CODE ###

A = int(input())
B = int(input())
if A == B:
	print "EQUAL"
elif A < B:
	print "LESS"
else:
	print "GREATER"
import math
from functools import reduce

N = int(input())
A = list(map(int,input().split()))
g_max = 0
for i in range(N):
    B = A.copy()
    B[i:i+1] = []
    g = reduce(math.gcd,B)
    if g_max < g:
        g_max = g
print(g_max)

### FIXED CODE ###

def gcd(x,y):
    while y != 0:
        x,y = y,x%y
    return x
n = int(input())
a = list(map(int,input().split()))

L,R = [0],[0]
for i in range(1,n+1): #L[i]は左i個,R[i]は右i個
    L.append(gcd(L[-1],a[i-1]))
    R.append(gcd(R[-1],a[n-i]))
print(max(gcd(L[i],R[n-i-1]) for i in range(n)))
import numpy as np
K = int(input())
table = ['1', '2', '3', '4', '5', '6', '7', '8', '9']
c = 9
result = []
for i in table:
  runrun = i
  if runrun[-1] == '0':
    table.extend([runrun + str(int(runrun[-1])), 
                   runrun + str(int(runrun[-1])+1)])
    c += 2
  elif runrun[-1] == '9':
    table.extend([runrun + str(int(runrun[-1])-1), 
                   runrun + str(int(runrun[-1]))])
    c += 2
  else:
    table.extend([runrun + str(int(runrun[-1])-1), 
                   runrun + str(int(runrun[-1])), 
                   runrun + str(int(runrun[-1])+1)])
    c += 3
  if c>=K:
    print(table[K-1])
    exit()

### FIXED CODE ###

K = int(input())
table = [1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in table:
  if len(table) > K:
    break
  x = i % 10
  for j in range(max(0, x - 1), min(x + 2, 10)):
    table.append(i * 10 + j)
print(table[K-1])
a,b=list(map(int,input()))
count=0
while (a<0):
  count+=1
  a-=b
print(count)
  

### FIXED CODE ###

a,b=list(map(int,input().split()))
count=0
while (a>0):
  count+=1
  a-=b
print(count)
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
a = [0]*(N+1)
b = [0]*(M+1)
X = 0
Y = 0
cnt = 0
for n in range(N):
    a[n+1] = a[n] + A[n]
for n in range(M):
    b[n+1] = b[n] + B[n]
for n in range(1, N+1):
    if a[n] <= K:
        X = n
for m in range(1, M+1):
    if b[m] <= K:
        Y = m 
if a[X] < b[Y]:
    K = K - a[X]
    cnt += X
    if K - b[Y] == 0:
        cnt += Y
    else:
        for y in range(1, Y):
            if b[y] <= K:
                cnt += 1
else:
    K = K - b[Y]
    cnt += Y
    if K - a[X] == 0:
        cnt += X
    else:
        for x in range(1, X):
            if b[x] <= K:
                cnt += 1
print(cnt)

### FIXED CODE ###

N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
a = [0]*(N+1)
b = [0]*(M+1)
for n in range(N):
    a[n+1] = a[n] + A[n]
for n in range(M):
    b[n+1] = b[n] + B[n]
ans, j = 0, M
for i in range(N + 1):
    if a[i] > K:
        break
    while b[j] > K - a[i]:
        j -= 1
    ans = max(ans, i + j)
print(ans)
# ARC087C - Good Sequence (ABC082C)
import sys
input = sys.stdin.readline

def main():
    n = int(input())
    lst = list(map(int, input().rstrip().split()))
    cnt = [0] * (10 * 9 + 1)
    for i in lst:
        cnt[i] += 1
    ans = 0
    for i, j in enumerate(cnt):
        if i > j:
            ans += j
        elif i < j:
            ans += j - i
    print(ans)


if __name__ == "__main__":
    main()


### FIXED CODE ###

# ARC087C - Good Sequence (ABC082C)
import sys
input = sys.stdin.readline

def main():
    n = int(input())
    lst = list(map(int, input().rstrip().split()))
    cnt = {}
    for i in lst:
        if i not in cnt:
            cnt[i] = 0
        cnt[i] += 1
    ans = 0
    for i, j in cnt.items():
        if i > j:
            ans += j
        elif i < j:
            ans += j - i
    print(ans)


if __name__ == "__main__":
    main()
print(input()+input())

### FIXED CODE ###

ls = list(map(str, input().split()))
print(ls[1]+ls[0])
N = int(input())
l = list[]

for i in N:
  n = int(input())
  l.append(n)

m = l.max()
SUM = l.sum() - m

if m > SUM:
  print("YES")
else:
  print("NO")


### FIXED CODE ###

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

m = max(l)
SUM = sum(l) - m

if m < SUM:
  print('Yes')
else:
  print('No')
n, m = map(int, input().split())
a_pos = [0]*(n+1)
for i in range(m):
    a_pos[int(input())] = 1
mod = 10**9+7
dp = [0]*(n+1)
dp[0] = 1
dp[1] = 0 if aL[1] else 1
for i in range(2, n+1):
    if a_pos[i] == 1:
        dp[i] = 0
    else:
        dp[i] = (dp[i-2] + dp[i-1]) % mod

print(dp[-1])


### FIXED CODE ###

n, m = map(int, input().split())
a_pos = [0]*(n+1)
for i in range(m):
    a_pos[int(input())] = 1
mod = 10**9+7
dp = [0]*(n+1)
dp[0] = 1
dp[1] = 0 if a_pos[1] else 1
for i in range(2, n+1):
    if a_pos[i] == 1:
        dp[i] = 0
    else:
        dp[i] = (dp[i-2] + dp[i-1]) % mod

print(dp[-1])
n, b_n, r_n = input().split()
b= "b" * int(b_n)
r = "r" * int(r_n)

total = (b + r) * int(n)
total = total[:int(n)]

b_n2 = 0
for _ in total:
  if _ == "b":
    b_n2 += 1
  
print(b_n2)

### FIXED CODE ###

n, b, r = map(int, input().split())

c = b + r

print(b*(n//c) + min(n % c, b))
x, y, a, b, c = map(int, input().split())
p = sorted(map(int, input().split()))
q = sorted(map(int, input().split()))
r = sorted(map(int, input().split()), reverse=True)
pi = len(p) - x
qi = len(q) - y
ri = 0
for _ in range(len(r)):
    if r[ri] <= min(p[pi], q[qi]):
        break
    else:
        if pi < len(p):
            if p[pi] < r[ri]:
                p[pi] = r[ri]
                pi += 1
                ri += 1
                continue
        if qi < len(q):
            if q[qi] < r[ri]:
                q[qi] = r[ri]
                qi += 1
                ri += 1
                continue
        else:
            break
print(sum(p[-x:]) + sum(q[-y:]))


### FIXED CODE ###

x, y, a, b, c = map(int, input().split())
p = sorted(map(int, input().split()))
q = sorted(map(int, input().split()))
r = sorted(map(int, input().split()), reverse=True)
pi = len(p) - x
qi = len(q) - y
ri = 0
for _ in range(len(r)):
    if r[ri] <= min(p[min(pi, len(p)-1)], q[min(qi, len(q)-1)]):
        break
    else:
        if pi >= len(p) and qi >= len(q):
            break
        else:
            if pi < len(p) and qi < len(q):
                if p[pi] < q[qi]:
                    p[pi] = r[ri]
                    pi += 1
                else:
                    q[qi] = r[ri]
                    qi += 1
            elif pi < len(p) and qi >= len(q):
                p[pi] = r[ri]
                pi += 1
            else:
                q[qi] = r[ri]
                qi += 1
            ri += 1
print(sum(p[-x:]) + sum(q[-y:]))
N=int(input())
if N[-1] == 3:
  print('bon')
elif N[-1] in [0,1,6,8]:
  print('pon')
else:
  print('hon')

### FIXED CODE ###

N=input()
if N[-1] == '3':
  print('bon')
elif N[-1] in ['0','1','6','8']:
  print('pon')
else:
  print('hon')
K = int(input())
S = input()
if len(S) <= K:
  print(S)
else:
  print(S[K:]+...)

### FIXED CODE ###

K = int(input())
S = input()
if len(S) <= K:
  print(S)
else:
  print(S[:K]+"...");
lst = []

for i in range (5):
    element = int(input())
    lst.append(element)

n=lst.index(0)
print(n+1)



### FIXED CODE ###

lst = []

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

lst.append(a)
lst.append(b)
lst.append(c)
lst.append(d)
lst.append(e)

n=lst.index(0)
print(n+1)
n,m = map(int,input().split())
sc = [list(map(int,input().split())) for i in range(m)]
s,c = zip(*sc)

arr = [0 for i in range(n)]

for i in range(m):
    if arr[s[i]-1] != 0 and arr[s[i]-1] != c[i]:
        print(-1)
        exit()
    if n != 1 and s[i]-1 == 0 and c[i] == 0:
        print(-1)
        exit()
    else:
        arr[s[i]-1] = c[i]

if n == 1 and arr[0] == 0:
    print(0)
    exit()

if arr[0] == 0:
    arr[0] = 1

print("".join(map(str,arr)))

### FIXED CODE ###

n,m = map(int,input().split())
sc = [list(map(int,input().split())) for i in range(m)]
if m > 0:
    s,c = zip(*sc)

arr = [0 for i in range(n)]

for i in range(m):
    if arr[s[i]-1] != 0 and arr[s[i]-1] != c[i]:
        print(-1)
        exit()
    if n != 1 and s[i]-1 == 0 and c[i] == 0:
        print(-1)
        exit()
    else:
        arr[s[i]-1] = c[i]

if n == 1 and arr[0] == 0:
    print(0)
    exit()

if arr[0] == 0:
    arr[0] = 1

print("".join(map(str,arr)))
x = input()

x^3 = x * x * x;

print x^3

### FIXED CODE ###

x = input()
print x * x * x
def trans(cur, prev_paths, score, goal_score, paths, N):
    # inf check
    if cur in prev_paths:
        return 'inf'
    if cur == N:
        goal_score = score
    if not cur in paths:
        return goal_score

    nodes = paths[cur]
    score_updated = False
    for n, s in nodes:
        new_score = score + s
        new_prev_paths = dict(prev_paths)
        new_prev_paths[cur] = 1
        tmp_goal_score = trans(n, new_prev_paths, new_score, goal_score, paths, N)
        if tmp_goal_score == 'inf':
            return 'inf'
        elif not score_updated or tmp_goal_score > goal_score:
            goal_score = tmp_goal_score
            score_updated = True

    return goal_score


N, M = map(int, input().split())

paths = {}
prev_paths = {}
for i in range(M):
    a, b, c = map(int, input().split())
    if a in paths:
        paths[a].append((b, c))
    else:
        paths[a] = [(b, c)] 

cur_node = 1
prev_node = -1
score = trans(cur_node, prev_paths, 0, 0, paths, N)
print(score)

### FIXED CODE ###

import sys
sys.setrecursionlimit(100000)

def set_enable_goal(cur_node, back_paths, enable_goal):
    if cur_node in back_paths:
        for next_node in back_paths[cur_node]:
            if enable_goal[next_node - 1] == 0:
                enable_goal[next_node - 1] = 1
                set_enable_goal(next_node, back_paths, enable_goal)


N, M = map(int, input().split())
MIN = float('-inf')
INF_LIMIT = -MIN

back_paths = {}
all_paths = {}
for i in range(M):
    a, b, c = map(int, input().split())
    if a in all_paths:
        all_paths[a].append((b, c))
    else:
        all_paths[a] = [(b, c)]

    if b in back_paths:
        back_paths[b].append(a)
    else:
        back_paths[b] = [a]


# path cut
enable_goal= [0 for i in range(N)]
enable_goal[N - 1] = 1
set_enable_goal(N, back_paths, enable_goal)

for a, paths in all_paths.items():
    if not enable_goal[a - 1]:
        all_paths[a] = []
    else:
        valid_paths = []
        for b, c in paths:
            if enable_goal[b - 1]:
                valid_paths.append((b, c))
        all_paths[a] = valid_paths


scores = [MIN for i in range(N)]
scores[0] = 0

is_inf = False
for n in range(N):
    for a in all_paths.keys():
        for b, c in all_paths[a]:
            scores[b - 1] = max(scores[b - 1], scores[a - 1] + c)

# loop check
if not is_inf:
    prev_score = scores[N - 1]
    for a in all_paths.keys():
        for b, c in all_paths[a]:
            scores[b - 1] = max(scores[b - 1], scores[a - 1] + c)
    if prev_score != scores[N - 1]:
        is_inf = True


if is_inf:
    print('inf')
else:
    print(scores[N - 1])
at = input().split()
top = input().split()
if at =='H':
  at_i = 1

if at == 'D':
  at_i = -1
  
if top == 'H':
	top_i = 1

if top == 'D':
  top_i = -1

if top_i * app_i == 1:
  print("H")
else
	print("D")
 

### FIXED CODE ###

at = list(input())
at_i = 0
top_i = 0
if at[0] =='H':
  at_i = 1

if at[0] == 'D':
  at_i = -1

if at[2] == 'H':
	top_i = 1

if at[2] == 'D':
  top_i = -1

if top_i * at_i == 1:
    print("H")
else :
    print("D")
size=int(input())
h = list(map(int,input().split()))
dp = 0
for i in range(0, size):
    if i < size-1:
        if abs(h[i]-h[i+1]) < abs(h[i]-h[i+2]):
            dp += abs(h[i+1]-h[i])
        else:
            dp += abs(h[i+2]-h[i])
    if i = size-1:
        dp += abs(h[i+1]-h[i])
    except:
        pass
print(dp)

### FIXED CODE ###

size=int(input())
h = list(map(int,input().split()))
dp = [0 for _ in range(size)]
for i in range(1,size):
    if i == 1:
        dp[i] = dp[0]+abs(h[0]-h[1])
    else:
        a = dp[i-2]+abs(h[i-2]-h[i])
        b = dp[i-1]+abs(h[i-1]-h[i])
        if a < b:
            dp[i] = a
        else:
            dp[i] = b
print(dp[-1])
n=int(input())
l=list(map(int,input().split()))
l.append(0)
a1=0
b1=0
a2=0
b2=0
for i in range(n):
    b1+=l[i]
    b2+=l[i]
    if i%2==0:
        if b1>=0:
            a1+=abs(-1-b1)
            b1=-1-l[i+1]
        if b2=<0:
            a2+=abs(1-b2)
            b2=1-l[i+1]
    else:
        if b1<=0:
            a1+=abs(1-b1)
            b1=1-l[i+1]
        if b2>=0:
            a2+=abs(-1-b2)
            b2=-1-l[i+1]
print(min(a1,a2))

### FIXED CODE ###

N = int(input())
a = list(map(int,input().split()))
ans1 = 0
ans2 = 0
S1 = 0
S2 = 0
for n in range(N):
    S1 += a[n]
    S2 += a[n]
    if n%2 == 0:
        if S1 >= -1:
            ans1 += S1 + 1
            S1 = -1
        if S2 <= 1:
            ans2 += 1 - S2
            S2 = 1
    if n%2 == 1:
        if S1 <= 1:
            ans1 += 1 - S1
            S1 = 1
        if S2 >= -1:
            ans2 += S2 + 1
            S2 = -1
print(min(ans1,ans2))
#coding: utf-8
#ABC042B

n,l=map(int,raw_input().split())
s=[raw_input() for i in xrange(n)]

s.sort()
res="".join(s)
print res


### FIXED CODE ###

#coding: utf-8
#ABC042A

l=map(int,raw_input().split())

if l.count(5)==2 and l.count(7)==1:
 print "YES"
else:
 print "NO"
s = input()
for i in s:
  if s[2] == s[3] and s[5] == s[6]:
    print("Yes")
  else:
    print("No")

### FIXED CODE ###

s = input()
if s[2] == s[3] and s[4] == s[5]:
  print("Yes")
else:
  print("No")
import math
a, b = map(int, input().split())
print((a * b) // math.gcd(a, b))


### FIXED CODE ###

import fractions
a, b = map(int, input().split())
print((a * b) // fractions.gcd(a, b))
import math
from itertools import combinations

def main():
    k = int(input())
    res = 0
    memo = [[0 for _ in range(k)] for _ in range(k)]
    for i ian range(1, k+1):
        for j in range(i, k+1):
            tmp = math.gcd(i,j)
            memo[i][j] = tmp
            memo[j][i] = tmp

    for i in range(1, k+1):
        res += i 

    for c in combinations(range(1,k+1),2):
        ab = memo[c[0], c[1]]
        res += ab * 6

    for c in combinations(range(1,k+1), 3):
        ab = memo[c[0], c[1]]
        abc = memo[ab, c[2]]
        res += abc * 6
    print(res)


if __name__ == '__main__':
    main()

### FIXED CODE ###

import numpy as np
from itertools import combinations

def main():
    k = int(input())
    res = 0
    memo = np.zeros((k+1, k+1), int)
    for i in range(1, k+1):
        for j in range(i, k+1):
            tmp = np.gcd(i,j)
            memo[i][j] = tmp
            memo[j][i] = tmp

    for i in range(1, k+1):
        res += i 

    for c in combinations(range(1,k+1),2):
        ab = memo[c[0], c[1]]
        res += ab * 6

    for c in combinations(range(1,k+1), 3):
        ab = memo[c[0], c[1]]
        abc = memo[ab, c[2]]
        res += abc * 6
    print(res)


if __name__ == '__main__':
    main()
# ABC 151C
n, m = map(int, input().split())
ps = list(input().split() for _ in range(m))
ac = 0
wa = 0
a = int(ps[0][0])
if m == 0:
    print(0, 0)
    exit()
for i in range(1, m):
    while int(ps[i][0]) <= int(ps[m-1][0]):
        if int(ps[i][0]) == a and ps[i][1] == 'WA':
            wa += 1
        elif int(ps[i][0]) == a and ps[i][1] == 'AC':
            ac += 1
            a += 1
        else:
            continue
print(ac, wa)


### FIXED CODE ###

# ABC 151C
n, m = map(int, input().split())
ac = 0
wa = 0
cnt = [0]*n
for i in range(m):
    p, s = input().split()
    p = int(p)
    p -= 1
    if cnt[p] == -1:
        continue
    if s == 'AC':
        ac += 1
        wa += cnt[p]
        cnt[p] = -1
    else:
        cnt[p] += 1
print(ac, wa)
a= list(map(int,input().split("0")))
print(sum(a))

### FIXED CODE ###

print(input().count("1"))