CodeEff/ECCO huggingface dataset:
# Original solution
# Author: S Mahesh Raju
# Username: maheshraju2020
# Date: 25/07/2020

from sys import stdin,stdout
from math import gcd, ceil, sqrt
from collections import Counter
from bisect import bisect_left, bisect_right
ii1 = lambda: int(stdin.readline().strip())
is1 = lambda: stdin.readline().strip()
iia = lambda: list(map(int, stdin.readline().strip().split()))
isa = lambda: stdin.readline().strip().split()
mod = 1000000007

n, k = iia()
arr = iia()
tot = 1
for i in range(k):
    tot *= arr[i]

for i in range(k, n):
    cur = tot
    tot *= arr[i]
    tot //= arr[i - k]
    if tot > cur:
        print('Yes')
    else:
        print('No')
    

# Optimized solution
# Author: S Mahesh Raju
# Username: maheshraju2020
# Date: 25/07/2020

from sys import stdin,stdout
from math import gcd, ceil, sqrt
from collections import Counter
from bisect import bisect_left, bisect_right
ii1 = lambda: int(stdin.readline().strip())
is1 = lambda: stdin.readline().strip()
iia = lambda: list(map(int, stdin.readline().strip().split()))
isa = lambda: stdin.readline().strip().split()
mod = 1000000007

n, k = iia()
arr = iia()
tot = 1
for i in range(k, n):
    if arr[i] > arr[i - k]:
        print('Yes')
    else:
        print('No')
