CodeEff/ECCO huggingface dataset:
# Original solution
def main():
    n, k, c = map(int, input().split())
    s = input()

    if c == 0:
        if s.count('o') == k:
            ret = [i for i, c in enumerate(s) if c == 'o']
        else:
            ret = []

    else:

        go = set()
        back = set()

        i = 0
        while i < n:
            if s[i] == 'o':
                go.add(i)
                if len(go) == k:
                    break
                i += c + 1
            else:
                i += 1

        if len(go) < k:
            return

        i = n - 1
        while i >= 0:
            if s[i] == 'o':
                back.add(i)
                if len(back) == k:
                    break
                i -= c + 1
            else:
                i -= 1

        if len(back) < k:
            return

        isec = go & back

        ret = []
        for elm in isec:
            go = set()
            i = 0
            while i < n:
                if i == elm:
                    i += 1
                    continue

                if s[i] == 'o':
                    go.add(i)
                    if len(go) == k:
                        break
                    i += c + 1
                else:
                    i += 1

            if len(go) < k:
                ret.append(elm)

    print(*map(lambda x: x + 1, ret), sep='\n')


if __name__ == '__main__':
    main()


# Optimized solution
def main():
    N, K, C = map(int, input().split())
    s = input()

    L = [-1] * K
    R = [-1] * K

    i = 0
    cur = 0
    while i < N and cur < K:
        if s[i] == 'o':
            L[cur] = i
            cur += 1
            i += C + 1
        else:
            i += 1

    i = N - 1
    cur = K - 1
    while i >= 0 and cur >= 0:
        if s[i] == 'o':
            R[cur] = i
            cur -= 1
            i -= C + 1
        else:
            i -= 1

    ans = (left + 1 for left, right in zip(L, R) if left == right)

    print(*ans, sep='\n')


if __name__ == '__main__':
    main()
# Original solution
def main():
    from bisect import bisect_left, bisect_right

    N, K, C = map(int, input().split())
    s = input()

    L = [0] * (N + 2)
    R = [0] * (N + 2)
    # 1-indexedで管理した
    # 貪欲に端から配置した場合に達成可能な
    # 累積配置数

    need = [0] * N

    i = 0
    while i < N:
        if s[i] == 'o':
            L[i + 1] = 1
            need[i] += 1
            i += C + 1
        else:
            i += 1

    i = N - 1
    while i >= 0:
        if s[i] == 'o':
            R[i + 1] = 1
            need[i] += 1
            i -= C + 1
        else:
            i -= 1

    for i in range(N):
        L[i + 1] += L[i]
        R[i + 1] += R[i]

    ans = []
    for i in range(N):
        if need[i] == 2:
            li = bisect_left(L, L[i])  # 1-indexed
            if R[i + 1] == R[i + 2]:
                ri = bisect_right(R, R[i + 2]) + 1
            else:
                ri = i + 2  # 1-indexed
            d = (ri - li + 1 <= C)
            except_i = L[i] + (R[N] - R[i + 1]) - d
            if except_i < K:
                ans.append(i + 1)

    print(*ans, sep='\n')


if __name__ == '__main__':
    main()

# 前後両端について
# それぞれから貪欲に配置した累積配置数を準備
# 必ず働く日は
# 前から貪欲に配置したケースと
# 後ろから貪欲に配置したケースの重なりに含まれる必要があり、
# そのような重なり(need==2)について
# その日に働かないとした場合の前後の累積配置数の和がK未満なら働く必要がある


# Optimized solution
def main():
    N, K, C = map(int, input().split())
    S = input()

    L = [-1] * K  # 0-ind

    i = 0
    cur = 0
    while i < N:
        if S[i] == 'o':
            L[cur] = i
            cur += 1
            if cur == K: break
            i += C
        i += 1

    R = [-1] * K  # 0-ind

    i = N - 1
    cur = K - 1
    while i >= 0:
        if S[i] == 'o':
            R[cur] = i
            cur -= 1
            if cur == -1: break
            i -= C
        i -= 1

    ans = (l + 1 for l, r in zip(L, R) if l == r)  # 1-ind
    print(*ans, sep='\n')


