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

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


def main():
    n = int(input())
    a = list(map(int, input().split()))
    a_sorted = sorted(a)

    result = []
    for i in range(1, n + 1):
        result.append(a.index(i) + 1)
    print(*result, sep=' ')


if __name__ == '__main__':
    main()


### FIXED CODE ###

# -*- coding: utf-8 -*-
import numpy as np
import sys
input = sys.stdin.readline


def main():
    n = int(input())
    a = list(map(int, input().split()))
    a = np.argsort(np.array(a))+1
    # print(a)
    # result = []
    # for i in range(1, n + 1):
    #     result.append(a.where(lambda x: x == i))
    print(*a, sep=' ')


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

S = input()
Q = int(input())
Queries = [[j for j in input().split()] for i in range(Q)]

f = 0
for query in Queries:
    if query[0] == "1":
        if f == 0:
            f = 1
        else:
            f = 0
    else:
        if f == 0:
            if query[1] == "1":
                S = query[2] + S
            else:
                S = S + query[2]
        else:
            if query[1] == "2":
                S = query[2] + S
            else:
                S = S + query[2] 
if f == 1:
    S = S[::-1]
print(S)

### FIXED CODE ###

S = input()
Q = int(input())

front = ""
end = ""
f = 0
for i in range(Q):
    query = input().split()

    if query[0] == "1":
        if f == 0:
            f = 1
        else:
            f = 0
    else:
        if f == 0:
            if query[1] == "1":
                front = query[2] + front
            else:
                end = end + query[2]
        else:
            if query[1] == "2":
                front = query[2] + front
            else:
                end = end + query[2]

S = front + S + end
if f == 1:
    S = S[::-1]
print(S)
### BUGGY CODE ###

class TupleQueue:

    def __init__(self, bufsize):
        self.start = 0
        self.end = 0
        self.buffer = [(None, None) for _ in range(bufsize)]

    def enqueue(self, t):
        self.buffer[self.end] = t
        self.end += 1

    def dequeue(self):
        if self.start != self.end:
            item = self.buffer[self.start]
            self.start += 1
            return item
        return None

    def clear(self):
        self.start = 0
        self.end = 0

    def is_empty(self):
        if self.start == self.end:
            return True
        return False


h, w = map(int, input().split())
que = TupleQueue(h * w)
nxt = TupleQueue(h * w)

data = []

for ln in range(h):
    line = list(input().rstrip())
    data.append(line)
    for r, letter in enumerate(line):
        if letter == '#':
            que.enqueue((ln, r))

count = 0

while que.is_empty() is False:
    count += 1
    while que.is_empty() is False:
        row, col = que.dequeue()
        for r, c in ((row - 1, col), (row + 1, col), (row, col - 1), (row, col + 1)):
            if 0 <= r < h and 0 <= c < w and data[r][c] == '.':
                nxt.enqueue((r, c))
                data[r][c] = '#'
    que, nxt = nxt, que
    nxt.clear()

print(count - 1)


### FIXED CODE ###

from collections import deque
h, w = map(int, input().split())
que = deque()
data = []

for ln in range(h):
    line = list(input().rstrip())
    data.append(line)
    for r, letter in enumerate(line):
        if letter == '#':
            que.append((ln, r))

count = 0
while len(que) > 0:
    count += 1
    next = deque()
    while len(que) > 0:
        row, col = que.popleft()
        for r, c in [(row - 1, col), (row + 1, col), (row, col - 1), (row, col + 1)]:
            if 0 <= r < h and 0 <= c < w and data[r][c] == '.':
                next.append((r, c))
                data[r][c] = '#'
    que = next

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

A = 0
B = 1
mid = []
goalIndex = []
ab = []

n, m = map(int, input().split())
for i in range(m):
    a,b = map(int, input().split())
    ab.append([a, b])
    if a == 1:
        mid.append(b)
    elif b == n:
        goalIndex.append(i)

# for _ab in ab:
#     if _ab[B] == n and _ab[A] in mid:
#         print("POSSIBLE")
#         exit()

for m in mid:
    for g in goalIndex:
        if ab[g][A] == m:
            print("POSSIBLE")
            exit()            

print("IMPOSSIBLE")

### FIXED CODE ###

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

A = 0
B = 1
mid = [0] * (n+1)
goal = [0] * (n+1)
ab = []

for i in range(m):
    a,b = map(int, input().split())
    ab.append([a, b])
    if a == 1:
        mid[b] += 1
    elif b == n:
        goal[a] += 1

# print(mid)
# print(goal)

