Harryxun/sft_time huggingface dataset:
### BUGGY CODE ###

n = int(input())

ans = set()


for i in range(n):
    ans = ans ^ set([input()])

print(len(ans))


### FIXED CODE ###

n = int(input())

ans = [input() for i in range(n)]

ans.sort()

s = sorted(set(ans))
t = 0
cnt = 0

result = 0
for i in range(n):
    temp = s[t]
    if ans[i] == temp:
        cnt += 1
    else:
        if cnt % 2 == 1:
            result += 1
        cnt = 1
        t += 1
else:
    if cnt % 2 == 1:
        result += 1
        
    
    

print(result)
### BUGGY CODE ###

# -*- coding: utf-8 -*-
#import numpy as np
def fnSolv():
  iNum, iK = map(int, input().split())
  lHn  = list(map(int, input().split()))
  lDP  = [0]*iNum
  lRange=list(range(iK))
  lLen = [10**9]*iK
  for iI0 in range(1, iNum):
    if iI0 > iK:
      for iI1 in lRange:
        lLen[iI1] = lDP[iI0 - iI1 - 1] + abs(lHn[iI0] - lHn[iI0 - iI1 - 1])
    else:
      for iI1 in range(iI0):
        lLen[iI1] = lDP[iI0 - iI1 - 1] + abs(lHn[iI0] - lHn[iI0 - iI1 - 1])
    lDP[iI0] = min(lLen)
  print(lDP[iNum-1])

if __name__ == '__main__':
  fnSolv()


### FIXED CODE ###

# -*- coding: utf-8 -*-
import numpy as np
def fnSolv():
  iNum, iK = map(int, input().split())
  naHn  = np.array(list(map(int, input().split())))
  naDP  = np.zeros(iNum, dtype='int64')
  naLen = np.ones(iK) * 10**9
  for iI0 in range(1, iNum):
    iK0 = min([iK, iI0])
    naLen = naDP[iI0-iK0:iI0] + np.abs(- naHn[iI0-iK0:iI0] + naHn[iI0])
    naDP[iI0] = naLen.min()
  print(naDP[iNum-1])

if __name__ == '__main__':
  fnSolv()
### BUGGY CODE ###

import copy

H, W = map(int, input().split())
state = []
for i in range(H):
    row_list = list(input())
    state.append(row_list)


def light(row, col, state):
    lighted_count = 0
    col1 = copy.copy(col)
    next = '.'
    while next == '.':
        state[row][col1] = '.'
        lighted_count += 1
        col1 += 1
        if col1 >= W:
            break
        next = state[row][col1]
    
    col2 = copy.copy(col)
    next = '.'
    while next == '.':
        state[row][col2] = '.'
        lighted_count += 1
        col2 -= 1
        if col2 < 0:
            break
        next = state[row][col2]

    row1 = copy.copy(row)
    next = '.'
    while next == '.':
        state[row1][col] = '.'
        lighted_count += 1
        row1 += 1
        if row1 >= H:
            break
        next = state[row1][col]

    row2 = copy.copy(row)
    next = '.'
    while next == '.':
        state[row2][col] = '.'
        lighted_count += 1
        row2 -= 1
        if row2 < 0:
            break
        next = state[row2][col]

    lighted_count -= 3
    return lighted_count



def blank_fun(state):
    blank_list = []
    for h in range(H):
        for w in range(W):
            if state[h][w] == '.':
                blank_list.append([h, w])
    return blank_list


blank_list = blank_fun(state)
blank_count = 0
for blank in blank_list:
    row = blank[0]
    col = blank[1]
    blank_count_now = light(row, col, state)

    if blank_count_now > blank_count:
        blank_count = blank_count_now


print(blank_count)

### FIXED CODE ###

import copy
import sys
input = sys.stdin.readline

H, W = map(int, input().split())
S = [[1 if a == '.' else 0 for a in list(input())]  for _ in range(H)]