if __name__ == '__main__':
    main()
# Original solution
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

# 前からと後ろからでcandに入れて両方に入るところ
N, K, C = lr()
S = sr()
cand1 = set()
cand2 = set()

def F(S):
    cand = set()
    count = 0
    cur = 0
    while cur < len(S):
        if S[cur] == 'o':
            count += 1
            cand.add(cur)
            cur += C+1            
        else:
            cur += 1
        if count >= K:
            break
    return cand

cand1 = F(S)
cand2 = F(S[::-1])
cand2 = set(N-1-x for x in cand2)
s = cand1 & cand2
s = sorted(list(s))
s = [x+1 for x in s]

def check(S):
    count = 0
    cur = 0
    while cur < len(S):
        if S[cur] == 'o':
            count += 1
            cur += C+1            
        else:
            cur += 1
        if count >= K:
            return True
    return False

for x in s:
    T = list(S)
    T[x-1] = 'x'
    if not check(T):
        print(x)


# Optimized solution
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

# 前からと後ろからでgreedyにcandに入れて両方の一致したところ
N, K, C = lr()
S = sr()

def choose(S):
    cand = []
    count = 0
    cur = 0
    while cur < len(S):
        if S[cur] == 'o':
            count += 1
            cand.append(cur)
            cur += C+1            
        else:
            cur += 1
        if count >= K:
            break
    return cand

cand1 = choose(S)
cand2 = choose(S[::-1])[::-1]
cand2 = [N-1-x for x in cand2]

for x, y in zip(cand1, cand2):
    if x == y:
        print((x+1))
# Original solution
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

# 前からと後ろからでgreedyにcandに入れて両方の一致したところ
N, K, C = lr()
S = sr()

def choose(S):
    cand = []
    count = 0
    cur = 0
    while cur < len(S):
        if S[cur] == 'o':
            count += 1
            cand.append(cur)
            cur += C+1            
        else:
            cur += 1
        if count >= K:
            break
    return cand

cand1 = choose(S)
cand2 = choose(S[::-1])[::-1]
cand2 = [N-1-x for x in cand2]

for x, y in zip(cand1, cand2):
    if x == y:
        print((x+1))


# Optimized solution
# coding: utf-8
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

N, K, C = lr()
S = sr()
# 左からと右からでそれぞれ貪欲、重なったところが必須
left = []; right = []

def work(S):
    ret = []
    cur = 0
    count = 0
    while count < K:
        if S[cur] == 'o':
            count += 1
            ret.append(cur)
            cur += C + 1
        else:
            cur += 1
    return ret

left = work(S)
right = work(S[::-1])
right = [N-1-x for x in right]
right.reverse()
answer = []
for l, r in zip(left, right):
    if l == r:
        answer.append(str(l+1))
print(('\n'.join(answer)))
# Original solution
import sys
sys.setrecursionlimit(10 ** 6)


def dfs(n, rest):
    global C, N
    rst = 0
    if maxR[n] > 0:
        rst = maxR[n]
    elif rest >= C and S[n] == 'o':
        rst += 1
        if n + (C + 1) < N:
            rst += dfs(n + C + 1, C)
    else:
        if n + 1 < N:
            rst += dfs(n + 1, rest + 1)
    maxR[n] = rst
    return rst


def dfs2(n, rest):
    global C, N
    rst = 0
    if maxL[n] > 0:
        rst = maxL[n]
    elif rest >= C and S[n] == 'o':
        rst += 1
        if n - (C + 1) >= 0:
            rst += dfs2(n - (C + 1), C)
    else:
        if n - 1 >= 0:
            rst += dfs2(n - 1, rest + 1)
    maxL[n] = rst
    return rst