for i in range(n+1):
    if mid[i] == 1 and goal[i] == 1:
        print("POSSIBLE")
        exit()

print("IMPOSSIBLE")
### BUGGY CODE ###

import numpy as np
n = int(input())

# alp = ["a","b","c","d","e",
# "f","g","h","i","j",
# "k","l","m","n","o",
# "p","q","r","s","t",
# "u","v","w","x","y","z"]
# 
ans = 0
# array1 = np.zeros().reshape( n,10)


# list1 = []
list_s = []

for i in range(n):
    s = input()
    list_s.append(s)

list_s = list(map(sorted, list_s))

for i in range(n):
    ans = ans + sum(map(lambda x: x==list_s[i],list_s)) -1

print(int(ans/2))

### FIXED CODE ###

n = int(input())

ans = 0
ans_dict = {}

for i in range(n):
    s = input()
    s = ''.join(sorted(s))
    if(s in ans_dict):
        ans += ans_dict[s]
        ans_dict[s] += 1
    else:
        ans_dict[s] = 1
        
print(int(ans))
### BUGGY CODE ###

n, m = map(int, input().split())
passed = 0
failed = 0
dicto = {}
for i in range(m):
    key, status = input().split()
    if key not in dicto.keys():
        dicto[key] = []
        dicto[key].append(status)
    else:
        if 'AC' not in dicto[key]:
            dicto[key].append(status)
for item in dicto:
    if 'AC' in dicto[item]:
        for i in dicto[item]:
            if i == 'WA':
                failed += 1
        passed += 1
print(passed, failed)


### FIXED CODE ###

n, m = map(int, input().split())
passed = 0
failed = 0
dicto = {}

for i in range(1, n+1):
    dicto[i] = [False, 0]

for i in range(m):
    key, status = input().split()
    key = int(key)
    if status == 'WA' and not dicto[key][0]:
        dicto[key][1] += 1
    else:
        dicto[key][0] = True

for i in dicto:
    if dicto[i][0]:
        failed += dicto[i][1]
        passed += 1

print(passed, failed)
### BUGGY CODE ###

n = int(input())
a_li = list(map(int,input().split()))

result = a_li[0]
for i in range(1,n):
  result = result * a_li[i]

if result > 10 ** 18:
  print(-1)
else:
  print(result)

### FIXED CODE ###

n = int(input())
a_li = list(map(int,input().split()))

if 0 in a_li:
  print(0)
else:
  result = a_li[0]
  for i in range(1,n):
    result = result * a_li[i]
  
    if result > 10 ** 18:
      print(-1)
      break
    
  else:
    print(result)
### BUGGY CODE ###

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

dot=[]
xxx=[]
yyy=[]

ans=float('inf')

for i in range(n):
  x,y=map(int,input().split())
  dot.append([x,y])
  xxx.append(x)
  yyy.append(y)

for sx in xxx:
  for sy in yyy:
    for gx in xxx:
      for gy in yyy:
        if sx==gx or sy==gy:
          continue
        cnt=0
        for lst in dot:
          if sx<=lst[0]<=gx or gx<=lst[0]<=sx:
            if sy<=lst[1]<=gy or gy<=lst[1]<=sy:
              cnt+=1
      
        if cnt>=k:
          ans=min(ans,abs(sx-gx)*abs(sy-gy))


print(ans)

### FIXED CODE ###

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

dot=[]
xxx=[]
yyy=[]

ans=float('inf')

for i in range(n):
  x,y=map(int,input().split())
  dot.append([x,y])
  xxx.append(x)
  yyy.append(y)

xxx.sort()
yyy.sort()

for sx in range(n):
  for sy in range(n):
    for gx in range(sx+1,n):
      for gy in range(sy+1,n):
        cnt=0
        for lst in dot:
          if xxx[sx]<=lst[0]<=xxx[gx]:
            if yyy[sy]<=lst[1]<=yyy[gy]:
              cnt+=1
      
        if cnt>=k:
          if xxx[sx]==xxx[gx] or yyy[sy]==yyy[gy]:
            continue
          ans=min(ans,(xxx[gx]-xxx[sx])*(yyy[gy]-yyy[sy]))


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

n=int(input())
as_=list(map(int,input().split()))
for i in range(1,n):
    print(as_[i-1:].count(i))
print(0)


### FIXED CODE ###

n=int(input())
as_=list(map(int,input().split()))
l=[0 for _ in range(n)]
for a in as_:
    l[a-1]+=1
for c in l:
    print(c)
### BUGGY CODE ###

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

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]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
      
uf = UnionFind(N)
for _ in range(M):
  x,y = map(int, input().split())
  uf.union(x-1,y-1)
  
