CodeEff/ECCO huggingface dataset:
# Original solution
from operator import mul
from functools import reduce

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


beforePoint = reduce(mul, A[:K])

for i in range(0, N-K):
    point = (beforePoint//A[i]) * A[i+K]
    # print(beforePoint, point)
    if beforePoint < point:
        print("Yes")
    else:
        print("No")
    beforePoint = point


# Optimized solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(N-K):
    # print(A[i], A[i+K])
    if A[i] < A[i+K]:
        print("Yes")
    else:
        print("No")
# Original solution
from operator import mul
from functools import reduce
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))


score = reduce(mul, A[:k])
for i in range(k, n):
    nscore = score//A[i-k]*A[i]
    if score < nscore:
        print('Yes')
    else:
        print('No')

    score = nscore


# Optimized solution
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))


for i in range(k, n):
    if A[i-k] < A[i]:
        print('Yes')
    else:
        print('No')
# Original solution
n,k = list(map(int,input().split()))
A = list(map(int,input().split()))

prev = 1
for i in range(k):
  prev *= A[k-i-1]
 
left = 0
right = k
tmp = prev
while right<n:
  tmp /= A[left]
  tmp *= A[right]
  if tmp>prev:
    print("Yes")
  else:
    print("No")
  prev = tmp
  left += 1
  right += 1

# Optimized solution
n,k = list(map(int,input().split()))
A = list(map(int,input().split()))
left = 0
right = k
while right<n:
  if A[right]>A[left]:
    print("Yes")
  else:
    print("No")
  left += 1
  right += 1
# Original solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))

score = 1
for i in range(k):
    score *= a[i]
ans = [score]

for i in range(k, n):
    score = score * a[i] // a[i-k]
    ans.append(score)

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


# Optimized solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))

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

now = 1
for i in range(k):
    now *= a[i]

for i in range(k,n):
    prv = now
    now *= a[i]
    now /= a[i-k]
    if prv < now:
        print("Yes")
    else:
        print("No")

# Optimized solution
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))

for i in range(k,n):
    if a[i] > a[i-k]:
        print("Yes")
    else:
        print("No")
# Original solution
def inN():
    return int(eval(input()))
def inL():
    return list(map(int,input().split()))

n,k = inL()
a = inL()
sum = 1
sum2 = 1
for i in range(k):
    sum2 *= a[i]
for i in range(k,n):
    #print(sum2)
    sum = sum2 * a[i] / a[i-k] 
    if sum > sum2:
        print('Yes')
    else:
        print('No')
    sum2 = sum

# Optimized solution
def inN():
    return int(eval(input()))
def inL():
    return list(map(int,input().split()))

n,k = inL()
a = inL()

for i in range(k,n):
    if a[i] > a[i-k]:
        print('Yes')
    else:
        print('No')
# Original solution
N,K = input().split()
scores = [int(s) for s in input().split()]

N = int(N)
K = int(K)
SCORES = 1
answer = []
for i in range(K-1,N):
    for j in range(i,i-(K),-1):
        SCORES *= scores[j]
        
    answer.append(SCORES)
    SCORES = 1
    
#print(answer)

for l in range(N-K):
    if answer[l] < answer[l+1]:
        print("Yes")
    else:
        print("No")

# Optimized solution
N,K = input().split()
scores = [int(s) for s in input().split()]

N = int(N)
K = int(K)

for i in range(K,N):
    if scores[i] <= scores[i-K]:
        print("No")
    else:
        print("Yes")
# Original solution
n,k = list(map(int,input().split()))
A = list(map(int,input().split()))

sc = [0]*(n-k+1)
sc[0] = 1

for i in range(k):
    sc[0] *= A[i]

for i in range(1,n-k+1):
    sc[i] = (sc[i-1]/A[i-1])*A[k-1+i]
    if sc[i] > sc[i-1]:
        print("Yes")
    else:
        print("No")

# Optimized solution
n,k = list(map(int,input().split()))
A = list(map(int,input().split()))