N, K, C = map(int, input().split())
S = input()
maxR = [-1] * N
for i in range(N):
    if S[i] == 'o' and maxR[i] == -1:
        maxR[i] = dfs(i, C)

if maxR[-1] == -1:
    maxR[-1] = 0
for i in range(N - 2, -1, -1):
    if maxR[i] == -1:
        maxR[i] = maxR[i + 1]

maxL = [-1] * N
for i in range(N - 1, -1, -1):
    if S[i] == 'o' and maxL[i] == -1:
        maxL[i] = dfs2(i, C)

if maxL[0] == -1:
    maxL[0] = 0
for i in range(1, N):
    if maxL[i] == -1:
        maxL[i] = maxL[i - 1]

ans = []
for i in range(N):
    r = maxR[i + 1] if i + 1 < N else 0
    l = maxL[i - 1] if i - 1 >= 0 else 0
    if r + l < K:
        ans.append(i + 1)

print(*ans, sep='\n')


# Optimized solution
import sys
sys.setrecursionlimit(10 ** 6)


def dfs(n, rest):
    global C, N
    rst = 0
    if maxR[n] > 0:
        rst = maxR[n]
    elif rest >= C and S[n] == 'o':
        rst += 1
        if n + (C + 1) < N:
            rst += dfs(n + C + 1, C)
    else:
        if n + 1 < N:
            rst += dfs(n + 1, rest + 1)
    maxR[n] = rst
    return rst


def dfs2(n, rest):
    global C, N
    rst = 0
    if maxL[n] > 0:
        rst = maxL[n]
    elif rest >= C and S[n] == 'o':
        rst += 1
        if n - (C + 1) >= 0:
            rst += dfs2(n - (C + 1), C)
    else:
        if n - 1 >= 0:
            rst += dfs2(n - 1, rest + 1)
    maxL[n] = rst
    return rst


N, K, C = map(int, input().split())
S = input()
maxR = [-1] * N
for i in range(N):
    if maxR[i] == -1:
        maxR[i] = dfs(i, C)

# if maxR[-1] == -1:
#     maxR[-1] = 0
# for i in range(N - 2, -1, -1):
#     if maxR[i] == -1:
#         maxR[i] = maxR[i + 1]

maxL = [-1] * N
for i in range(N - 1, -1, -1):
    if maxL[i] == -1:
        maxL[i] = dfs2(i, C)

# if maxL[0] == -1:
#     maxL[0] = 0
# for i in range(1, N):
#     if maxL[i] == -1:
#         maxL[i] = maxL[i - 1]

ans = []
for i in range(N):
    r = maxR[i + 1] if i + 1 < N else 0
    l = maxL[i - 1] if i - 1 >= 0 else 0
    if r + l < K:
        ans.append(i + 1)

print(*ans, sep='\n')
# Original solution
import sys
sys.setrecursionlimit(10 ** 6)


def dfs(n, rest):
    global C, N
    rst = 0
    if maxR[n] > 0:
        rst = maxR[n]
    elif rest >= C and S[n] == 'o':
        rst += 1
        if n + (C + 1) < N:
            rst += dfs(n + C + 1, C)
    else:
        if n + 1 < N:
            rst += dfs(n + 1, rest + 1)
    maxR[n] = rst
    return rst


def dfs2(n, rest):
    global C, N
    rst = 0
    if maxL[n] > 0:
        rst = maxL[n]
    elif rest >= C and S[n] == 'o':
        rst += 1
        if n - (C + 1) >= 0:
            rst += dfs2(n - (C + 1), C)
    else:
        if n - 1 >= 0:
            rst += dfs2(n - 1, rest + 1)
    maxL[n] = rst
    return rst


N, K, C = map(int, input().split())
S = input()
maxR = [-1] * N
for i in range(N):
    if maxR[i] == -1:
        maxR[i] = dfs(i, C)

