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

s = input()
t = s.replace("LR","L,R")
# print(t)
u = t.split(",")
# print(u)
ans = []
for i in range(len(u)):
    # print(u[i])
    j = u[i].find("RL")
    # print(j)
    numR = j+1
    numL = len(u[i])-(j+1)
    a = [0]*len(u[i])
    a[j] = (numR+1)//2 + (numL)//2
    a[j+1] = (numR)//2 + (numL+1)//2
    ans = ans + a
print(" ".join(map(str, ans)))

### FIXED CODE ###

s = input()
l = len(s)
ans = [0]*l
count = 0
for i in range(l):
    if s[i]=="R" and s[i+1]=="R":
        count += 1
    elif s[i]=="R" and s[i+1]=="L":
        count += 1
        ans[i] += (count+1)//2
        ans[i+1] += count//2
        count = 0
for i in reversed(range(l)):
    # print(i)
    # print(s[i])
    if s[i]=="L" and s[i-1]=="L":
        count += 1
    elif s[i]=="L" and s[i-1]=="R":
        count += 1
        ans[i] += (count+1)//2
        ans[i-1] += count//2
        count = 0
print(" ".join(map(str, ans)))
### BUGGY CODE ###

a,b,k = map(int,input().split())
for i in range(a,b+1):
    if i <= a+k-1 or i >= b-k+1:
        print(i)


 


### FIXED CODE ###

a,b,k = map(int,input().split())
if b+1-a <= k*2:
    for i in range(a,b+1):
        print(i)
else:
    for j in range(a,a+k):
        print(j)
    for l in range(b-k+1,b+1):
        print(l)
### BUGGY CODE ###

import math
import numpy as np

def main():
    h,w,k = tuple([int(t)for t in input().split()])

    s = [[int(i) for i in list(input())] for _ in range(h)]
    
    s = np.array(s)

    candidates = []

    for i in range(1<<h):
        s_subs = divide(s,i)
        cutnum = 0
        pos = 0
        subsum = np.array([0]*len(s_subs))
        j = 0
        while j<w:
            temp = np.array([np.sum(s_[:,j]) for s_ in s_subs])
            if any([s_>k for s_ in temp]):
                cutnum = -1-bin(i).count('1')
                break

            subsum = subsum+temp
            if any([s_>k for s_ in subsum]):
                cutnum+=1
                subsum = np.array([0]*len(s_subs))
                j-=1
            
            j+=1

        candidates.append((bin(i).count('1')+cutnum))

    print(min([t for t in candidates if t>=0]))

def divide(s,i):
    subs = []
    counter = 0
    pos = 0
    while i!= 0:
        counter +=1
        if i%2==1:
            subs.append(s[pos:counter])
            pos = counter
        i >>=1

    subs.append(s[pos:])
    return subs
    
if __name__ == "__main__":
    main()

### FIXED CODE ###

import math
import functools
from operator import add

def main():
    h,w,k = tuple([int(t)for t in input().split()])

    s = [[int(i) for i in list(input())] for _ in range(h)]
    
    cusum = [accumelist(s_) for s_ in s]

    candidates = []

    for i in range(1<<(h-1)):
        subcu = divide(cusum,i)
        subs = divide(s,i)

        subcusum = []

        rowsum = []

        for sub_ in subcu:
            subcusum.append(functools.reduce((lambda a,b:list(map(add,a,b))),sub_))

        for sub_ in subs:
            rowsum.append(functools.reduce((lambda a,b:list(map(add,a,b))),sub_))


        cutnum = 0

        temp = [0]*len(subcusum)

        for j in range(w):
            for l in range(len(subcusum)):
                if subcusum[l][j]-temp[l]>k:
                    if rowsum[l][j]>k:
                        cutnum+=10000
                    temp = [x[j-1] for x in subcusum]
                    cutnum+=1
                    break
        
        candidates.append(cutnum+bin(i).count('1'))

    print(min(candidates))
            