# Original solution
# -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from collections import deque
from functools import lru_cache
import bisect
import re
import queue
import copy
import decimal


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [Scanner.string() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [Scanner.int() for i in range(n)]


def solve():
    N, K = Scanner.map_int()
    A = Scanner.map_int()
    S = 1
    for i in range(K - 1):
        S *= A[i]
    for i in range(K, N):
        if A[i - K] < A[i]:
            print('Yes')
        else:
            print('No')


def main():
    # sys.setrecursionlimit(1000000)
    # sys.stdin = open("sample.txt")
    solve()


if __name__ == "__main__":
    main()


# Optimized solution
# -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from collections import deque
from functools import lru_cache
import bisect
import re
import queue
import copy
import decimal


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [Scanner.string() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [Scanner.int() for i in range(n)]


def solve():
    N, K = Scanner.map_int()
    A = Scanner.map_int()
    for i in range(K, N):
        if A[i - K] < A[i]:
            print('Yes')
        else:
            print('No')


def main():
    # sys.setrecursionlimit(1000000)
    # sys.stdin = open("sample.txt")
    solve()


if __name__ == "__main__":
    main()
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
a_old = 1
for i in range(K):
    a_old = a_old*A[i]
a_new = a_old
for i in range(K, N):
    a_new = (a_old // A[i-K])*A[i]
    if a_new > a_old:
        print('Yes')
    else:
        print('No')
    a_old = a_new

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

num = n-k

ans = 1
before = 0

for i in range(num+1):
    ans *= a[i]

for i in range(1,num+1):
    before = ans
    ans = ans/ a[i-1] * a[i+k-1]
    if before >= ans:
        print("No")
    else:
        print("Yes")


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

num = n-k

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

for i in range(k):
  start *= a[i]
  
b.append(start)

score = start

for i in range(k, n):
  score = score / a[i-k] * a[i]
  b.append(score)
  
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[i + k]:
    print('Yes')
  else:
    print('No')
# Original solution
from operator import mul
from functools import reduce
N, K = list(map(int, input().split()))
As = list(map(int, input().split()))
base = []
ans2=0
for n in range(K, N+1):
    ans1=ans2
    start = n-K
    ans = 1
    ans = reduce(mul, As[start:n])
    ans2 = ans
    if n != K:
        if ans1 < ans2:
            print("Yes")
        else:
            print("No")

# Optimized solution
N, K = list(map(int, input().split()))
As = list(map(int, input().split()))
ans2=0
for n in range(K+1, N+1):
    ans1 = As[n-K-1]
    ans2 = As[n-1]
    if ans1 < ans2:
        print("Yes")
    else:
        print("No")
# Original solution
import functools
import operator

prod = functools.partial(functools.reduce, operator.mul)

N,K,*A = list(map(int, open(0).read().split()))

p = None
j = 0
for i in range(K, N+1):
    c = prod(A[j:i])
    if p:
        if p < c:
            print('Yes')
        else:
            print('No')
    p = c
    j += 1

# Optimized solution
N,K,*A = list(map(int, open(0).read().split()))

for i,n in enumerate(range(K-1, N)):
    if i == 0:
        continue
    if A[n-K] < A[n]:
        print('Yes')
    else:
        print('No')
# Original solution
from copy import deepcopy
n,k=list(map(int, input().split()))
a=list(map(int,input().split()))
tmp = 1
for i in range(k):
    tmp*=a[i]
p = tmp
p //= a[0]
p *= a[k]
for j in range(n-k):
    #print(tmp,p)
    if tmp < p:
        print("Yes")
    else:
        print("No")
    if k+j+1 > n-1:
        break
    tmp = p
    #print(a[j+1],a[k+j])
    p //= a[j+1]
    p *= a[k+j+1]


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

input = sys.stdin.readline

def product(lst):
    x = 1
    for i in lst:
        x *= i
    return x

def main(n, k, lst):
    prev = product(lst[:k])
    for i in range(n-k):
        curr = (prev / lst[i]) * lst[i+k]
        if curr > prev: print("Yes")
        else: print("No")
        prev = curr
    
    


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




# Optimized solution
# @uthor : Kaleab Asfaw
import sys

input = sys.stdin.readline

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

m_cur = 1
for i in range(1, K+1):
    m_cur *= A[i]

for i in range(K+1, N+1):
    a_latest, a_last = A[i], A[i-K]
    m_last, m_cur = m_cur, (m_cur // a_last) * a_latest
    if m_last < m_cur:
        print("Yes")
    else:
        print("No")


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

for i in range(K+1, N+1):
    a_latest, a_last = A[i], A[i-K]
    if a_latest > a_last:
        print("Yes")
    else:
        print("No")
# Original solution
def main():
    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"))

if __name__ == '__main__':
    main()

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

    ans = []
    for i in range(k,n):
        ans.append("Yes" if a[i] > a[i-k] else "No")

    print(("\n".join(ans)))

if __name__ == '__main__':
    main()
# 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):
    new = (now/a[i-k])*a[i]
    if now < new:
        print("Yes")
    else:
        print("No")
    now = new

# 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
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub


import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline

INF = 2**62-1


def read_int():
    return int(buff_readline())


def read_int_n():
    return list(map(int, buff_readline().split()))


def read_float():
    return float(buff_readline())


def read_float_n():
    return list(map(float, buff_readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()

def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, K, A):
    p = reduce(mul, A[:K], 1)
    for i, a in enumerate(A[K:]):
        np = p//A[i] * a
        if p < np:
            print('Yes')
        else:
            print('No')
        p = np


def main():
    N, K = read_int_n()
    A = read_int_n()
    (slv(N, K, A))


if __name__ == '__main__':
    main()


# Optimized solution
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub


import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline

INF = 2**62-1


def read_int():
    return int(buff_readline())


def read_int_n():
    return list(map(int, buff_readline().split()))


def read_float():
    return float(buff_readline())


def read_float_n():
    return list(map(float, buff_readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()

def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, K, A):
    for i, a in enumerate(A[K:]):
        if A[i] < a:
            print('Yes')
        else:
            print('No')


def main():
    N, K = read_int_n()
    A = read_int_n()
    (slv(N, K, A))


if __name__ == '__main__':
    main()
# 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]

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

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

score=1
for i in range(K):
    score+=A[i]

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

point = 1
point_ = 1
for i in range(K):
	point *= A[i]

for i in range(N - K):
	for x in range(K):
		point_ *= A[i + x + 1]
	if point < point_:
		print("Yes")
	else:
		print("No")
	point = point_
	point_ = 1

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


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

tmp = 1
for j in range(K):
    tmp *= A[j]
for i in range(1, N-K+1):
    ans = 1
    for j in range(K):
        ans *= A[i+j]
    # print(tmp, ans)
    if tmp < ans:
        print('Yes')
    else:
        print('No')
    tmp = ans


# 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()))
li = list(map(int, input().split()))

s = 1
for i in range(k):
    s *= li[i]

for i in range(k, n):
    t = s * li[i]
    t //= li[i-k]

    if s < t:
        print('Yes')
    else:
        print('No')
        
    s = t


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

for i in range(k, n):

    if li[i-k] < li[i]:
        print('Yes')
    else:
        print('No')
# Original solution
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
for i in range(1,N):
    A[i] *= A[i-1]
A = [1] + A
for i in range(K,N):
    if A[i]/A[i-K] < A[i+1]/A[i+1-K]:
        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()))

# 累積積
AC = [1]
for a in A:
    AC.append(AC[-1]*a)
AC.pop(0)
# print(AC)

for i in range(k,n):
    if (i-1)-k < 0:
        prev = AC[i-1]
    else:
        prev = AC[i-1] / AC[(i-1)-k]
    
    if i-k < 0:
        now = AC[i]
    else:
        now = AC[i] / AC[i-k]
    # print(prev)
    # print(now)
    # print((i-1)-(k))
    # print(i-1)
    # print("****")
    # print(i-(k))
    # print(i)
    if prev < now:
        print("Yes")
    else:
        print("No")
    # print("----------")

# 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
from sys import stdin

def multiple(A,st,ed):
    res = 1
    for i in range(st,ed):
        res = res * A[i]

    return res

def main():
    n, k = [int(x) for x in stdin.readline().rstrip().split()]
    A = [int(x) for x in stdin.readline().rstrip().split()]

    H = [0] * (n-k)
    pre = multiple(A,0,k)
    H[0] = pre

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

if __name__ == "__main__":
    main()

# Optimized solution
from sys import stdin

def multiple(A,st,ed):
    res = 1
    for i in range(st,ed):
        res = res * A[i]

    return res

def main():
    n, k = [int(x) for x in stdin.readline().rstrip().split()]
    A = [int(x) for x in stdin.readline().rstrip().split()]

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

if __name__ == "__main__":
    main()
# Original solution
def main():
    n, k = list(map(int, input().split()))
    results = tuple(map(int, input().split()))

    products = 1
    for result in results[:k]:
        products *= result
    for i in range(n-k):
        new_products = products * results[i+k] / results[i]
        if products < new_products:
            print('Yes')
        else:
            print('No')
        products = new_products


if __name__ == '__main__':
    main()


# Optimized solution
def main():
    n, k = list(map(int, input().split()))
    results = tuple(map(int, input().split()))

    for i in range(n-k):
        print(('Yes' if results[i] < results[i+k] else 'No'))



if __name__ == '__main__':
    main()
# Original solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
b = []
for i in range(n-k+1):
    x = 1
    for j in range(i,k+i):
        x *= a[j]
    b.append(x)
for i in range(n-k):
    if b[i+1] > b[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(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 = 1
for i in range(k):
    b *= a[i]
for i in range(k,n):
    c = b
    b = b // a[i-k]
    b *= a[i]
    if b > c:
        print('Yes')
    else:
        print('No')

# Optimized solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
b = 1
for i in range(k,n):
    if a[i] > a[i-k]:
        print('Yes')
    else:
        print('No')
# Original solution
import collections
d = collections.deque()

N, K = list(map(int, input().split()))
A = [int(i) for i in input().split()]
for _ in range(K):
    d.append(A[_])


for i in range(K,N):
    sum_1 = sum(d)
    d.popleft()
    d.append(A[i])
    sum_2 = sum(d)
    if sum_1 < sum_2: print('Yes')
    else: print('No')

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

g = 1
grade = []
for i in range(n):
    g *= a[i]
    if i+1 > k:
        g /= a[i-k]
    grade.append(int(g))

for i in range(k, n):
    if grade[i-1] < grade[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(n):
    if i+1 > k:
        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()))
a.reverse()
s=1
for i in range(k):
    s*=a[i]
x=[s]
for i in range(k,n):
    s//=a[i-k]
    s*=a[i]
    x.append(s)
x.reverse()
for i in range(1,len(x)):
    if x[i]>x[i-1]:
        print("Yes")
    else:
        print("No")


# Optimized solution
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.reverse()
ans=[]
for i in range(k,n):
    if a[i]<a[i-k]:
        ans.append("Yes")
    else:
        ans.append("No")
ans.reverse()
for s in ans:
    print(s)
# Original solution
# Problem C - Marks
# input
N, K = list(map(int, input().split()))
a_nums = list(map(int, input().split()))

# initialization
cumulative_sum = 1
for i in range(K):
    cumulative_sum *= a_nums[i]
cumulative_list = [0] * N
cumulative_list[K-1] = cumulative_sum

# cumulative sum calc
for i in range(K, N):
    cumulative_sum = cumulative_sum // a_nums[i-K]
    cumulative_sum = cumulative_sum * a_nums[i]
    cumulative_list[i] = cumulative_sum

# check
for i in range(K, N):
    if cumulative_list[i]>cumulative_list[i-1]:
        print("Yes")
    else:
        print("No")


# Optimized solution
# Problem C - Marks
# input
N, K = list(map(int, input().split()))
a_nums = list(map(int, input().split()))

# initialization
cumulative_sum = 1
for i in range(K):
    cumulative_sum += a_nums[i]
cumulative_list = [0] * N
cumulative_list[K-1] = cumulative_sum

# cumulative sum calc
for i in range(K, N):
    cumulative_sum = cumulative_sum - a_nums[i-K]
    cumulative_sum = cumulative_sum + a_nums[i]
    cumulative_list[i] = cumulative_sum
    if cumulative_list[i]>cumulative_list[i-1]:
        print("Yes")
    else:
        print("No")
# Original solution
def prod(A):
    ans = 1
    for a in A:
        ans *= a
    return ans


def solve():
    N, K = [int(x) for x in input().split()]
    A = [int(x) for x in input().split()]
    for i in range(K, N):
        if i < K:
            continue
        if prod(A[i - K + 1:i + 1]) > prod(A[i - K:i]):
            print('Yes')
        else:
            print('No')


if __name__ == "__main__":
    solve()

# Optimized solution
def solve():
    N, K = [int(x) for x in input().split()]
    A = [int(x) for x in input().split()]
    ans = []
    for i in range(K, N):
        if A[i - K] < A[i]:
            ans.append('Yes')
        else:
            ans.append('No')
    print(('\n'.join(ans)))


if __name__ == "__main__":
    solve()
# Original solution
N, K = list(map(int, input().split()))
scores = list(map(int, input().split()))
grades =[]
for i in range(K+1,N+2):
    before = 1
    for j in range(K):
        before = before*scores[i-j-2]
    grades.append(before)

for k in range(N-K):
    if grades[k]>=grades[k+1]:
        print("No")
    else:
        print("Yes")


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

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

pre = 1
for i in range(k):
    pre *= A[i]

def prod(i, k, pre):
    now = pre / A[i-k-1] * A[i-1]
    return now

for i in range(k+1, n+1):
    now = prod(i, k, pre)
    if now <= pre:
        print('No')
    else:
        print('Yes')
    pre = now


# 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()))

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

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


# 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
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy
import bisect

n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
d = 1
for i in range(k):
    d = d*a[i]
b = [d]
for i in range(n-k):
    c = (b[-1]*a[k+i])//a[i]
    b.append(c)
for i in range(n-k):
    if b[i+1]>b[i]:
        print("Yes")
    else:
        print("No")

# Optimized solution
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy
import bisect
mod = 10**9+7

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