# if maxR[-1] == -1:
#     maxR[-1] = 0
# for i in range(N - 2, -1, -1):
#     if maxR[i] == -1:
#         maxR[i] = maxR[i + 1]

maxL = [-1] * N
for i in range(N - 1, -1, -1):
    if maxL[i] == -1:
        maxL[i] = dfs2(i, C)

# if maxL[0] == -1:
#     maxL[0] = 0
# for i in range(1, N):
#     if maxL[i] == -1:
#         maxL[i] = maxL[i - 1]

ans = []
for i in range(N):
    r = maxR[i + 1] if i + 1 < N else 0
    l = maxL[i - 1] if i - 1 >= 0 else 0
    if r + l < K:
        ans.append(i + 1)

print(*ans, sep='\n')


# Optimized solution
N, K, C = map(int, input().split())
S = input()

L = [0] * K
k = 0
i = 0
rest = C
while k < K:
    if rest >= C and S[i] == 'o':
        L[k] = i
        k += 1
        rest = 0
    else:
        rest += 1
    i += 1

R = [0] * K
k = K
i = N - 1
rest = C
while k > 0:
    if rest >= C and S[i] == 'o':
        R[k - 1] = i
        k -= 1
        rest = 0
    else:
        rest += 1
    i -= 1

ans = []
for k in range(K):
    if L[k] == R[k]:
        ans.append(L[k] + 1)
print(*ans, sep='\n')
# Original solution
from bisect import bisect_left, bisect_right

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

work = [i for i, e in enumerate(s, 1) if e == "o"]
INF = 10 ** 9

work_l = []
prev = -INF
for e in work:
    if e - prev > c:
        work_l.append(e)
        prev = e

work_r = []
prev = INF
for e in work[::-1]:
    if prev - e > c:
        work_r.append(e)
        prev = e

work_r = work_r[::-1]

ans = []
mx_r = len(work_r)
for e in work:
    l = bisect_left(work_l, e)
    r = mx_r - bisect_right(work_r, e)
    if l + r < k:
        ans.append(e)

print(*ans, sep="\n")


# Optimized solution
n, k, c = map(int, input().split())
s = input()
INF = 10 ** 9

work = [i for i, e in enumerate(s, 1) if e == "o"]
l = [0] * (n + 1)
r = [0] * (n + 1)

prev = -INF
cnt = 0
for e in work:
    if e - prev > c:
        cnt += 1
        l[cnt] = e
        prev = e

prev = INF
cnt = 0
for e in work[::-1]:
    if prev - e > c:
        cnt += 1
        r[cnt] = e
        prev = e

l = l[1:k+1]
r = r[1:k+1][::-1]

ans = []
for el, er in zip(l, r):
    if el == er:
        ans.append(el)

print(*ans, sep="\n")
# Original solution
import sys
readline = sys.stdin.readline

# もっとも早い日に貪欲に働いたパターン
# もっとも遅い日に貪欲に働いたパターン
# 上記でX回目の仕事が同じ日であればその日は必ず働く必要がある

N,K,C = list(map(int,readline().split()))
S = readline().rstrip()

fast = [0] * K
ind = 0
cnt = 0
while cnt < K: # K回働くまで
  if S[ind] == "o":
    fast[cnt] = ind
    cnt += 1
    ind += (C + 1)
  else:
    ind += 1

late = [0] * K
ind = len(S) - 1
cnt = 0
while cnt < K:
  if S[ind] == "o":
    late[cnt] = ind
    cnt += 1
    ind -= (C + 1)
  else:
    ind -= 1
    
late = late[::-1]

ans = []
for i in range(K):
  if fast[i] == late[i]:
    ans += [fast[i] + 1]
    
for a in ans:
  print(a)

# Optimized solution
import sys
readline = sys.stdin.readline

# もっとも早い日に貪欲に働いたパターン
# もっとも遅い日に貪欲に働いたパターン
# 上記でX回目の仕事が同じ日であればその日は必ず働く必要がある