def divide(s,i):
    subs = []
    counter = 0
    pos = 0
    while i!= 0:
        counter +=1
        if i%2==1:
            subs.append(s[pos:counter])
            pos = counter
        i >>=1
 
    subs.append(s[pos:])
    return subs

def accumelist(s):
    if s == []:
        return []
    res = [s[0]]
    for i in range(1,len(s)):
        res.append(res[i-1]+s[i])

    return res

def _add_(a,b):
    return map(add,a,b)
    
if __name__ == "__main__":
    main()
### BUGGY CODE ###

n, m = map(int, input().split())
a = sorted(list(map(int, input().split())))

for _ in range(m):
    a[-1] //= 2
    a = sorted(a)

print(sum(a))

### FIXED CODE ###

import heapq

n, m = map(int, input().split())
a = [-int(i) for i in input().split()]

heapq.heapify(a)

for _ in range(m):
    temp = heapq.heappop(a)
    temp = -(-temp//2)
    heapq.heappush(a, temp)

print(-sum(a))
### BUGGY CODE ###

n, m = list(map(int, input().split(' ')))
aaa = list(map(int, input().split(' ')))
len_aaa = len(aaa)
# 全部混ぜて長さがaの分だけ多きい方から取る
for i in range(m):
    b, c = list(map(int, input().split(' ')))
    ccc = [c] * b
    aaa = sorted(ccc + aaa)[::-1][:len_aaa]
print(sum(aaa))

### FIXED CODE ###

import bisect
n, m = list(map(int, input().split(' ')))
aaa = list(map(int, input().split(' ')))
aaa = sorted([-a for a in aaa])[::-1]
len_aaa = len(aaa)

cccbbb = []
for i in range(m):
    b, c = list(map(int, input().split(' ')))
    cccbbb.append((-c, b))
cccbbb = sorted(cccbbb)
ccc = []
for c, b in cccbbb:
    ccc += [c] * b
    if len(ccc) > len_aaa:
        break
ans = 0
for i in range(len_aaa):
    c = ccc[i] if i < len(ccc) else 0
    ans += min(aaa[i], c)
print(abs(ans))
### BUGGY CODE ###

k,s = map(int,input().split())

counter = 0

for x in range(k+1):
    if s-x > 2 * k:
        continue
    for y in range(k+1):
        if s-x-y > k:
            continue
        elif s-x-y <= k and s-x-y >=0:
            counter += 1
                
print(counter)

### FIXED CODE ###

k,s = map(int,input().split())
counter = 0

for x in range(k+1):
    if s-x > 2*k:
        continue
    for y in range(k+1):
        if s-x-y > k or s-x-y < 0:
            continue
        else:
            counter += 1
            
print(counter)
### BUGGY CODE ###

n=int(input())
a=list(map(int,input().split()))
 
b=list(set(a))
c=0
for i in b:
    c+= a.count(i) - i if a.count(i) - i>=0 else a.count(i) 
print(c)

### FIXED CODE ###

from collections import Counter

n=int(input())
a=list(map(int,input().split()))
counter=Counter(a)
b=list(set(a))
c=0
for i in b:
    k =  counter[i]
    c+= k-i if k-i>=0 else k
print(c)
### BUGGY CODE ###

n,W=map(int,input().split())
wv=[list(map(int,input().split())) for _ in range(n)]
dp=[0]*(W+1)
for w,v in wv:
    for i in range(W,w-1,-1):
        nv=dp[i-w]+v
        if nv>dp[i]:
            dp[i]=nv
print(dp[-1])

### FIXED CODE ###

import sys
input=sys.stdin.readline

n, cap = map(int, input().split())
val =[0]*(cap+1)
def nap(n,cap):
    for _ in range(n):
        w, v = map(int, input().split())
        for wk in range(cap,w-1,-1):
            nv=val[wk-w]+v
            if val[wk]<nv:
                val[wk]=nv
    return max(val)
print(nap(n,cap))
### BUGGY CODE ###

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

l -= 1
r -= 1

for k in range(1, n):
    res = 0
    #print("l",l, "r",r)
    for a in range(n):
        for b in range(a+1, n):
            #print("from", a, "to", b)
            c = 9999999999
            c = min(c, b - a)
            #print(" dire", c)
            c = min(c, abs( abs(l - a) + abs(r - b) ) + 1 )
            #print(" warp", abs(l - a) + abs(r - b) +1,abs(l - a),  abs(r - b))
            if c == k:
                #print(" hit!!!!!!!!!!", k)
                res += 1
    print(res)


### FIXED CODE ###

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

l -= 1
r -= 1

dist = [0] * 10000000

for a in range(n):
    for b in range(a+1, n):
        #print("from", a, "to", b)
        c = 9999999999
        c = min(c, b - a)
        #print(" dire", c)
        c = min(c, abs( abs(l - a) + abs(r - b) ) + 1 )
        dist[c] += 1
for k in range(1, n):
    print(dist[k])
### BUGGY CODE ###

a, b = map(int, input().split())
ans = 0
for i in range(a, b + 1):
    ans ^= i
print(ans)

### FIXED CODE ###

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

def f(x):
    res = 0
    while x % 4 != 3:
        res ^= x
        x -= 1
    
    return res

print(f(a - 1) ^ f(b))
### BUGGY CODE ###

num = int(input())
list = []
min = 0
for i in range(1,num+1):
    p = num/i
    if p.is_integer() == True:
        if list.count(i) == 0 and list.count(int(p)) == 0:
            list.append(i)
            list.append(int(p))
    

l = len(list)
list.sort()
if l%2 == 1:
    min = list[int((l/2))]*2-2
else:
    min = list[int(l/2)-1]+list[int(l/2)]-2
print(min)

### FIXED CODE ###

n = int(input())
ans = n-1
d = 1
while d*d <= n:
    if n%d == 0:
        e = n//d
        ans = min(ans,d-1+e-1)
    d+=1
print(ans)
### BUGGY CODE ###

a = []
a = input().split()
H = int(a[0])
N = int(a[1])
A = input().split()
A = [int(i) for i in A]

#print('H=', H, 'N=', N)
#print('A=', A)

for i in range(N):
  n = A.index(max(A))
#  print('n=', n)
  H = H - max(A)
  A.remove(A[n])
#  print('A=', A)

if H <= 0:
  print('Yes')
if H > 0:
  print('No')



### FIXED CODE ###

a = []
a = input().split()
H = int(a[0])
N = int(a[1])
A = input().split()
A = [int(i) for i in A]

#print('H=', H, 'N=', N)
#print('A=', A)

#for i in range(N):
#  n = A.index(max(A))
#  print('n=', n)
#  H = H - max(A)
#  A.remove(A[n])
#  print('A=', A)

T = sum(A)
H = H - T


if H <= 0:
  print('Yes')
if H > 0:
  print('No')
### BUGGY CODE ###

n = int(input())
a= list(map(int, input().split()))
s = [0]*n
ans1 = 0
ans2 = ""
for i in range(1, n+1):
  temp = sum(s[n-i::n+1-i])
  if (temp % 2 == 0 and a[-i] == 1) or (temp % 2 == 1 and a[-i] == 0) :
    s[-i] = 1
    ans1 += 1
    ans2 = str(n+1-i) + " " + ans2

print(ans1)
print(ans2)

### FIXED CODE ###

n = int(input())
a= list(map(int, input().split()))
s = [0]*n
ans2 = []
for i in range(1, n+1):
  temp = sum(s[n-i::n+1-i])
  if (temp % 2 == 0 and a[-i] == 1) or (temp % 2 == 1 and a[-i] == 0) :
    s[-i] = 1
    ans2.append(str(n+1-i)) 

ans2.reverse()
print(sum(s))
print(" ".join(ans2))
### BUGGY CODE ###

N = int(input())
P = list(map(int,input().split()))
ans = 0
for i in range(N):
    flag = True
    for j in range(i):
        if P[i] > P[j]:
            flag = False
            break
    if flag:
        ans += 1
print(ans)

### FIXED CODE ###

N = int(input())
P = list(map(int,input().split()))
ans = 0
minx = 10**9
for i in range(N):
    if minx > P[i]:
        ans += 1
        minx = P[i]
print(ans)
### BUGGY CODE ###

N = int(input())
list = list(map(int, input().split()))
no = 0 
ans = 1
if list.count("0") >0:
  print("0")
  exit()
else:
  for i in range(N):
    ans = ans * list[no]
    no += 1
print(ans if ans <= 10**18 else "-1")

### FIXED CODE ###

def resolve():
    N = int(input())
    A = list(map(int, input().split()))
    ans = 1
    if 0 in A:
        print(0)
        exit()
    for i in A:
        ans *= i
        if ans > 10**18:
            print(-1)
            exit()
    print(ans)
resolve()
### BUGGY CODE ###

import collections

S = input()
N = len(S)
l = []
for i in range(N):
    l.append(int(''.join(S[i:N]))%2019)

c = collections.Counter(l)

values, counts = zip(*c.most_common())
counts = list(counts)

try:
    ans = counts.pop(list(values).index(0))
except:
    ans = 0

for i in range(len(counts)):
    if counts[i] != 1:
        ans += counts[i] * (counts[i]-1) // 2

print(ans)

### FIXED CODE ###

S = list(input())
N = len(S)

l = [0] * 2019
temp = 0
e = 1
for i in range(N-1, -1, -1):
    temp += int(S[i]) * e
    temp %= 2019
    l[temp] += 1
    e *= 10
    e %= 2019

ans = l[0]

for i in range(0, 2019):
    ans += l[i] * (l[i]-1) // 2

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

n_a,n_b,M=map(int,input().split())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
price=[]
for i in range(M):
    X=list(map(int,input().split()))
    price.append(A[X[0]-1]+B[X[1]-1]-X[2])
for i in range(n_a):
    for j in range(n_b):
        price.append(A[i]+B[j])
print(min(price))

### FIXED CODE ###

n_a,n_b,M=map(int,input().split())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
price=[]
for i in range(M):
    X=list(map(int,input().split()))
    price.append(A[X[0]-1]+B[X[1]-1]-X[2])
price.append(min(A)+min(B))
print(min(price))
### BUGGY CODE ###

from collections import Counter
import sys
N, K = map(int, input().split())
a_lis = [int(_) for _ in input().split()]
count = 0
counter = sorted(Counter(a_lis).items(), key=lambda x: x[1])
while len(counter) > K:
    count += counter[0][1]
    counter.pop(0)
    if len(counter) == K:
        print(count)
        sys.exit()
print(0)

### FIXED CODE ###

from collections import Counter
import sys
N, K = map(int, input().split())
a_lis = [int(_) for _ in input().split()]

counter = sorted(Counter(a_lis).items(), key=lambda x: x[1])

if len(counter) > K:
    ans_list = counter[:len(counter) - K]
    count = sum([item[1] for item in ans_list])
    print(count)
    sys.exit()

print(0)
### BUGGY CODE ###

n, k = map(int, input().split(" "))
p = list(map(int, input().split(" ")))
p2 = []

for x in range(n - k + 1):
    c = 0
    for y in range(k):
        c += p[x + y]
    p2.append(c)

a = max(p2)

print((a + k)/2)


### FIXED CODE ###

n, k = map(int, input().split(" "))
p = list(map(int, input().split(" ")))
e = []
s = [0]
sj = []

for x in p:
    e.append((1 + x) / 2)

for x in range(n):
    s.append(s[x] + e[x])

for x in range(k, n + 1):
    sj.append(s[x] - s[x - k])
    
print(max(sj))
### BUGGY CODE ###

import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush,heapify
from math import ceil, floor, sqrt
from copy import deepcopy

def main():
    n = int(input())
    a_list = list(map(int, input().split()))
    q = int(input())
    max_num = sum(a_list)
    ans = [0]*q
    for i in range(q):
        b,c = map(int, input().split())
        count = 0
        for j in range(n):
            if b==a_list[j]:
                count += 1
                a_list[j] = c
        
        max_num += (c - b)*count
        ans[i] = max_num

    for i in ans:
        print(i)
   
if __name__ == "__main__":
    main()

### FIXED CODE ###

import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush,heapify
from math import ceil, floor, sqrt
from copy import deepcopy

def main():
    max_num = 10**5
    n = int(input())
    a_list = list(map(int, input().split()))
    q = int(input())
    
    query = [map(int, input().split()) for _ in range(q)]
    num = [0 for _ in range(max_num+1)]
    for i in a_list:
        num[i] += 1

    ans = sum(a_list)

    for b,c in query:
        n = num[b]
        num[b] = 0
        num[c] += n
        ans += (c-b)*n
        print(ans)

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

n = int(input())
a = list(map(int,input().split()))
b = [0]*n
tmp=[]
ans=""
for i in range(n-1,-1,-1):
  num = i+1
  total=0
  for j in range(i,n):
    if (j+1)%(i+1)==0:
      total+=b[j]
  if total%2==a[i]:
    b[i]=0
  else:
    b[i]=1
    tmp.append(i+1)

print(sum(b))
tmp = sorted(tmp)

for i in range(len(tmp)):
  ans += str(tmp[i]) + " "
print(ans)

### FIXED CODE ###

n = int(input())
a = list(map(int,input().split()))
b = [0]*n
tmp=[]
ans=""
for i in range(n-1,-1,-1):
  num = i+1
  total=0
  j=1
  while (i+1)*j <= n:
    total+=b[((i+1)*j)-1]
    j+=1  
  if total%2==a[i]:
    b[i]=0
  else:
    b[i]=1
    tmp.append(i+1)

print(sum(b))
print(str(sorted(tmp)).replace(',','').replace('[','').replace(']',''))
### BUGGY CODE ###

# -*- coding: utf-8 -*-
"""
C - Linear Approximation
https://beta.atcoder.jp/contests/abc102/tasks/arc100_a

"""
import sys
from sys import stdin
input = stdin.readline

from functools import lru_cache
def solve(arr):
    @lru_cache(maxsize=None)
    def calc_score(n):
        return sum([abs(a-(n+i)) for i, a in enumerate(arr, start=1)])

    ub = max(arr)
    lb = -max(arr)

    while True:
        mid1 = (lb*2 + ub) // 3
        mid2 = (lb + ub*2) // 3
        mid1_score = calc_score(mid1)
        mid2_score = calc_score(mid2)

        if mid2_score > mid1_score:
            ub = mid2
        else:
            lb = mid1
        if abs(ub - lb) <= 4:
            break

    ans = float('inf')
    for b in range(lb, ub+1):
        t = calc_score(b)
        ans = min(ans, t)
    return ans


def main(args):
    N = int(input())
    arr = [int(a) for a in input().split()]
    ans = solve(arr)
    print(ans)


if __name__ == '__main__':
    main(sys.argv[1:])


### FIXED CODE ###

# -*- coding: utf-8 -*-
"""
C - Linear Approximation
https://beta.atcoder.jp/contests/abc102/tasks/arc100_a
TLE
"""
import sys
from sys import stdin
input = stdin.readline

from functools import lru_cache
def _solve(arr):
    @lru_cache(maxsize=None)
    def calc_score(n):
        return sum([abs(a-(n+i)) for i, a in enumerate(arr, start=1)])

    ub = max(arr)
    lb = -max(arr)

    while True:
        mid1 = (lb*2 + ub) // 3
        mid2 = (lb + ub*2) // 3
        mid1_score = calc_score(mid1)
        mid2_score = calc_score(mid2)

        if mid2_score > mid1_score:
            ub = mid2
        else:
            lb = mid1
        if abs(ub - lb) <= 4:
            break

    ans = float('inf')
    for b in range(lb, ub+1):
        t = calc_score(b)
        ans = min(ans, t)
    return ans


from statistics import median

def solve(arr):
    def calc_score(n):
        return sum([abs(a-(n+i)) for i, a in enumerate(arr, start=1)])

    array_b = [a-i for i, a in enumerate(arr, start=1)]
    m = median(array_b)
    ans = float('inf')
    for i in range(int(m)-1, int(m)+2):
        ans = min(ans, calc_score(i))
    return ans



def main(args):
    N = int(input())
    arr = [int(a) for a in input().split()]
    ans = solve(arr)
    print(ans)


if __name__ == '__main__':
    main(sys.argv[1:])
### BUGGY CODE ###

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

cnt = 1
for i in range(N):
  if i >= 1 and p[i] <= min(p[0:i]):
      cnt += 1
print(cnt)


### FIXED CODE ###

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

cnt = 0
for n in p:
  if n == p[0]:
    cnt += 1
    min = n
  elif min >= n:
    cnt += 1
    min = n
print(cnt)
### BUGGY CODE ###

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

for i in range(N):
    answer=0
    removed=[lst[j] for j in range(N) if j!=i]
    for el in set(removed):
        el_num=removed.count(el)
        answer+=el_num*(el_num-1)//2
    print(answer)

### FIXED CODE ###

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

import collections

dct=collections.Counter(lst)


#for i in range(N):
Sum=0
for v in dct.values():
        Sum+=v*(v-1)//2


for i in range(N):
    print(Sum-dct[lst[i]]+1)
### BUGGY CODE ###

N = input().split()
n= int(N[0])
m = int(N[1])
way = [[0] * n  for _ in range(n+1)]
count = 0
h = input().split()
ans = 0
w =0
for i in h:
    way[0][count] = int(i)
    count += 1

for j in range(m):
    a = input().split()
    b = int(a[0])
    c = int(a[1])
    way[b][c-1] += 1
    way[c][b-1] += 1

for k in range(n):
    p = [i for i, x in enumerate(way[k+1]) if x != 0]

    w=0
    if len(p) ==0:
        ans+=1
    for l in p:
        w +=1
        if(way[0][k] > way[0][l]):
            if w == len(p):
                ans += 1
            continue
        else:
            break


print(ans)

### FIXED CODE ###

import numpy as np

N = input().split()
n= int(N[0])
m = int(N[1])
way = np.zeros(n)
count = 0
h = input().split()
ans = 0
w =0
r = np.zeros(n)

for j in range(m):
    a = input().split()
    b = int(a[0])
    c = int(a[1])
    if int(h[b-1])>int(h[c-1]):
        r[b-1] += 1
        r[c-1] = -1000000
    elif int(h[c-1])>int(h[b-1]):
        r[c-1] += 1
        r[b-1] = -1000000
    else:
        r[b-1] = -1000000
        r[c-1] = -1000000
print(np.count_nonzero(r>=0))
### BUGGY CODE ###

n,p = map(int,input().split())
s = input()
num = 0
s1 = [0]*(n+1)
ans = 0
if p == 2 or p == 5:
	for i in range(len(s)):
		if int(s[i])%p == 0:
			ans += i+1	
	print(ans)
	exit()
ans = 0
for i in range(n+1):
	s1[i] = int(s)%(10**i)%p
arr = [0]*p
for i in range(n+1):
	arr[s1[i]] += 1
for i in range(p):
	ans += arr[i] * (arr[i] - 1) // 2
print(ans)


### FIXED CODE ###

def main():
	N,P = map(int,input().split())
	S = [int(s) for s in list(input().strip())][::-1]
	num = 0
	ans = 0
	if P == 2 or P == 5:
		for i in range(N):
			if S[i]%P == 0:
				ans += N-i
		print(ans)
		return
	L = [0]*P
	L[0]=1
	t = 0
	s = 1
	for z in S:
		t = (z*s+t)%P	
		L[t]+=1
		s=s*10%P
	for l in L:
		ans += l * (l - 1) // 2
	print(ans)

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

import bisect
import sys
input = sys.stdin.readline

n, m = map(int, input().split())
A = list(map(int, input().split()))
A.sort()

for _ in range(m):
    max_price = A.pop(-1) // 2
    bisect.insort(A, max_price)

total = sum(A)
print(total)


### FIXED CODE ###

import heapq
import sys
input = sys.stdin.readline

n, m = map(int, input().split())
A = map(int, input().split())
A = list(map(lambda x: x*(-1), A))
heapq.heapify(A)

for _ in range(m):
    max_price = -heapq.heappop(A) // 2
    heapq.heappush(A, -max_price)

total = -sum(A)
print(total)
### BUGGY CODE ###

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

B = []
for i in range(1, N+1):
    B.append(A.index(i)+1)

import numpy as np
C = str(np.array(B))
print(C[1:-1])


### FIXED CODE ###

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

B = [0] * N
for i, a in enumerate(A):
    B[a-1] = i + 1

print(*B)
### BUGGY CODE ###

N=int(input())
S=input()
key_list = {}

LENGTH = len(S)
count = 0
for i in range(LENGTH):
  for j in range(i+1,LENGTH):
    for k in range(j+1,LENGTH):
      #print(i,j,k)
      target = str(S[i]+S[j]+S[k])
      #print(target)
      if target in key_list:
        #print("exist")
        pass
      else:
        key_list[target] = 0
        count += 1
print(count)

### FIXED CODE ###

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


count = 0
for i in range(1000):
  if i < 100:
    target_1 = "0"
    if i < 10:
      target_2 = "0"
      target_3 = str(i)
    else:
      target_2 = str(i)[0]
      target_3 = str(i)[1]
  else:
    target_1 = str(i)[0]
    target_2 = str(i)[1]
    target_3 = str(i)[2]
  
  step = 1
  for j in range(N):
    if S[j] == target_1 and step == 1:
      step = 2
      pass
    
    elif S[j] == target_2 and step == 2:
      step = 3
      
    elif S[j] == target_3 and step == 3:
      count += 1
      break

print(count)
### BUGGY CODE ###

from math import gcd

n = int(input())
a = list(map(int, input().split()))
MAX = 10 ** 6


def sieve(x):
    """
    Sieve of Eratosthenes
    :param x: max value
    :return: list of bool
    """

    is_prime = [True] * (x + 1)
    is_prime[0] = is_prime[1] = False

    for i in range(2, x + 1):
        if is_prime[i]:
            for j in range(i * 2, x + 1, i):
                is_prime[j] = False

    return is_prime


is_prime = sieve(MAX)
primes = [i for i, e in enumerate(is_prime) if e]
a.sort()

bl = True
for e in a:
    nxt = []
    for e2 in primes:
        if e % e2 != 0:
            nxt.append(e2)
        else:
            while e % e2 == 0:
                e //= e2

    if e != 1:
        bl = False

    primes = nxt

g = a[0]
for e in a:
    g = gcd(g, e)

if g == 1 and bl:
    ans = "pairwise coprime"
elif g == 1:
    ans = "setwise coprime"
else:
    ans = "not coprime"

print(ans)


### FIXED CODE ###

from math import gcd
import numpy as np
from numba import njit

n = int(input())
a = list(map(int, input().split()))
MAX = 10 ** 6

g = a[0]
for e in a:
    g = gcd(g, e)

if g != 1:
    print("not coprime")
    exit()

nums = np.zeros(MAX + 1, np.int64)
for e in a:
    nums[e] += 1


@njit
def f(nums):
    for i in range(2, MAX + 1):
        if nums[i::i].sum() > 1:
            return False

    return True


bl = f(nums)

if bl:
    print("pairwise coprime")
else:
    print("setwise coprime")