def main():
    R = copy.deepcopy(S)
    for h in range(H):
        s = 0
        for w in range(W):
            if R[h][w] == 1:
                s += 1
                R[h][w] = s
            else:
                s = 0
        l = 0
        for w in range(W-1, -1, -1):
            if R[h][w] > 0:
                l = max(l, R[h][w])
                R[h][w] = l
            else:
                l = 0

    L = copy.deepcopy(S)
    for w in range(W):
        s = 0
        for h in range(H):
            if L[h][w] == 1:
                s += 1
                L[h][w] = s
            else:
                s = 0
        l = 0
        for h in range(H-1, -1, -1):
            if L[h][w] > 0:
                l = max(l, L[h][w])
                L[h][w] = l
            else:
                l = 0
    ans = 0
    for h in range(H):
        for w in range(W):
            ans = max(ans, L[h][w]+R[h][w]-1)
    print(ans)

if __name__ == "__main__":
    main()
### BUGGY CODE ###

def solve():
    N,Q =[int(s) for s in input().split() if s]
    S = input()
    indices = [i for i in range(N-1) if S[i]+S[i+1] == 'AC']
    # print(l)
    for _ in range(Q):
        left, right =[int(s) for s in input().split() if s]
        print(sum(left-1 <= i <= right-2 for i in indices))
solve()

### FIXED CODE ###

def solve():
    N,Q = map(int, input().split())
    S = input()
    AC_total = [0]*N
    for i in range(1,N):
        AC_total[i] = AC_total[i-1]
        if S[i-1] == 'A' and S[i] == 'C':
            AC_total[i] += 1
        
    
    # print(AC_total)
    for _ in range(Q):
        l,r = map(int, input().split())
        print(AC_total[r-1]-AC_total[l-1])
        
solve()
### BUGGY CODE ###

import copy

n = int(input())
str = input()
char_list = list(str)
del_num = []

dellist = lambda items, indexes: [item for index, item in enumerate(items) if index not in indexes]

for i in range(len(char_list)-1):
    if char_list[i] == char_list[i+1]:
        del_num.append(i+1)

print(len(dellist(char_list,del_num)))


### FIXED CODE ###

n = int(input())
str = input()
char_list = list(str)
#del_num = []

count =0
ans =0

#dellist = lambda items, indexes: [item for index, item in enumerate(items) if index not in indexes]
for i in range(len(char_list)-1):
    if char_list[i] == char_list[i+1]:
        #del_num.append(i+1)
        count += 1

ans = n - count

print(ans)
### BUGGY CODE ###

a,b,n = map(int,input().split())
ma = 0

if(n<b):
    ma = (a*n)//b - (a* (n//b))
else:
    ma = (a*(b-1))//b - (a*((b-1)//b))
    for x in range(b,n+1):
        
        num = (a*x)//b - (a*(x//b))
        if(ma > num):
            break
        ma = num
        

print(ma)

### FIXED CODE ###

a,b,n = map(int,input().split())
ma = 0

if(n<b):
    ma = (a*n)//b - (a* (n//b))
else:
    ma = (a*(b-1))//b - (a*((b-1)//b))
    """
    for x in range(b,n+1):
        
        num = (a*x)//b - (a*(x//b))
        if(ma > num):
            break
        ma = num
    """

print(ma)
### BUGGY CODE ###

def resolve():
    '''
    code here
    '''
    N = int(input())
    A_list = [int(input()) for _ in range(N)]

    num_list = []

    for i in A_list:
        try:
            num_list.remove(i)
        except ValueError:
            num_list.append(i)

    print(len(num_list))


if __name__ == "__main__":
    resolve()


### FIXED CODE ###


def resolve():
    '''
    code here
    '''
    import collections

    N = int(input())
    A_list = [int(input()) for _ in range(N)]
    cnt_dic = collections.Counter(A_list)

    cnt = 0
    for v in cnt_dic.values():
        if v % 2 == 1:
            cnt += 1

    print(cnt)

if __name__ == "__main__":
    resolve()
### BUGGY CODE ###

import fractions
a, b = map(int, input().split())
abMax = fractions.gcd(a, b)
gcdList = [1]
if fractions.gcd(a, b) % 2 == 0:
    gcdList.append(2)
for i in range(1, int((abMax+1)/2)):
    c = 2*i + 1
    if a % c == 0 and b % c == 0:
        swi = 0
        for k in gcdList:
            if fractions.gcd(k, c) != 1:
                swi = 1
                break
        if swi == 0:
            gcdList.append(c)

print(len(gcdList))


### FIXED CODE ###