N,K,C = list(map(int,readline().split()))
S = readline().rstrip()

fast = [0] * K
ind = 0
cnt = 0
while cnt < K: # K回働くまで
  if S[ind] == "o":
    fast[cnt] = ind
    cnt += 1
    ind += (C + 1)
  else:
    ind += 1

late = [0] * K
ind = len(S) - 1
cnt = K - 1
while 0 <= cnt:
  if S[ind] == "o":
    late[cnt] = ind
    cnt -= 1
    ind -= (C + 1)
  else:
    ind -= 1
    
ans = []
for i in range(K):
  if fast[i] == late[i]:
    ans += [fast[i] + 1]
    
for a in ans:
  print(a)
# Original solution
n,a,b=list(map(int,input().split()))
print((min([a*n,b])))

# Optimized solution
n,a,b=list(map(int,input().split()))
print((min(n*a,b)))
# Original solution
n,a ,b = list(map(int, input().split()))
s = a * n
print((min(s,b)))


# Optimized solution
n,a,b = list(map(int, input().split()))
print((min(n*a, b)))
# Original solution
li=list(map(int,input().split()))

if li[0]*li[1]>li[2]:
  print((li[2]))
else:
  print((li[0]*li[1]))

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

if n*a>b:
  print(b)

else:
  print((n*a))
# Original solution
N, A, B = list(map(int, input().split()))

x = N*A
y = B

li = [x,y]
print((min(li)))

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

li = [N*A,B]
print((min(li)))
# Original solution
N, A, B = list(map(int,input().split()))


if N * A <= B:
    print((N * A))
else:
    print(B)

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

C = N * A

if C < B:
    print(C)
else:
    print(B)
# Original solution
import sys, heapq, bisect, math, fractions
from collections import deque

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

print((min(A * N, B)))

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

print((min(A * N, B)))
# Original solution
N,A,B=list(map(int,input().split()))
print((min(N*A,B)))

# Optimized solution
n,a,b=list(map(int,input().split()))
print((min(n*a,b)))
# Original solution
n,a,b = list(map(int,input().split()))
print((min(n*a,b)))

# Optimized solution
n,a,b = list(map(int,input().split()))
print((min(a*n,b)))
# Original solution
n,a,b=list(map(int,input().split()))
print((min(a*n,b)))

# Optimized solution
N,A,B = list(map(int,input().split()))
print((min(A*N,B)))
# Original solution
# 電車代とタクシー代で小さい方を選ぶ
# 電車が安い
n,a,b = list(map(int, input().split()))

if a * n <= b:
    print((a * n))
# タクシーが安い
else:
    print(b)

# Optimized solution
n,a,b = list(map(int, input().split()))
if a * n <= b:
    print((a * n))
else:
    print(b)
# Original solution
from time import sleep
n, a, b = list(map(int, input().split()))
sleep(3.0)
print((min(a * n, b)))

# Optimized solution
# coding: utf-8
# Your code here!


N,A,B = list(map(int,input().split())) 
print((B if A*N > B else A*N))
# Original solution
n,a,b = list(map(int,input().split()))
print((min(a*n,b)))

# Optimized solution
n,a,b = list(map(int,input().split()))
print((min(n*a,b)))
# Original solution
s = [int(i) for i in input().split()]
print(s[0]*s[1])    if (s[0]*s[1] < s[2])  else print(s[2])


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

if N*A > B:
  print(B)
else:
  print((N*A))
# Original solution
# -*- coding: utf-8 -*-
N,A,B = list(map(int,input().split()))
train = N*A
taxi = B
result = train - taxi

if result >= 0:
    print(taxi)
else:
    print(train)


# Optimized solution
n,a,b=list(map(int,input().split()))
train=a*n
taxi=b
print((min(train,taxi)))
# Original solution
N, A, B = list(map(int, input().split()))

print((min(A * N, B)))