for i in range(n-k):
    if A[i] < A[k+i]:
        print("Yes")
    else:
        print("No")
# Original solution
n, k = [int(w) for w in input().split()]
la = [int(w) for w in input().split()]

mul = 1
for i in range(k):
    mul *= la[i]

bef = mul

for i in range(k, n):
    mul /= la[i-k]
    mul *= la[i]

    cond = mul > bef
    print(("Yes" if cond else "No"))

    bef = mul


# Optimized solution
n, k = [int(w) for w in input().split()]
la = [int(w) for w in input().split()]


for i in range(k, n):
    cond = la[i] > la[i-k]
    print(("Yes" if cond else "No"))
# Original solution
from functools import reduce

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

cum = [0] * (n - k + 1)
cum[0] = reduce(lambda x, y: x * y, a[0:0 + k])
for i in range(1, n - k + 1):
    cum[i] = cum[i - 1] * a[i + k - 1] // a[i - 1]

for i in range(1, len(cum)):
    if cum[i] > cum[i - 1]:
        print('Yes')
    else:
        print('No')


# Optimized solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))

for i in range(k, n):
    if a[i - k] / a[i] < 1:
        print('Yes')
    else:
        print('No')
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
tmp = 1
ans = []
for i in range(N):
    if i+1 < K:
        tmp *= A[i]
        continue
    tmp *= A[i]
    ans.append(tmp)
    tmp //= A[i-K+1]

for i in range(1,len(ans)):
    if ans[i-1] < ans[i]:
        print("Yes")
    else:
        print("No")



# Optimized solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
tmp = 1
ans = []
for i in range(N):
    if i+1 <= K:
        continue
    if A[i-K] < A[i]:
        print("Yes")
    else:
        print("No")
# Original solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))

z = 1
for i in range(k):
    z = z * a[i]

for i in range(n-k):
    t = a[k+i] * z / a[i]
    if z < t:
        print("Yes")
    else:
        print("No")
    z = t

# Optimized solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))

for i in range(n-k):
    if a[k+i] > a[i]:
        print("Yes")
    else:
        print("No")
# Original solution
n, k = list(map(int, input().split()))
a = [int(i) for i in input().split()]
s = [0 for i in range(n)]
p = [0 for i in range(n)]

s[0] = a[0]
for i in range(1, n):
  s[i] = s[i-1] * a[i]

p[k-1] = s[k-1]
for i in range(k, n):
  p[i] = int(s[i] / s[i-k])

for i in range(k, n):
  if p[i] > p[i-1]:
    print("Yes")
  else:
    print("No")
    

# Optimized solution
n, k = list(map(int, input().split()))
a = [int(i) for i in input().split()]
res = 0
for i in range(n-k):
  if a[i+k] - a[i] > 0:
    print("Yes")
  else:
    print("No")
# Original solution
from functools import reduce
from operator import mul
from collections import deque

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

A = [int(i) for i in input().split()]

B = deque(A[:K])

C = reduce(mul,B)

for i in range(K,N):
  B.popleft()
  B.append(A[i])
  D = reduce(mul,B)
  if C < D:
    print('Yes')
  else:
    print('No')
  C = D

# Optimized solution
from collections import deque

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

A = [int(i) for i in input().split()]

B = deque(A[:K])

for i in range(K,N):
  if B.popleft() < A[i]:
    print('Yes')
  else:
    print('No')    
    
  B.append(A[i])
# Original solution
import functools

def read():
    N, K = list(map(int, input().split(' ')))
    As = list(map(int, input().split(' ')))
    return N, K, As

def mul(l):
    return functools.reduce(lambda x, y: x * y, l)

def fun(N, K, As):
    for i in range(N - K):
        prev = mul(As[i:i+K])
        current = mul(As[i+1:i+K+1])
        if current > prev:
            print('Yes')
        else:
            print('No')

if __name__ == '__main__':
    N, K, As = read()
    fun(N, K, As)