import math


def main():
    a, b = map(int, input().split())
    gcd = math.gcd(a, b)
    ans = [1]
    while gcd % 2 == 0:
        ans.append(2)
        gcd = gcd // 2
    f = 3
    while f * f <= gcd:
        if gcd % f == 0:
            ans.append(f)
            gcd = gcd // f
        else:
            f += 2
    if gcd != 1:
        ans.append(gcd)
    print(len(set(ans)))


if __name__ == '__main__':
    main()
### BUGGY CODE ###

n, k = map(int, input().split())
a = list(map(int, input().split()))
dig=[0 for i in range(40)] # 10^12 < 2^40

for i in range(n) :
    temp = a[i] 
    for j in range(40) :
        if temp <= 0 :
            break
        if temp % 2 == 1 :
            dig[j] += 1
        temp = temp // 2

bin = 1 << 39 # 2^39
sum0 = 0
i = 39
# leading_zero of k
while(bin > k) :
    sum0 += bin * dig[i]
    bin //= 2
    i += -1


def solve (k, bin, i) :
    if i < 0 :
        return 0, 0
    if k >= bin :  # this digit can be 1 or 0
        sum1, ans1 = solve(k-bin, bin//2, i-1)
        sum1 += bin * (n- dig[i]) 
        sum0, ans0 = solve(k,bin//2, i-1)
        sum0 += bin * dig[i]
        if sum1 >= sum0 :
            sum = sum1
            ans = ans1 + bin
        else :
            sum = sum0
            ans = ans0
    else :         # this digit must be 0
        sum, ans = solve(k,bin//2, i-1)
        sum += bin * dig[i]
    return sum, ans

sum, ans = solve(k, bin, i)

print (sum+sum0)
#print(sum, sum0)
#print (ans)




### FIXED CODE ###

n, k = map(int, input().split())
a = list(map(int, input().split()))
dig=[0 for i in range(40)] # 10^12 < 2^40

for i in range(n) :
    temp = a[i] 
    for j in range(40) :
        if temp <= 0 :
            break
        if temp % 2 == 1 :
            dig[j] += 1
        temp = temp // 2

bin = 1 << 39 # 2^39
sum0 = 0
i = 39
# leading_zero of k
while(bin > k) :
    sum0 += bin * dig[i]
    bin //= 2
    i += -1

memo={}

def solve (k, bin, i) :
    if i < 0 :
        return 0, 0
    if (k,bin) in memo:
        return memo[(k,bin)]
    if k >= bin :  # this digit can be 1 or 0
        sum1, ans1 = solve(k-bin, bin//2, i-1)
        sum1 += bin * (n- dig[i]) 
        sum0, ans0 = solve(bin-1,bin//2, i-1)
        sum0 += bin * dig[i]
        if sum1 >= sum0 :
            sum = sum1
            ans = ans1 + bin
        else :
            sum = sum0
            ans = ans0
    else :         # this digit must be 0
        sum, ans = solve(k,bin//2, i-1)
        sum += bin * dig[i]
    memo[(k,bin)] = sum, ans
    return sum, ans

sum, ans = solve(k, bin, i)

print (sum+sum0)
#print(sum, sum0)
#print (ans)
### BUGGY CODE ###

import sys
sys.setrecursionlimit(1000000)
def solve(n,l,pos):
    ans=0
    if(pos==n):
        return 0
    if(pos==n-1):
        return abs(l[-1]-l[-2])
    ans+=min(abs(l[pos-1]-l[pos])+solve(n,l,pos+1),abs(l[pos-1]-l[pos+1])+solve(n,l,pos+2))
    return ans
n=int(input())
l=list(map(int,input().split()))
print(solve(n,l,1))

### FIXED CODE ###

import sys
sys.setrecursionlimit(1000000)
def solve(n,l,pos):
    if(pos==n):
        return 0
    if(pos==n-1):
        return abs(l[-1]-l[-2])
    if(t[pos]!=-1):
        return t[pos]
    t[pos]=min(abs(l[pos-1]-l[pos])+solve(n,l,pos+1),abs(l[pos-1]-l[pos+1])+solve(n,l,pos+2))
    return t[pos]
n=int(input())
l=list(map(int,input().split()))
global t
t=[-1]*(n+1)
print(solve(n,l,1))
### BUGGY CODE ###

n,w = map(int,input().split())
dp = [[0]*(w+1) for _ in range(n+1)]
ary = [list(map(int,input().split())) for _ in range(n)]
for i in range(n):
    for j in range(w+1):
        if j >= ary[i][0]:
            dp[i+1][j] = max(dp[i][j],dp[i][j-ary[i][0]]+ary[i][1])
        else:dp[i+1][j] = dp[i][j]
print(dp[n][w])

### FIXED CODE ###

nums, weight = map(int,input().split())
ary  = [0 for i in range(nums)]
for i in range(nums):
    ary[i] = list(map(int,input().split()))
dp =[[0 for i in range(weight+1)]for i in range(nums+1)]
 
check = 0
for i in range(nums):
    for x in range(weight+1):
        if x - ary[i][0] >= 0:
            check = dp[i][x -ary[i][0]] + ary[i][1]
            if check > dp[i+1][x]:
                dp[i+1][x] = check
 
        check = dp[i][x]
        if check > dp[i+1][x]:
            dp[i+1][x] = check
 
print(dp[nums][weight])
### BUGGY CODE ###

s = input()
ans = 0
for i in range(len(s) + 1):
    tmp, tmpb = 0, 0
    for j in range(i, len(s)):
        if s[j] == '<':
            break
        tmpb += 1
    
    for j in range(i - 1, -1, -1):
        if s[j] == '>':
            break
        tmp += 1
    ans += max(tmp, tmpb)

print(ans)
    

### FIXED CODE ###

s = input()
ans = 0
t = [0 for i in range(len(s) + 1)]
tmp = 0
for i in range(1, len(s) + 1):
    if s[i - 1] == '<':
        tmp += 1
    else:
        tmp = 0
    t[i] = tmp

ans += t[len(s)]
tmp = 0
for i in range(len(s) - 1, -1, -1):
    if s[i] == '>':
        tmp += 1
    else:
        tmp = 0
    ans += max(tmp, t[i])
    
print(ans)
### BUGGY CODE ###

import bisect
n, d, a = map(int, input().split())
XH = sorted([list(map(int, input().split())) for _ in range(n)])
X, H = zip(*XH)
H = list(H)
K = [-(-i//a) for i in H]
now = 0
ans = 0
for now in range(n):
  l = K[now]
  if l > 0:
    ans += l
    for i in range(now, bisect.bisect_right(X, X[now]+2*d)):
      K[i] -= l
print(ans)

### FIXED CODE ###

import bisect
n, d, a = map(int, input().split())
XH = sorted([list(map(int, input().split())) for _ in range(n)])
X, H = zip(*XH)
K = [-(-i//a) for i in H]
L = [0]*(n+2)
ans = 0
for i in range(n):
  L[i+1] += L[i]
  s = max(K[i]-L[i+1], 0)
  ans += s
  L[i+1] += s
  L[bisect.bisect_right(X, X[i]+2*d)+1] -= s
print(ans)
### BUGGY CODE ###

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

count = 0

for x in range(K+1):
    for y in range(K+1):
        for z in range(K+1):
            if x + y + z == S:
                count += 1
                
print(count)

### FIXED CODE ###

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

count = 0

for x in range(K+1):
    for y in range(K+1):
        if S-x-y >= 0 and K >= S-x-y:
            count += 1
            
print(count)
### BUGGY CODE ###

S=input()
count=0

while 'BW' in S:
    ind=S.index('BW')
    S=S[:ind]+'WB'+S[ind+2:]
    count=count+1

print(count)

### FIXED CODE ###

S=input()

tmp=[i for i, x in enumerate(S) if x == 'W']
print(sum(tmp)-sum(range(len(tmp))))
### BUGGY CODE ###

import sys
import heapq
import math
N, K = map(int, sys.stdin.readline().rstrip().split())
A = list(map(int, sys.stdin.readline().rstrip().split()))
F = list(map(int, sys.stdin.readline().rstrip().split()))
A.sort()
F.sort()

cost = []
for i in range(N):
    cost.append((-A[i] * F[N - 1 - i], A[i], F[N - 1 - i]))
heapq.heapify(cost)

while K > 0:
    max_1, a_1, f_1 = heapq.heappop(cost)
    max_2, a_2, f_2 = heapq.heappop(cost)
    if max_1 == 0:
        break
    c = math.ceil((max_2 - max_1 + 1) / f_1)
    num = min(K, c)
    if num <= a_1:
            heapq.heappush(cost, (min(max_1 + f_1 * num, 0), a_1, f_1))
            heapq.heappush(cost, (max_2, a_2, f_2))
            K -= num
    else:
        heapq.heappush(cost, (min(max_1 + f_1 * a_1, 0), a_1, f_1))
        heapq.heappush(cost, (max_2, a_2, f_2))
        break

print(-cost[0][0])

### FIXED CODE ###

import sys
import math
N, K = map(int, sys.stdin.readline().rstrip().split())
A = list(map(int, sys.stdin.readline().rstrip().split()))
F = list(map(int, sys.stdin.readline().rstrip().split()))
A.sort()
A = A[::-1]
F.sort()

def test(x):
    res = 0
    for i in range(N):
        t = A[i] * F[i]
        if t > x:
            res += math.ceil((t - x) / F[i])
    
    return res <= K

ng = -1
ok = 10**18

while ng + 1 < ok:
    mid = (ng + ok) // 2
    if test(mid):
        ok = mid
    else:
        ng = mid
print(ok)
### BUGGY CODE ###

n = int(input())
s = input()

c = 0

for k in range(n):
    for j in range(k):
        for i in range(j):
            if (k-j) != (j-i):
                if s[i] != s[j] and s[i] != s[k] and s[j] != s[k]:
                    c += 1

print(c)

### FIXED CODE ###

n = int(input())
s = list(input())

r = s.count('R')
g = s.count('G')
b = s.count('B')

# 1つ目の条件を満たす組の数
ans = r * g * b

# 2つ目の条件を満たす組の数
c = 0
for i in range(n):
    for j in range(i+1,n):
        k = 2 * j -i
        if k > n-1:
            break
        if s[i] != s[j] and s[j] != s[k] and s[k] != s[i]:
            c += 1

print(ans - c)
### BUGGY CODE ###

# -*- coding: utf-8 -*-

import sys
args = sys.argv

debug_flg = False
def debug(val1,val2="",val3="",val4=""):
    global debug_flg
    if debug_flg:
        print(val1,val2,val3,val4,sep=" , ")

if len(args) != 2:
    n= int(input())
    s= input()
else:
    debug_flg = True
    if args[1] == "2":
        n=39
        s="RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB"
    elif args[1] == "3":
        n=1
        s="R"
    else:
        n=4
        s="RRGB"

snum = []
for i in range(1,n+1):
    if s[i-1] == "R":
        snum.append(0)
    elif s[i-1] == "G":
        snum.append(1)
    elif s[i-1] == "B":
        snum.append(2)
snum = tuple(snum)

ret =0
for i in range(1,n-1):
    for j in range(i,n):
        if snum[i-1] == snum[j-1]:
            continue
        for k in range(j,n+1):
            if j-i == k-j:
                continue
            if snum[i-1] == snum[k-1]:
                continue
            if snum[j-1] == snum[k-1]:
                continue
            ret += 1

print(ret)






### FIXED CODE ###

def main():
    n= int(input())
    s= input()

    r = s.count("R")
    g = s.count("G")
    b = s.count("B")

    ans = r * g * b
    snum = tuple(s[:])
    for i in range(1,n-1):
        for j in range(i,n):
            k = j * 2 - i
            if k > n:
                break

            if snum[i-1] != snum[j-1] and snum[i-1] != snum[k-1] and snum[j-1] != snum[k-1]:
                ans -= 1

    print(ans)


if __name__ == '__main__':
    main()
### BUGGY CODE ###

N = int(input())
X = tuple(map(int, input().split()))
Y = X[::-1]
for k in range(N):
    try:
        i = Y.index(k+1)
        Y = Y[:i]
    except:
        i = -1
        leng = k
        break
    leng = k + 1
if leng == 0:
    ans = -1
else:
    ans = N - leng
print(ans)

### FIXED CODE ###

N = int(input())
X = tuple(map(int, input().split()))

c = 0
for x in X:
    if x == c+1:
        c+=1
if c == 0:
    ans = -1
else:
    ans = N-c
print(ans)
### BUGGY CODE ###

m = 10**9+7
n = 1
a = ab = abc = 0
for c in input():
    if c == 'A':
        a += n
    elif c == 'B':
        ab += a
    elif c == 'C':
        abc += ab
    else:
        ta, tab = a, ab
        a *= 3
        ab *= 3
        abc *= 3
        a += n
        ab += ta
        abc += tab
        n *= 3
    a %= m
    ab %= m
    abc %= m
print(abc)


### FIXED CODE ###

m = 10**9+7
n = 1
a = ab = abc = 0
for c in input():
    if c == 'A':
        a += n
    elif c == 'B':
        ab += a
    elif c == 'C':
        abc += ab
    else:
        ta, tab = a, ab
        a *= 3
        ab *= 3
        abc *= 3
        a += n
        ab += ta
        abc += tab
        n *= 3
    a %= m
    ab %= m
    abc %= m
    n %= m
print(abc)
### BUGGY CODE ###

n = int(input())
ans = 0
for i in range(0,n):
  ans += i
print(ans)

### FIXED CODE ###

n = int(input())
print((n*(n-1))//2)
### BUGGY CODE ###

import numpy as np

n = int(input())
a = list(map(int, input().split()))
a_np = np.array(a)
a_np = np.roll(a_np, 1)
counter = [0 for _ in range(n)]
for i in range(n - 1):
    index = list(np.where(a % a_np == 0))
    for n in index[0]:
        counter[int(n)] += 1
    a_np = np.roll(a_np, 1)
print(counter.count(0))

### FIXED CODE ###

import numpy as np
 
n = int(input())
a = list(map(int, input().split()))
a.sort()
dp = [0 for _ in range(a[-1] + 1)]

for x in a:
    for j in range(x, a[-1] + 1, x):
        dp[j] += 1
ans = 0
for x in set(a):
    #print(x)
    if dp[x] == 1:
        ans += 1
print(ans)
### BUGGY CODE ###

n = int(input())
a = list(map(int, input().split()))
mod = 10**9+7
s = 0
for i in range(n-1):
    for j in range(i+1, n):
        s += (a[i]%mod*a[j]%mod)%mod
        s %= mod
print(s)
    

### FIXED CODE ###

n = int(input())
a = list(map(int, input().split()))
mod = 10**9+7
s = 0
l = [0 for i in range(n)]
l[0] = a[0]
for i in range(1, n):
    l[i] += l[i-1]
    l[i]%=mod
    l[i] += a[i]
    l[i]%=mod
# print(l)
for i in range(1, n):
    s+=((a[i]%mod)*(l[i-1]%mod))%mod
    s%=mod
print(s)
### BUGGY CODE ###

import math

n = input()
a = input().split()
N = int(n)

ann = []
for i in range(N):
    ana = 1
    for j in range(i+1):
        ana = ana * int(a[j])
    ann.append(ana-1)

ans_list = []
for i in ann:
    ans = 0
    for j in range(N):
        ans += int(i % int(a[j]))
    ans_list.append(ans)

ans_list.sort()
ans_list.reverse()
print(str(ans_list[0]))





### FIXED CODE ###

import math

n = input()
a = input().split()
N = int(n)

ans_list = []
ann = []
ana = 1
for j in range(N):
    ana = ana * int(a[j])
ana = ana -1
ans = 0
for k in range(N):
    ans += int(ana % int(a[k]))
ans_list.append(ans)

ans_list.sort()
ans_list.reverse()
print(str(ans_list[0]))
### BUGGY CODE ###

n, y = map(int, input().split())
y = int(y / 1000)

xmax = int(y / 10)
ymax = int(y / 5)
zmax = y

for nx in reversed(range(0, xmax+1)):
   for ny in reversed(range(0, ymax+1)):
      nz = n - nx - ny
      yy = 10 * nx + 5 * ny + nz
      if (nz >= 0 and nz <= zmax and yy == y):
         print(nx, ny, nz)
         exit()

print(-1, -1, -1)


### FIXED CODE ###

n, y = map(int, input().split())

for i in range(n+1):
   for j in range(n-i+1):
      if (10000 * i + 5000 * j + 1000 * (n - i - j) == y):
         print(i, j, n - i - j)
         exit()

print(-1, -1, -1)
### BUGGY CODE ###

a,b=map(int,input().split())
List=list(map(int,input().split()))
t=-1
for i in range(a-b+1):
    if sum(List[i:i+b]) >t:
        t=sum(List[i:i+b])
print((t+b)/2)

### FIXED CODE ###

a,b=map(int,input().split())
List=list(map(int,input().split()))
t=-1
S=[0]
for i in range(a):
    S+=[S[i]+List[i]]
t=-1
for i in range(a-b+1):
    if S[i+b]-S[i]>t:
        t=S[i+b]-S[i]
print((t+b)/2)
### BUGGY CODE ###

N = int(input())
A = list(map(int,input().split()))
E =[]
for i in range(1,N+1):
  E.append(int(int(A.index(i))+1))
for i in range(0,N): 
  print(str(int(E[i]))+' ',end = '')

### FIXED CODE ###

N = int(input())
A = list(map(int,input().split()))
D = [0]*N
for i in range(N):
  a = A[i]
  D[a-1] = i+1
d = str(D[0])
for i in range(1,N):
  d += ' '+str(D[i])
print(d)
### BUGGY CODE ###

# -*- coding: utf-8 -*-

N = int(input())
S = input()

# 累積和を使う方法
W_ruiseki = []
E_ruiseki = []
# 0地点を含めたN+1パターンを予め用意しておく
for i in range(N+1):
    W_ruiseki.append(S[:i].count("W"))
    E_ruiseki.append(i - W_ruiseki[i])

ans = float("inf")
for i in range(N):
    cnt = 0
    cnt += W_ruiseki[i]
    cnt += E_ruiseki[N] - E_ruiseki[i+1]
    ans = min(ans, cnt)

print(ans)

### FIXED CODE ###

# -*- coding: utf-8 -*-

N = int(input())
S = input()

# 初期値設定
cnt = S[1:].count("E")
ans = cnt
# 結局自分と1個前しか変化しない
for i in range(1, N):
    if S[i] == "E":
        cnt -= 1
    if S[i-1] == "W":
        cnt += 1
    ans = min(ans, cnt)

print(ans)
### BUGGY CODE ###

import math
A,B,N=map(int,input().split())
maxval=0
for x in range(N+1):
    if(maxval<=math.floor(A*x/B)-A*math.floor(x/B)):
        maxval=math.floor(A*x/B)-A*math.floor(x/B)
        ans=x
print(maxval)   

### FIXED CODE ###

import math
A,B,N=map(int,input().split())
if(N<B):
    x = N
else:
    x =B-1    

print(int( math.floor(A*x/B)-A*math.floor(x/B)  ))
### BUGGY CODE ###

def lcs(x,y):
    xs = len(x)
    ys = len(y)
    x = " " + x
    y = " " + y
    c = [[0 for i in xrange(len(x))] for j in xrange(len(y))]
    for i in xrange (1,ys+1):
        for j in xrange (1,xs+1):
            if x[j] == y[i]:
                a = 1
            else:
                a = 0
            c[i][j] = max(c[i][j-1],c[i-1][j],c[i-1][j-1] + a)
    return max(max(c))
n = input() 
for i in xrange (n): 
    x = raw_input()
    y = raw_input() 
    print lcs(x,y)

### FIXED CODE ###

def lcs():
    x, y = raw_input(), raw_input()
    b1 = [0 for k in range(len(y)+1)]
    for i in xrange(len(x)):
        a = x[i]
        b2 = b1 + []
        for j in xrange(len(y)):
            if a == y[j]:
                b1[j+1] = b2[j] + 1
            elif b1[j+1] < b1[j]:
                b1[j+1] = b1[j]
    print max(b1)
 
n = input()
for i in xrange(n):
    lcs()
### BUGGY CODE ###

n = int(input())
a = list(map(int, input().split()))
for i in range(1,n+1):
    print(a.index(i)+1,end=" ")
 

### FIXED CODE ###

n = int(input())
A = list(map(int, input().split()))
rev = [0]*(n)
for i in range(n):
    rev[A[i]-1] = i+1
print(" ".join(map(str, rev)))