# Optimized solution
N, A, B = list(map(int, input().split()))
print((min(N * A, B)))
# Original solution
n,a,b = list(map(int, input().split()))
train = a*n
taxi = b
if train <= taxi:
    print(train)
else:
    print(taxi)

# Optimized solution
n,a,b = list(map(int, input().split()))
train = a*n
taxi = b
cost = min(train,taxi)
print(cost)
# Original solution
d, t, s = list(map(int, input().split()))

print(("Yes" if d / s <= t else "No"))


# Optimized solution
d, t, s = list(map(int, input().split()))

print(("Yes" if t * s >= d else "No"))
# Original solution
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from collections import Counter
def main():
    d, t, s = list(map(int, input().split()))
    dis = s * t
    if d > dis:
        print('No')
    else:
        print('Yes')

if __name__ == '__main__':
    main()

# Optimized solution
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines

def main():
    d, t, s = list(map(int, input().split()))
    if t * s >= d:
        print('Yes')
    else:
        print('No')

if __name__ == '__main__':
    main()
# Original solution
DTS = [int(i) for i in input().split()]
D = DTS[0]
T = DTS[1]
S = DTS[2]
if D/T <= S:
    print("Yes")
else:
    print("No")

# Optimized solution
input_list = [int(num) for num in input().split()]

D = input_list[0]
T = input_list[1]
S = input_list[2]

if D/S <= T:
    print("Yes")

else:
    print("No")