# Optimized solution
def read():
    N, K = list(map(int, input().split(' ')))
    As = list(map(int, input().split(' ')))
    return N, K, As


def fun(N, K, As):
    for i in range(N - K):
        prev = As[i]
        current = As[i+K]
        if current > prev:
            print('Yes')
        else:
            print('No')

if __name__ == '__main__':
    N, K, As = read()
    fun(N, K, As)
# Original solution
N, K = list(map(int,input().split()))
A = list(map(int,input().split()))
S = [1]

for i in range(0,N):
    tmp = S[-1] * A[i]
    S.append(tmp)

# print(S)

B = []
for i in range(K,N+1):
    B.append(S[i]//S[i-K])

for i in range(1,len(B)):
    if(B[i]>B[i-1]):
        print('Yes')
    else:
        print('No')


# Optimized solution
N, K = list(map(int,input().split()))
A = list(map(int,input().split()))

for i in range(K,N):
    if(A[i]>A[i-K]):
        print('Yes')
    else:
        print('No')
# Original solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))

sum = []

s = 1
for i in range(k):
    s *= a[i]
sum.append(s)

for i in range(k+1, n+1):
    i -= 1
    s = s * a[i] // a[i-k]
    sum.append(s)

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



# Optimized solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))

for i in range(k+1, n+1):
    i -= 1
    if a[i-k] < a[i]:
        print("Yes")
    else:
        print("No")
# Original solution
import sys
from collections import defaultdict, deque, Counter
import math

# import copy
from bisect import bisect_left, bisect_right
import heapq

# sys.setrecursionlimit(1000000)

# input aliases
input = sys.stdin.readline

getS = lambda: input().strip()
getN = lambda: int(eval(input()))
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]

INF = 10 ** 20
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)


def nck(n, k, kaijyo):
    return (npk(n, k, kaijyo) * divide(kaijyo[k])) % MOD


def npk(n, k, kaijyo):
    if k == 0 or k == n:
        return n % MOD
    return (kaijyo[n] * divide(kaijyo[n-k])) % MOD


def kaijyo(n):
    ret = [1]
    for i in range(1, n + 1):
        ret.append((ret[-1] * i)% MOD)
    return ret

def solve():
    n, k = getList()
    nums = getList()
    pro = [1]
    for num in nums:
        pro.append(pro[-1] * num)
    # print(pro)
    for i in range(n - k):
        # print(i)
        ku = pro[k+i] / pro[i]
        ku2 = pro[k+i + 1] / pro[i+ 1]
        if ku2 > ku:
            print("Yes")
        else:
            print("No")
if __name__ == "__main__":
    # main()
    solve()

# Optimized solution
import sys
from collections import defaultdict, deque, Counter
import math

# import copy
from bisect import bisect_left, bisect_right
import heapq

# sys.setrecursionlimit(1000000)

# input aliases
input = sys.stdin.readline

getS = lambda: input().strip()
getN = lambda: int(eval(input()))
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]

INF = 10 ** 20
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)


def nck(n, k, kaijyo):
    return (npk(n, k, kaijyo) * divide(kaijyo[k])) % MOD


def npk(n, k, kaijyo):
    if k == 0 or k == n:
        return n % MOD
    return (kaijyo[n] * divide(kaijyo[n-k])) % MOD


def kaijyo(n):
    ret = [1]
    for i in range(1, n + 1):
        ret.append((ret[-1] * i)% MOD)
    return ret

def solve():
    n, k = getList()
    nums = getList()
    # pro = [1]
    # for num in nums:
    #     pro.append(pro[-1] * num)
    # print(pro)
    for i in range(n - k):
        # print(i)
        # ku = pro[k+i] / p/] / pro[i+ 1]
        if nums[i] < nums[i+k]:
            print("Yes")
        else:
            print("No")
if __name__ == "__main__":
    # main()
    solve()
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
ans1 = 1
B = []
for i in range(K):
  ans1 = ans1*A[i]
B.append(ans1)
for i in range(N-K):
  ans1 = ans1*A[K+i]/A[i]
  B.append(ans1)