ans = 0
for lis in uf.all_group_members().values():
  s = set(lis)
  for a in s:
    if P[a]-1 in s:
      ans += 1
      
print(ans)

### FIXED CODE ###

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

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]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
      
uf = UnionFind(N+1)
for _ in range(M):
  x,y = map(int, input().split())
  uf.union(x,y)
  
ans = 0
for i in range(N):
  if uf.same(i+1, P[i]):
    ans += 1
      
print(ans)
### BUGGY CODE ###

def make_divisors(n):
    lower_divisors , upper_divisors = [], []
    i = 1
    while i*i <= n:
        if n % i == 0:
            lower_divisors.append(i)
            if i != n // i:
                upper_divisors.append(n//i)
        i += 1
    return lower_divisors + upper_divisors[::-1]

def main():
    N = int(input())
    A = list(map(int, input().split()))
    minA = min(A)
    maxA = max(A)


    d = 2
    is_pairwise = True
    cnt = 0
    for a in A:
        if a % d == 0:
            cnt += 1
        if cnt == 2:
            is_pairwise = False
            break

    if is_pairwise:
        for d in range(3, maxA+1, 2):
            cnt = 0
            for a in A:
                if a % d == 0:
                    cnt += 1
                if cnt == 2:
                    is_pairwise = False
                    break
            if not is_pairwise:
                break
        
        if is_pairwise:
            print('pairwise coprime')
            return



    div_min_A = make_divisors(minA)
    div_min_A
    # print(div_min_A)

    s_max = int(A[-1] ** 0.5) + 1

    is_setwise = True
    # 最小値の約数（1以外）で割れる数が何個あるか調べ、
    # 2個以上あるなら
    for d in div_min_A[1:]:
        cnt = 0
        d_is_setwise_div = True
        for a in A:
            if a % d != 0:
                d_is_setwise_div = False
                break
        if d_is_setwise_div:
            is_setwise = False
            break
    
    if is_setwise:
        print('setwise coprime')
    else:
        print('not coprime')

if __name__ == '__main__':
    main()

### FIXED CODE ###

def make_divisors(n):
    lower_divisors , upper_divisors = [], []
    i = 1
    while i*i <= n:
        if n % i == 0:
            lower_divisors.append(i)
            if i != n // i:
                upper_divisors.append(n//i)
        i += 1
    return lower_divisors + upper_divisors[::-1]

def prime_factorize(n):
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a

def gcd(x, y):
    if y == 0:
        return x
    else:
        return gcd(y, x % y)

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

    all_prime = set()
    is_pairwise = True
    for a in A:
        facts = set(prime_factorize(a))
        if len(facts & all_prime) != 0:
            is_pairwise = False
            break

        all_prime |= facts

    if is_pairwise:
        print('pairwise coprime')
        return

    _gcd = A[0]
    is_setwise = False
    for a in A[1:]:
        _gcd = gcd(a, _gcd)
        if _gcd == 1:
            is_setwise = True
            break
    
    if is_setwise:
        print('setwise coprime')
    else:
        print('not coprime')

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

n,k=map(int,input().split())
#xは求める場合の数
x=0
for i in range(k,n+2):
  #ｙはi-1までの和
  y=0
  for j in range(i):
    y+=j
  x+=((i*n-2*y+1)%(10**9+7))
print(x)

### FIXED CODE ###

n,k=map(int,input().split())
b=0
for i in range(k,n+2):
  x=0.5*i*(i-1)
  b+=i*n-2*x+1
print(int(b%(10**9+7)))
### BUGGY CODE ###

S=input()
T=input()
setT=list(set(T))    
    
if set(T)<=set(S):
    i=0
    j=0
    while 1:
        if S[i%len(S)]==T[j]:
            j+=1
        if j==len(T):
            break
        i+=1
    print(i+1)
else:
    print(-1)

### FIXED CODE ###

from bisect import bisect_right as br
S=input()
T=input()

def s2n(s):
    return ord(s)-97

ALF=[[] for _ in [0]*26]
for i in range(len(S)):
    ALF[s2n(S[i])].append(i)

ALF_T=[0]*26
seqT=[]
res=0
for t in T:
    i=s2n(t)
    if ALF[i]:
        if seqT:
            a=seqT[-1]
        else:
            a=-1
        j=br(ALF[i],a)
        seqT.append(ALF[i][j%len(ALF[i])])
    else:
        res=-1
if res>=0:
    tmp=[]
    m=-1
    for n in seqT:
        if m<n:
            tmp.append(n)
        else:
            res+=1
            tmp=[n]
        m=n
    res=res*len(S)+tmp[-1]+1
print(res)
### BUGGY CODE ###

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

for i in range(Q):
    B, C = map(int, input().split())
    for j in range(N):
        if newA[j] == B:
            newA[j] = C
        if newA[j] > C:
            break
    print(sum(newA))

### FIXED CODE ###

N = int(input())
A = list(map(int, input().split()))
S = sum(A)
D = [0] * (10 ** 5 + 1)
for i in range(N):
    D[A[i]] += 1

Q = int(input())
for i in range(Q):
    B, C = map(int, input().split())
    S += (C - B) * D[B]
    print(S)
    
    D[C] += D[B] 
    D[B] = 0
### BUGGY CODE ###

N, M, K = map(int, input().split())
mod = 998244353
ans = 0
nCi = [1]

for i in range(1, N+1):
    nCi.append(nCi[i-1]*(N-i) * pow(i, mod-2, mod))


for i in range(min(N, K)+1):
    ans += (M%mod) * pow(M - 1, N-1-i, mod) * nCi[i]
    ans %= mod

print(ans)


### FIXED CODE ###

N, M, K = map(int, input().split())
mod = 998244353
ans = 0
nCi = [1]

for i in range(1, N+1):
    nCi.append(nCi[i-1]*(N-i) * pow(i, mod-2, mod) % mod)


for i in range(K+1):
    ans += M * pow(M - 1, N-1-i, mod) * nCi[i]
    ans %= mod

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

from collections import Counter
import copy

N = int(input())

target_list = map(int, input().split())
check = [Counter(target_list)]

for index in range(int(input())):
    B, C = map(int, input().split())
    if B in check[index]:
        result = copy.deepcopy(check[index])
        if C in result:
            result[C] = result[C] + result.pop(B)
        else:
            result[C] = result.pop(B)
    else:
        result = copy.deepcopy(check[index])
    check.append(result)
    print(sum([a * b for a, b in result.items()]))


### FIXED CODE ###

from collections import Counter

N = int(input())

target_list = list(map(int, input().split()))
check = Counter(target_list)
result = sum(target_list)


for index in range(int(input())):
    B, C = map(int, input().split())
    if B in check:
        result = result + (check[B]) * (C - B)
        if C in check:
            check[C] = check[C] + check[B]
        else:
            check[C] = check[B]
        check[B] = 0
    print(result)
### BUGGY CODE ###


N, X, Y = list(map(int, input().split()))

# N = 2000
# X = 100
# Y = 1900


X -= 1
Y -= 1

# @profile
def main(N, X, Y):
    ans = [0]*N
    for sv in range(N):
        # dist[v] = dist from sv to v
        dist = [float("inf")]*N
        last_visited = []
        dist[sv] = 0
        last_visited.append(sv)
        while last_visited:
            next_last_visited = []
            for v in last_visited:
                d = dist[v]
                if v+1 < N and dist[v+1] == float("inf"):
                    dist[v+1] = d+1
                    next_last_visited.append(v+1)
                if v-1 >= 0 and dist[v-1] == float("inf"):
                    dist[v-1] = d+1
                    next_last_visited.append(v-1)
                if v == X and dist[Y] == float("inf"):
                    dist[Y] = d+1
                    next_last_visited.append(Y)
                if v == Y and dist[X] == float("inf"):
                    dist[X] = d+1
                    next_last_visited.append(X)
            # print(last_visited, next_last_visited)
            last_visited = next_last_visited
        # print(dist)
        for d in dist:
            ans[d] += 1

    for a in ans[1:]:
        print(a//2)


main(N, X, Y)


### FIXED CODE ###


N, X, Y = list(map(int, input().split()))

# N = 2000
# X = 100
# Y = 1900


X -= 1
Y -= 1

# @profile


def main(N, X, Y):
    ans = [0]*N
    for i in range(N):
        for j in range(i+1, N):
            d = min(j-i, abs(X-i)+abs(Y-j)+1)
            ans[d] += 1

    for a in ans[1:]:
        print(a)


main(N, X, Y)
### BUGGY CODE ###

import sys 
input = sys.stdin.readline

N,K = map(int,input().split())
h = list(map(int,input().split()))

dp = [0] * 100010

dp[0] = 0
dp[1] = abs(h[1]-h[0])
for i in range(2,min(K,N)):
    Minimum = dp[i-1]+abs(h[i]-h[i-1])
    for j in range(2,i+1):
        Minimum = min(dp[i-j]+abs(h[i]-h[i-j]),Minimum)
    dp[i] = Minimum
if N > K:
    if K == 1:
        for i in range(K,N):
            Minimum = dp[i-1]+abs(h[i]-h[i-1])
            dp[i] = Minimum
        
    else:
        for i in range(K,N):
            Minimum = dp[i-1]+abs(h[i]-h[i-1])
            for (j,k) in zip(dp[i-K:i-1],h[i-K:i-1]):
                Minimum = min(j+abs(h[i]-k),Minimum)
            dp[i] = Minimum
        
print(dp[N-1])

### FIXED CODE ###

#import sys 
#input = sys.stdin.readline

N,K = map(int,input().split())
h = list(map(int,input().split()))

dp = [0] * 100010

dp[0] = 0
dp[1] = abs(h[1]-h[0])
for i in range(2,min(K,N)):
    Minimum = dp[i-1]+abs(h[i]-h[i-1])
    for j in range(2,i+1):
        Minimum = min(dp[i-j]+abs(h[i]-h[i-j]),Minimum)
    dp[i] = Minimum
if N > K:
    if K == 1:
        for i in range(K,N):
            Minimum = dp[i-1]+abs(h[i]-h[i-1])
            dp[i] = Minimum
        
    else:
        for i in range(K,N):
            Minimum = dp[i-1]+abs(h[i]-h[i-1])
            for (j,k) in zip(dp[i-K:i-1],h[i-K:i-1]):
                Minimum = min(j+abs(h[i]-k),Minimum)
            dp[i] = Minimum
        
print(dp[N-1])
### BUGGY CODE ###

n = int(input())
an = map(int, input().split())
num = 1
num = 1
for i in an:
    num *= i
    if (i == 0):
        num = 0
        break
    
if num > 10**18:
    print(-1)
else:
    print(num)

### FIXED CODE ###

n = int(input())
an = map(int, input().split())
num = 1
max = 10**18
for i in an:
    if num < max:
         num *= i
    if (i == 0):
        num = 0
        break
    
if num > 10**18:
    print(-1)
else:
    print(num)
### BUGGY CODE ###

N,K,Q = map(int, raw_input().split())
A = []
 
for i in range(0,Q):
  A.append(int(raw_input()))
for i in range(1,N+1):
  con = A.count(i)
  if K - (Q - con) > 0:
    print "Yes"
  elif K - (Q - con) <= 0:
    print "No"
    


### FIXED CODE ###

N,K,Q = map(int, raw_input().split())
K_list = [Q-K]*N
for i in range(0,Q):
  index = int(raw_input())
  K_list[index-1] = K_list[index-1] -1

for i in K_list:
  if i < 0:
    print "Yes"
  else:
    print "No"
### BUGGY CODE ###

N,K=map(int,input().split())
ab=[list(map(int,input().split())) for _ in range(N-1)]
graph=[[] for _ in [0]*N]
for a,b in ab:
    graph[a-1].append(b-1)
    graph[b-1].append(a-1)
info=[[False,set(),set(),-1] for _ in [0]*N]
q=[[0,""]]
while(q):
    i,j = q.pop()
    if j!="":
        info[i][1].add(j)
        info[i][2]|={k for k in info[j][1]}
    if info[i][0]==False:
        info[i][0]=True
        info[i][3]=K-len(info[i][1])-len(info[i][2])
    while(graph[i]):
        g=graph[i].pop()
        q.append((g,i))
ans=1
mod=10**9+7
for i in info:
    ans=(ans*i[3])%mod
print(ans)

### FIXED CODE ###

N,K=map(int,input().split())
ab=[list(map(int,input().split())) for _ in range(N-1)]
graph=[[] for _ in [0]*N]
[graph[a-1].append(b-1) for a,b in ab]
[graph[b-1].append(a-1) for a,b in ab]
q=[[-1,0]]
cnt=0
ans=K
mod=10**9+7
while(q):
    q1=[]
    if cnt<2:
        cnt+=1
    for i,j in q:
        g=graph[j]
        if i!=-1:
            g.remove(i)
        for cnt2,k in enumerate(g):
            q1.append([j,k])
            ans=(ans*(K-cnt-cnt2))%mod
    q=q1
print(ans)
### BUGGY CODE ###

n, k = map(int, input().split())
a = list(map(int, input().split()))
x = []
for i in range(n-k+1):
    tmp = 1
    for j in range(k):
        tmp *= a[i+j]
    x.append(tmp)

for i in range(n-k):
    if x[i] < x[i+1]:
        print("Yes")
    else:
        print("No")

### FIXED CODE ###

n, k = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n-k):
    if a[i] < a[i+k]:
        print("Yes")
    else:
        print("No")