# Original solution
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda: [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda: list(map(int, read().split()))


def main():
    D, T, S = in_nn()

    if S * T >= D:
        print("Yes")
    else:
        print("No")


if __name__ == '__main__':
    main()


# Optimized solution
D, T, S = list(map(int, input().split()))

if T * S >= D:
    print("Yes")
else:
    print("No")
# Original solution
D, T, S = list(map(int, input().split()))

distance = T * S

if D > distance:
  print('No')
else:
  print('Yes')

# Optimized solution
D, T, S = list(map(int, input().split()))

distance = T * S

if D <= distance:
  print('Yes')
else:
  print('No')
# Original solution
d, t, s = list(map(int, input().split()))
ans = d / s

if t >= ans:
    print("Yes")
else:
    print("No")
  


# Optimized solution
D, T, S = list(map(int, input().split()))

if D/S <= T:
  print("Yes")
else:
  print("No")
# Original solution
d,t,s=list(map(int,input().split()))
print(('Yes' if d/s<=t else 'No'))


# Optimized solution
d,t,s=list(map(int,input().split()))
print(('Yes' if s*t>=d else 'No'))
# Original solution
D,T,S = list(map(int,input().split()))
if D/S <= T:
  print("Yes")
else:
  print("No")

# Optimized solution
D,T,S = list(map(float,input().split()))
if D/S <= T:
  print("Yes")
else:
  print("No")
# Original solution
d,t,s=list(map(int,input().split()))
p=d/s
if t>=p:
  print('Yes')
else:
  print('No')

# Optimized solution
from sys import stdin
def ip():
    return stdin.readline().rstrip()
d,t,s=list(map(int,ip().split()))
if d<=t*s:
    print('Yes')
else:
    print('No')
# Original solution
x,y ,z= list(map(int,input().split()))
if(x<=y*z):
	print('Yes')
else:
	print('No')

# Optimized solution
x,y ,z= list(map(int,input().split()))
ans=x/z
if ans<=y:
	print('Yes')
else:
	print('No')
# Original solution
# -*- coding: utf-8 -*-
# 標準入力を取得
D, T, S = list(map(int, input().split()))

# 求解処理
ans = str()
if D <= S * T:
    ans = "Yes"
else:
    ans = "No"

# 結果出力
print(ans)


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

def get_input() -> tuple:
    """
    標準入力を取得する.

    Returns:\n
        tuple: 標準入力
    """
    D, T, S = list(map(int, input().split()))

    return D, T, S


def main(D: int, T: int, S: int) -> None:
    """
    メイン処理.

    Args:\n
        D (int): 待ち合わせ場所(1 <= D <= 10000)
        T (int): 待ち合わせ時間(1 <= T <= 10000)
        S (int): 分速(1 <= S <= 10000)
    """
    # 求解処理
    ans = str()
    if D <= S * T:
        ans = "Yes"
    else:
        ans = "No"

    # 結果出力
    print(ans)


if __name__ == "__main__":
    # 標準入力を取得
    D, T, S = get_input()

    # メイン処理
    main(D, T, S)
# Original solution
D,T,s=list(map(int,input().split()))
if s*T-D>=0:
  print("Yes")
else:
  print("No")

# Optimized solution
d,t,s=list(map(int,input().split()))
if d<=t*s:
    print("Yes")
else:
    print("No")
# Original solution
d,t,s = list(map(int, input().split()))

ans = d / s

if ans > t:
    print("No")
else :
    print("Yes")

# Optimized solution
d,t,s = list(map(int, input().split()))

dist = t * s

if dist >= d:
    print("Yes")
else :
    print("No")
# Original solution
# 入力
D, T, S = input().split()

# 以下に回答を記入
D = int(D)
T = int(T)
S = int(S)

if D - T * S <= 0:
  print('Yes')
else:
  print('No')

# Optimized solution
# 入力
D, T, S = input().split()

# 以下に回答を記入
D = int(D)
T = int(T)
S = int(S)

if T * S >= D:
  print('Yes')
else:
  print('No')
# Original solution
'''
Created on 2020/08/29

@author: harurun
'''
def main():
  import sys
  pin=sys.stdin.readline
  pout=sys.stdout.write
  perr=sys.stderr.write
  
  D,T,S=list(map(int,pin().split()))
  if S*T>=D:
    print("Yes")
  else:
    print("No")
  return 
main()

# Optimized solution
a,b,c=list(map(int,input().split()))
if a<=b*c:print("Yes")
else:print("No")
  
#連続acしなきゃ……
# Original solution
d, t, s = list(map(int, input().split()))

# s*t = d'

if s*t >= d: print('Yes')
else:print('No')


# Optimized solution
d, t, s = list(map(int, input().split()))
print(('No' if s*t < d else 'Yes'))
# Original solution
D,T,S = list(map(int,input().split()))

su = D / S
#print(su)
if su <= T:
    print("Yes")
else:
    print("No")


# Optimized solution
#177A
D,T,S = list(map(int,input().split()))

if D / S <= T:
    print("Yes")

else:
    print("No")
# Original solution
d, t, s = list(map(int, input().split()))
if t * s < d: print("No")
else:print("Yes")

# Optimized solution
d, t, s = list(map(int, input().split()))
print(("No" if t*s < d else"Yes"))
# Original solution
def resolve():
    d, t, s = list(map(int, input().split()))
    print(("Yes" if t * s >= d else "No"))


if __name__ == '__main__':
    resolve()


# Optimized solution
d,t,s=list(map(int, input().split()));print(("YNeos"[t*s<d::2]))
# Original solution
def resolve():
    d, t, s = list(map(int, input().split()))
    if t >= d/s:
        print("Yes")
    else:
        print("No")
resolve()

# Optimized solution
d, t, s = list(map(int, input().split()))
if t < d/s:
  print("No")
else:
  print("Yes")
# Original solution
a,t,s=list(map(int,input().split()))
if a<=t*s:
    print("Yes")
else:
    print("No")

# Optimized solution
d, t, s = list(map(int, input().split()))
if d <= t * s:
    print("Yes")
else:
    print("No")
# Original solution
D,T,S=list(map(int,input().split()))
if T*S>=D:
    print("Yes")
else:
    print("No")





    









        

    









    

        




    















    



    





    






        






    
















        


























            
    


    


    
    














    


    














# Optimized solution
D,T,S=list(map(int,input().split()))

if S*T<D:
    print("No")
else:
    print("Yes")