for i in range(N-K):
  if B[i] < B[i+1]:
    print('Yes')
  else:
    print('No')
  

# Optimized solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(N-K):
  if A[i] < A[K+i]:
    print('Yes')
  else:
    print('No')
# Original solution
N,K = list(map(int, input().split()))
A = list(map(int, input().split()))
b = 1
c = 1
a = 0
while K < N:
    for i in range(a,K):
        b *= A[i]
    for j in range(a+1,K+1):
        c *= A[j]
    if c > b:
        print("Yes")
    else:print("No")
    b=1
    c=1
    K += 1
    a += 1

# Optimized solution
N,K = list(map(int, input().split()))
A = list(map(int, input().split()))

a = 0
while K < N:
    if A[a] < A[K]:
        print("Yes")
    else:print("No")
    K += 1
    a += 1
# Original solution
N, K = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
#%%
temp1 = 1
T = A[0: K]
for i in T:
    temp1 *= i

arr = []
arr.append(temp1)

for i in range(K, N):
    temp1 = arr[-1]
    temp2 = arr[-1]
    temp2 /= A[i - K]
    temp2 *= A[i]
    arr.append(temp2)
    if temp1 < temp2:
        print("Yes")
    else:
        print("No")


# Optimized solution

N, K = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]

#%%

for i in range(K, N):
    if A[i - K] < A[i]:
        print("Yes")
    else:
        print("No")
# Original solution
n, k = list(map(int, input().split()))
arr = list(map(int, input().split()))
for i in range(n - k):
  c = sum(arr[i + 1:k + i + 1])
  d = sum(arr[i:k + i])
  if c > d:
    print("Yes")
  else:
    print("No")

# Optimized solution
n, k = list(map(int, input().split()))
arr = list(map(int, input().split()))
for i in range(n - k):
  if arr[i] < arr[i + k]:
    print("Yes")
  else:
    print("No")
# Original solution
import sys
def IL(): return list(map(int,sys.stdin.readline().rstrip().split()))

if __name__=='__main__':
    n,k = IL()
    a = list(IL())
    l = n-k+1
    pre = b = 0
    for i in range(l):
        result = 1
        for rep in a[i:i+k]:
            result = result*rep
        pre = b
        b = result
        if 0<i:
            if pre<b:
                print('Yes')
            else:
                print('No')
    exit()

# Optimized solution
import sys
def IL(): return list(map(int,sys.stdin.readline().rstrip().split()))

if __name__=='__main__':
    n,k = IL()
    a = list(IL())
    l = n-k
    pre = b = 0
    for i in range(l):
        if a[i]<a[i+k]:
            print('Yes')
        else:
            print('No')
    exit()
# Original solution
n, k= list(map(int, input().split()))
a = list(map(int, input().split()))

def main():
    scores = []
    score = 1
    for i in range(k-1, -1, -1):
        score *= a[i]

    scores.append(score)
    scores_append = scores.append

    for j in range(k, n):
        score_before = scores[-1]
        score = score_before * a[j] / a[j-k]
        scores_append(score)
        if score > score_before:
            print('Yes')
        else:
            print('No')

            
if __name__ == '__main__':
    main()    

# Optimized solution
n, k= list(map(int, input().split()))
a = list(map(int, input().split()))

for i in range(k, n):
    if a[i] > a[i-k]:
        print('Yes')
    else:
        print('No')
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
answer = 'Yes'
score = 1
for i in range(K):
    score *= A[i]

for i in range(N - K):
    next_score = score * A[K + i] // A[i]
    print(('Yes' if next_score > score else 'No'))
    score = next_score



# Optimized solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
answer = 'Yes'
score = 0
for i in range(K):
    score += A[i]

for i in range(N - K):
    next_score = score + A[K + i] - A[i]
    print(('Yes' if next_score > score else 'No'))
    score = next_score
# Original solution
# -*- coding: utf-8 -*-


# 入力を整数に変換して受け取る
def input_int():
    return int(eval(input()))


# マイナス1した値を返却
def int1(x):
    return int(x) - 1


# 半角スペース区切り入力をIntに変換してMapで受け取る
def input_to_int_map():
    return list(map(int, input().split()))


# 半角スペース区切り入力をIntに変換して受け取る
def input_to_int_tuple():
    return tuple(map(int, input().split()))


# 半角スペース区切り入力をIntに変換してマイナス1した値を受け取る
def input_to_int_tuple_minus1():
    return tuple(map(int1, input().split()))


def main():
    n, k = input_to_int_map()
    a_array = input_to_int_tuple()

    temp = [1]
    val = 1
    for a in a_array:
        val *= a
        temp.append(val)

    pre_k_val = temp[k + 1 - 1]
    ini_pre_k_val = temp[k + 1 - 1 - k]
    pre_k_val /= ini_pre_k_val
    for i in range(k + 1, n + 1):
        k_val = temp[i]
        ini_k_val = temp[i - k]
        k_val /= ini_k_val

        if pre_k_val < k_val:
            print("Yes")
        else:
            print("No")

        pre_k_val = k_val


if __name__ == "__main__":
    main()


# Optimized solution
# -*- coding: utf-8 -*-


# 入力を整数に変換して受け取る
def input_int():
    return int(eval(input()))


# マイナス1した値を返却
def int1(x):
    return int(x) - 1


# 半角スペース区切り入力をIntに変換してMapで受け取る
def input_to_int_map():
    return list(map(int, input().split()))


# 半角スペース区切り入力をIntに変換して受け取る
def input_to_int_tuple():
    return tuple(map(int, input().split()))


# 半角スペース区切り入力をIntに変換してマイナス1した値を受け取る
def input_to_int_tuple_minus1():
    return tuple(map(int1, input().split()))


def main():
    n, k = input_to_int_map()
    a_array = input_to_int_tuple()

    for k_val, pre_k_val in zip(a_array[k:], a_array[k - k:]):
        if k_val > pre_k_val:
            print("Yes")
        else:
            print("No")

if __name__ == "__main__":
    main()
# Original solution
# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import sys
def main(N, K, A):
    st = SegmentTree(f=lambda x, y: x * y, identity_factory=lambda: 1, initial_values=A)
    prev = st.query(0, K)
    for i in range(K + 1, N + 1):
        curr = st.query(i - K, i)
        print(('Yes' if curr > prev else 'No'))
        prev = curr

class SegmentTree:
    def __init__(self, n=None, f=max, identity_factory=int, initial_values=None):
        assert(n or initial_values)
        size = n if n else len(initial_values)
        d = [identity_factory() for _ in range(2 * size + 1)]
        self.__n, self.__d, self.__f, self.__e = size, d, f, identity_factory
        if initial_values:
            for i, v in enumerate(initial_values): d[size + i] = v
            for i in range(size - 1, 0, -1): d[i] = f(d[i << 1], d[i << 1 | 1])

    def get_val(self, index):
        return self.__d[index + self.__n]

    def set_val(self, index, new_value):
        i, d, f = index + self.__n, self.__d, self.__f
        if d[i] == new_value: return
        d[i] = new_value
        while i:
            i = i >> 1
            d[i] = f(d[i << 1], d[i << 1 | 1])

    def modify(self, index, value):
        self.set_val(index, self.__f(self.__d[index + self.__n], value))

    def query(self, from_inclusive, to_exclusive):
        ans = self.__e()
        if to_exclusive <= from_inclusive: return ans
        l, r, d, f = from_inclusive + self.__n, to_exclusive + self.__n, self.__d, self.__f
        while l < r:
            if l & 1: ans, l = f(ans, d[l]), l + 1
            if r & 1: ans, r = f(d[r - 1], ans), r - 1
            l, r = l >> 1, r >> 1
        return ans

if __name__ == '__main__':
    input = sys.stdin.readline
    N, K = list(map(int, input().split()))
    *A, = list(map(int, input().split()))
    main(N, K, A)


# Optimized solution
# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import sys
def main(N, K, A):
    for i in range(K, N):
        print(('Yes' if A[i] > A[i - K] else 'No'))

if __name__ == '__main__':
    input = sys.stdin.readline
    N, K = list(map(int, input().split()))
    *A, = list(map(int, input().split()))
    main(N, K, A)
# Original solution
#Problem C

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

p1 = 1
p2 = 0


for i in range(K):
    p1 *= a[i]
    

for i in range(N-K):
    p2 = p1/a[i]*a[K+i]
    if p2 > p1:
        print("Yes")
    else:
        print("No")
    p1 = p2

# Optimized solution
#Problem C

N,K = list(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")
# Original solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))


b = []
i = 0
while k != n+1:
    total = 1
    for j in range(i, k):
        total *= a[j]
    b.append(total)
    i += 1
    k += 1
l = len(b)
#print(b)
for i in range(l-1):
    if b[i] < b[i+1]:
        print('Yes')
    else:
        print('No')

# Optimized solution
n, k = list(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')
# Original solution
N,K = list(map(int, input().split()))
A = list(map(int, input().split()))
i = N - K
while i > 0:
    print(('Yes' if A[K] > A[0] else 'No'))
    A.pop(0)
    i -= 1

# Optimized solution
N,K = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range (K,N):
    print(('Yes' if A[i] > A[i-K] else 'No'))
# Original solution
n,k = list(map(int,input().split()))

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

b = []
for i in range(k-1,n):
    c = 1
    for j in range(k):
        c *= a[i - j]
    b.append(c)

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


# Optimized solution
n,k = list(map(int,input().split()))

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

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

q = collections.deque([])
cumul = 1
prev = 0
for ai in map(int, input().split()):
	cumul *= ai
	q.append(ai)
	if len(q) == k + 1:
		cumul /= q.popleft()


	if len(q) == k:
		if prev != 0:
			print('Yes' if cumul > prev else 'No')
		prev = cumul

# Optimized solution
n,k = list(map(int , input().split()))
ais = list(map(int, input().split()))
for ii in range(k, n):
	print('Yes' if ais[ii] > ais[ii - k] else 'No')
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))

lst = [0]*(N-K+1)

lst[0] = 1
for i in range(K):
    lst[0] = lst[0] * A[i]

for i in range(1,N-K+1):
    lst[i] = lst[i-1] / A[i-1]
    lst[i] = lst[i] * A[K-1+i]
    if lst[i] > lst[i-1]:
        print("Yes")
    else:
        print("No")


# Optimized solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))

for i in range(1,N-K+1):
    if (A[K-1+i] / A[i-1]) > 1:
        print("Yes")
    else:
        print("No")
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
s = 1
for j in range(K-1):
  s *= A[j]
for i in range(K, N):
  if A[i] > A[i-K]:
    print("Yes")
  else:
    print("No")
  s *= A[i]
  s //= A[i-K]

# Optimized solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(K, N):
  if A[i] > A[i-K]:
    print("Yes")
  else:
    print("No")
# Original solution
n, k = list(map(int, input().split()))
points = [int(i) for i in input().split()]
scores = [0] * n
scores[0] = points[0]

for i in range(1, n):
    scores[i] = scores[i - 1] * points[i]
    
    if k <= i:
        scores[i] //= points[i - k]
        
for i in range(k, n):
    if scores[i - 1] < scores[i]:
        print('Yes')
    else:
        print('No')

# Optimized solution
n, k = list(map(int, input().split()))
points = [int(i) for i in input().split()]

for i in range(k, n):
    if points[i - k] < points[i]:
        print('Yes')
    else:
        print('No')
# Original solution
import copy
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
memo = copy.copy(a)
for i in range(k, n+1, 1):
    for j in range(i-k, i-1, 1):
        memo[i-1] *= a[j]
for i in range(k, n, 1):
    if memo[i-1] < memo[i]:
        print("Yes")
    else:
        print("No")

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