Harryxun/stf_run huggingface dataset:
inp = input()
res = 0
for i in range(len(inp)):
	for j in range(i, len(inp)):
    	if len([w for w in inp[i:j] if w in ["A", "C", "G", "T"]]) == (j-i):
        	res = max(res, j-i)
print(res)

### FIXED CODE ###

inp = input()
res = 0
for i in range(len(inp)+1):
  for j in range(i+1, len(inp)+1):
    if len([w for w in inp[i:j] if w in ["A", "C", "G", "T"]]) == (j-i):
      res = max(res, j-i)
print(res)
s = input()
ans = "No"

if (s[2] == s[3])and (s[4] == s[5])and (s[2] != s[4])and (s[0]!=s[1])and (s[0]!=s[2])ans(s[0]!=s[4]):
    ans = "Yes"

print(ans)


### FIXED CODE ###

s = input()
ans = "No"

if (s[2] == s[3])and (s[4] == s[5]):
    ans = "Yes"

print(ans)
N=int(input())
A=map(float,input().split())
A.sort()
r=A[0]
for i in range(1,N,1):
  r=(r+A[i])/2
print(r)

### FIXED CODE ###

N=int(input())
A=list(map(int,input().split()))
A.sort()
r=A[0]
for i in range(1,N,1):
  r=float((r+A[i])/2)
print(r)
N = int(input())
ans = [0]*36

def bit(inp,ans):
    if inp == 0:
        ans[0] = 0
        inp2 = 0
    
    if inp > 0:
        b = [1,5,21,85,341,1365,5461,21845,87381,349525,1398101,5592405,22369621,89478485,357913941,1431655765]
        pcount = 0
        for ii in range(len(b)):
            if inp <= b[ii]:
                inp2 = inp - 4**ii
                break
            pcount = pcount + 1
        ans[pcount*2] = 1
        
    if inp < 0:
        b2 = [-2,-10,-42,-170,-682,-2730,-10922,-43690,-174762,-699050,-2796202,-11184810,-44739242,-178956970,-715827882]
        pcount = 0
        for ii in range(len(b2)):
            if inp >= b2[ii]:
                inp2 = inp + 2 * (4**ii)
                break
            pcount = pcount + 1
        ans[pcount*2+1] = 1
        
    return inp2,ans

    
while N != 0:
    N,ans = bit(N,ans)

fi = ans[::-1]
fistr = [str(n) for n in fi]
m = ''.join(fistr)
mm = int(m)

print(mm)

### FIXED CODE ###

N = int(input())
ans = [0]*36

def bit(inp,ans):
    if inp == 0:
        ans[0] = 0
        inp2 = 0
    
    if inp > 0:
        b = [1,5,21,85,341,1365,5461,21845,87381,349525,1398101,5592405,22369621,89478485,357913941,1431655765]
        pcount = 0
        for ii in range(len(b)):
            if inp <= b[ii]:
                inp2 = inp - 4**ii
                break
            pcount = pcount + 1
        ans[pcount*2] = 1
        
    if inp < 0:
        b2 = [-2,-10,-42,-170,-682,-2730,-10922,-43690,-174762,-699050,-2796202,-11184810,-44739242,-178956970,-715827882,-2863311530]
        pcount = 0
        for ii in range(len(b2)):
            if inp >= b2[ii]:
                inp2 = inp + 2 * (4**ii)
                break
            pcount = pcount + 1
        ans[pcount*2+1] = 1
        
    return inp2,ans

    
while N != 0:
    N,ans = bit(N,ans)

fi = ans[::-1]
fistr = [str(n) for n in fi]
m = ''.join(fistr)
mm = int(m)

print(mm)
print("Yes" if len(set(map(int, input().split())) == 2 else "No")

### FIXED CODE ###

print("Yes" if len(set(map(int, input().split()))) == 2 else "No")
a,b = map(int(),input().split())

if a*b % 2 ==1:
	print("Odd")
else:
	print("Even")    

### FIXED CODE ###

a,b = map(int,input().split())
 
if a*b % 2 == 1:
    print("Odd")
else:
    print("Even")
n,m = map(int,input().split())
lng = []
for _ in range(n-1):
    lng.append(int(input()))
i = 0
sm = 0
for _ in range(m):
    j = i+int(input())
    mv = sum(lng[i:j]) if j > i else sum(lng[j:i])
    sm += mv
    i = j
print(sm%100000)

### FIXED CODE ###

n,m = map(int,input().split())
lng = [0]
for _ in range(n-1):
    lng.append(lng[-1] + int(input()))
i = 0
sm = 0
for _ in range(m):
    j = i+int(input())
    sm += abs(lng[i]-lng[j])
    sm %= 100000
    i = j
print(sm)
N, M = map(int, raw_input().split())
a={}
b={}
for i in range(M):
    k,l=map(int, raw_input().split())
    if k==1:
        a.add(k)
    if l==N:
        b.add(l)
if a&b:
    print("POSSIBLE")
else:
    print("IMPOSSIBLE")

### FIXED CODE ###

x=input()
print("ABC"+str(x))
n = input()
m = map(int,raw_input().split())
a = 0
for i in xrange(n):
    a += m[i]
 
print min(m),max(m),a
 

 
Compile Error Logs: 

You are not authorized to see the message. 
 
 
Status 
 

### FIXED CODE ###

n = int(raw_input())
a = map(int, raw_input().split())
 
print min(a), max(a), sum(a)
import math

def main():
    data_num, max_num_10 = list(map(int, input().split()))
    data = list(map(int, input().split()))

    max_num_2 = bin(max_num_10)[2:]
    ketasuu = len(max_num_2)
    # keta_count = [0 for i in range(ketasuu)]

    max_ketasuu = ketasuu
    for point_10 in data:
        point_2 = bin(point_10)[2:]
        # print(point_2)
        if max_ketasuu < len(point_2):
            max_ketasuu = len(point_2)

    keta_count = [0 for i in range(max_ketasuu)]

    for point_10 in data:
        point_2 = bin(point_10)[2:][::-1]
        # print(point_2)
        for i in range(len(point_2)):
            if point_2[i] == '1':
                    keta_count[i] += 1
        # print(keta_count)

    ans = ''
    for i in range(ketasuu):
        if keta_count[i] >= math.ceil(data_num / 2):
            ans += '0'
        else:
            ans += '1'
    ans = ans[::-1]


    if max_num_10 < int(ans, 2):
        for i in range(ketasuu):
            if ans[i] == '1':
                # print(ans)
                ans = list(ans)
                # print(ans)
                ans[i] = '0'
                # print(ans)
                ans = ''.join(ans)
                # print(ans)
                break

    ans = ans[::-1]

    ans_count = 0
    now_point = 1

    for i in range(max_ketasuu):
        if i >= ketasuu:
            count_number = keta_count[i]
        else:
            if ans[i] == '1':
                count_number = data_num - keta_count[i]
            else:
                count_number = keta_count[i]
            # print(ans_count, now_point, count_number)
        ans_count += now_point * count_number
        now_point *= 2

    print(ans_count)



if __name__ == '__main__':
    main()


### FIXED CODE ###

a, b = list(map(int, input().split()))
print(a/b)
if a <= 3200:
    print(s)
else:
    print("red")

### FIXED CODE ###

a = int(input())
s = str(input())

if a >= 3200:
    print(s)
else:
    print("red")
def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)

def lcm(a, b):
    return a * b // gcd(a, b)

import sys
input = sys.stdin.readline
N = int(input())
T = [int(input()) for _ in range(N)]
if N == 1:
    ans = T[0]
else:
    ans = lcm(T[0], T[1])
    for i in range(2, N):
    ans = lcm(ans, T[i])
print(ans)

### FIXED CODE ###

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)

def lcm(a, b):
    return a * b // gcd(a, b)

import sys
input = sys.stdin.readline
N = int(input())
if N == 1:
    print(input())
else:
    T = [int(input()) for _ in range(N)]
    ans = lcm(T[0], T[1])
    for i in range(2, N):
        ans = lcm(ans, T[i])
    print(ans)
def dfs(i, s, sum):
    if i == 3:
        if sum == 7:
            print(s + "=7")
            exit()
    dfs(i + 1, s + "+" + abcd[i + 1], sum + int(abcd[i + 1]))
    dfs(i + 1, s + "-" + abcd[i + 1], sum - int(abcd[i + 1]))
abcd = input()
dfs(0, abcd[0], int(abcd[0]))

### FIXED CODE ###

def dfs(i, f, sum):
    if i == 3:
        if sum == 7:
            print(f + "=7")
            exit()
    else:
        dfs(i + 1, f + "+" + abcd[i + 1], sum + int(abcd[i + 1]))
        dfs(i + 1, f + "-" + abcd[i + 1], sum - int(abcd[i + 1]))
abcd = input()
dfs(0, abcd[0], int(abcd[0]))
while True:
    print(sum(list(map(int,input().split()))))

### FIXED CODE ###

while True:
    try:
        print(sum(list(map(int,input().split()))))
    except:
        break
n = int(input())
a = list(map(int, input().split()))
dp = [1e9 for _ in range(n+1)]
#dp[i]...コストの最小
dp[0] = 0
dp[1] = a[0]
for i in range(n-1):
  dp[i+2] = min(dp[i+1] + abs(a[i+1] - a[i]), dp[i] + abs(a[i+2] - a[i]))
print(dp[n])

### FIXED CODE ###

n = int(input())
a = list(map(int, input().split()))
dp = [1e9]*n
dp[0] = 0
for i in range(1, n):
  dp[i] = min(dp[i], dp[i-1] + abs(a[i] - a[i-1]))
  if i > 1:
    dp[i] = min(dp[i], dp[i-2] + abs(a[i] - a[i-2]))
print(dp[n-1])
A ,B= map(float,input().split())
A = int(A)
C = str(B)
if B == 10.0:
  D = 1000
elif B == 0.0:
  D = 0
else:
  D = int(C[-1]) + int(C[-2])*10 + int(C[-4])*100
ans = A*D
ans = ans//100
print(ans)

### FIXED CODE ###

A ,B= map(float,input().split())
A = int(A)
C = str(B)
if B == 10.0:
  D = 1000
elif B == 0.0:
  D = 0
elif len(C) == 4:
  D = int(C[-1]) + int(C[-2])*10 + int(C[-4])*100
elif len(C) == 3:
  D = int(C[-1])*10 + int(C[-3])*100
  
ans = A*D
ans = ans//100
print(ans)
N,M=map(int,input().split())
h=list(map(int,input().split()))

pair=[]
for _ in range(M):
    inp=list(map(int,input().split()))
    pair.append(inp)

loser=[]
for i in range(M):
    if h[pair[i][0]]<h[pair[i][1]]:
        loser.append(pair[i][0])
    elif h[pair[i][0]]>h[pair[i][1]]:
        loser.append(pair[i][1])
    else:
        loser.append(pair[i][0])
        loser.append(pair[i][1])

set_loser=set(loser)
ans=N-int(len(set_loser))
print(ans)

### FIXED CODE ###

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

pair=[]
for _ in range(M):
    inp=list(map(int,input().split()))
    pair.append(inp)

loser=[]
for i in range(M):
    if h[pair[i][0]-1]<h[pair[i][1]-1]:
        loser.append(pair[i][0])
    elif h[pair[i][0]-1]>h[pair[i][1]-1]:
        loser.append(pair[i][1])
    else:
        loser.append(pair[i][0])
        loser.append(pair[i][1])

set_loser=set(loser)
ans=N-int(len(set_loser))
print(ans)
s = list(input())
f = int(''.join(s[:2]))
r = int(''.join(s[2:]))
yymm = 0
mmyy = 0
if 0 <= f and f <= 99:
    if 1<=r and r<= 12:
        yymm = 1
if 1<=f and f<= 12:
    if 0 <= r and r <= 99:
        mmyy = 1
if mmyy == 1 and yymm == 1:
    print('AMBIGUOUS')
elif mmyy == 0 and yymm == 1:
    print('YYMM')
elif myy == 1 and yymm == 0:
    print('MMYY')
else:
    print('NA')

### FIXED CODE ###

s = list(input())
f = int(''.join(s[:2]))
r = int(''.join(s[2:]))
yymm = 0
mmyy = 0
if 0 <= f and f <= 99:
    if 1<=r and r<= 12:
        yymm = 1
if 1<=f and f<= 12:
    if 0 <= r and r <= 99:
        mmyy = 1
if mmyy == 1 and yymm == 1:
    print('AMBIGUOUS')
elif mmyy == 0 and yymm == 1:
    print('YYMM')
elif mmyy == 1 and yymm == 0:
    print('MMYY')
else:
    print('NA')
n, l = map(int, input().split())
A = sorted([input() for _ in range(l)])
print("".join(A))


### FIXED CODE ###

N, L = map(int, input().split())
S = [input() for i in range(N)]
print("".join(sorted(S)))
a,b,c,d = map(int,input().split())
k = 0
if d>=abs(a-c):
  print("Yes")
  k += 1
if d>=abs(a-b):
  if d>=abd(b-c):
    if k == 1:
      break
    else:
      print("Yes")
      k += 1
if k == 0:
  print("No")

### FIXED CODE ###

a,b,c,d=map(int,input().split())
if abs(c-a)<=d:
  print("Yes")
elif abs(c-b)<=d and abs(b-a)<=d:
  print("Yes")
else:
  print("No")
N=int(input())
#number of cakes
if all( (N - 4*i) % 7 != 0 for i in range(N/4)):
    print("No")
else:
    print("Yes")

### FIXED CODE ###

N=int(input())
#number of cakes
if all( (N - 4*i) % 7 != 0 for i in range(N//4 + 1)):
    print("No")
else:
    print("Yes")
N, K = map(int,input().split())

from operator import mul
from functools import reduce

def combinations_count(n,r):
    r = min(n-r,r)
    if r == 0: return 1
    over = reduce(mul, range(n, n - r, -1))
    under = reduce(mul, range(1,r + 1))
    return over // under

div = K - 1  
for i in range(1, K+1):
  split_ball = combinations_count(div, i-1)
  red_ball = N-K-i+1
  if i-1==N-K:
    red_balls = 1
  else:
    red_balls = combinations_count(red_ball+i, i)
  print((split_ball * red_balls) % (10**9 + 7))

### FIXED CODE ###

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

from operator import mul
from functools import reduce

def combinations_count(n,r):
    r = min(n-r,r)
    if r == 0: return 1
    over = reduce(mul, range(n, n - r, -1))
    under = reduce(mul, range(1,r + 1))
    return over // under

div = K - 1  
for i in range(1, K+1):
  split_ball = combinations_count(div, i-1)
  red_ball = N-K-i+1
  if red_ball<0:
    red_balls = 0
  else:
    red_balls = combinations_count(red_ball+i, i)
  print((split_ball * red_balls) % (10**9 + 7))
##C
n=input().int
a=list(int(input()) for i in range(n))
b=sorted(a,reverse=True)

for i in range(n):
    if a[i]==b[-1]:
        print(b[-2])
    else:
        print(b[-1])

### FIXED CODE ###

##C
n=int(input())
a=list(int(input()) for i in range(n))
b=sorted(a)

for i in range(n):
    if a[i]==b[-1]:
        print(b[-2])
    else:
        print(b[-1])
S = input()
ans = 0

N = len(S)
Slist = []

for i in range(N):
    Slist.append(S[i])

def f(A, ans):
    n = len(A)
    if n == 0 or n == 1:
        print(ans)
        return 0
        
    for j in range(n-1):
        if A[j] == '0' and A[j+1] == '1':
            del A[j:j+2]
            ans += 2
            break
        elif A[j] == '1' and A[j+1] == '0':
            del A[j:j+2]
            ans += 2
            break
        if j == n-2:
            print(ans)
            return 0 
    f(A, ans)

f(Slist, ans)

        

### FIXED CODE ###

S = input()


N = len(S)

count_0 = 0
count_1 = 0

for i in range(N):
    if S[i] == '0':
        count_0 += 1
    else:
        count_1 += 1

if count_0 > count_1:
    print(int(count_1*2))

else:
    print(int(count_0*2))
import sys
input = sys.stdin.readline

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


s = []
t = []


for i in range(n):
    #print(k + a[i])
    if len(s) > k:
        break
    elif len(s) < k < len(s) + a[i]:
        s += [i] * (k + 1 - len(s))
    else:
        s += [i] * a[i]

if len(s) <k:
    s += [n] * (k + 1 - len(s))

for i in range(m):
    if len(t) > k:
        break
    elif len(t) < k < len(t) + b[i]:
        t += [i] * (k + 1 - len(t))
    else:
        t += [i] * b[i]

if len(t) <k:
    t += [m] * (k + 1 - len(t))

m = 0

# print(s)
# print(t)

#print(s[-1], t[-1])

if len(s) + len(t) - 2 <= k:
    m = s[-1] + t[-1]
else:
    for i in range(k+1):
        m = max(m, s[i] + t[k-i])

print(m)

### FIXED CODE ###

import sys
input = sys.stdin.readline

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


#Aだけのときのmax

s = 0
j = 0
for i in range(n):
    if s + a[i] > k:
        break
    else:
        s += a[i]
        j += 1


ans = [j]

for l in range(m):
    flag = True
    s += b[l]
    while s > k:
        s -= a[j-1]
        j -= 1
        if j < 0:
            flag = False
            break
    
    if not flag:
        break
    else:
        ans.append(l + 1 + j)
        #print(ans)

print(max(ans))
s = input().split()
nums = []
[[nums.append(num) for num in row.split(" ")] for row in s[:9]]
n = int(s[9])
bs = s[10:]
mat = [num in bs for num in nums]
patterns = [[0, 1, 2],
            [0, 4, 8],
            [0, 3, 6],
            [1, 4, 7],
            [2, 4, 6],
            [2, 5, 8],
            [3, 4, 5],
            [6, 7, 8]]
for pat in patterns:
    if mat[pat[0]] and mat[pat[1]] and mat[pat[2]]:
        print("Yes")


### FIXED CODE ###

import sys
input = sys.stdin.readlines()
nums = []
[[nums.append(num) for num in row.strip().split(" ")] for row in input[:3]]
bs = [i.strip() for i in input[4:]]
mat = [num in bs for num in nums]
patterns = [[0, 1, 2],
            [0, 4, 8],
            [0, 3, 6],
            [1, 4, 7],
            [2, 4, 6],
            [2, 5, 8],
            [3, 4, 5],
            [6, 7, 8]]
for pat in patterns:
    if mat[pat[0]] and mat[pat[1]] and mat[pat[2]]:
        print("Yes")
        sys.exit()
print("No")
N = int(input())
Inputs = [tuple(map(int, input().split())) for _ in range(N)]
H = 0
f = 0
for cx in range(101):
    for cy in range(101):
        n = 0
        while(n < N-1):
            x1, y1, h1 = Inputs[n]
            if h1 == 0:
                continue
            H1 = h1 + abs(x1-cx) + abs(y1-cy)
            x2, y2, h2 = Inputs[n+1]
            H2 = h2 + abs(x2-cx) + abs(y2-cy)
            if H1 != H2:
                f = 0
                break
            else:
                f = 1
                n += 1
        if f:
            print('aaaa')
            Cx = cx
            Cy = cy
            H = H1
            
                
print(Cx, Cy, H)

### FIXED CODE ###

N = int(input())
coordinate = []
ans = -1
for _ in range(N):
    x, y, h = map(int, input().split())
    if h == 0:
        continue
    coordinate.append([x, y, h])
N = len(coordinate)
for cx in range(101):
    for cy in range(101):
        x1, y1, h1 = coordinate[0]
        H1 = h1 + abs(cx-x1) + abs(cy-y1)
        f = 1
        if N == 1:
            f = 2
            Cx = x1
            Cy = y1
            ans = h1
            break
        for n in range(1, N):
            x, y, h = coordinate[n]
            H = h + abs(cx-x) + abs(cy-y)
            if H == H1:
                f *= 1
            else:
                f *= 0
            if f and n == N-1:
                break
        if f == 1:
            Cx = cx
            Cy = cy
            ans = H1
            break
    if f:
        break
        
print(Cx, Cy, ans)
import math

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

def lcm(x, y):
  return x * y // math.gcd(x, y)

l = 1
for a in A:
  l = lcm(a, l)
B = [(l - 1) % a for a in A]
print(sum(B))

### FIXED CODE ###

import fractions

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

def lcm(x, y):
  return x * y // fractions.gcd(x, y)

l = 1
for a in A:
  l = lcm(a, l)
B = [(l - 1) % a for a in A]
print(sum(B))
a = int(input())
s = int(input())

if a >= 3200:
    print(s)
else:
    print("red")
        

### FIXED CODE ###

a = int(input())
s = str(input())

if a >= 3200:
    print(s)
else:
    print("red")
import fractions

def lcm(lst):
    if len(lst) == 2:
        return (lst[0] * lst[1]) // fractions.gcd(lst[0], lst[1])
    l = lcm(lst[1:])
    return (lst[0] * l) // fractions.gcd(lst[0], l)

n = int(input())
inputs = list(map(int, input().split(' ')))
x = lcm(inputs) - 1
s = 0
for i in inputs:
    s += x % i
print(s)


### FIXED CODE ###

import fractions

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

n = int(input())
inputs = list(map(int, input().split(' ')))
for i in range(len(inputs)):
    if i == 0:
        x = lcm(inputs[0], inputs[1])
        continue
    if i == 1:
        continue
    x = lcm(x, inputs[i])
x -= 1
s = 0
for i in inputs:
    s += x % i
print(s)
n=int(input())
s=input()
c=[]
cnt=1
for i in range(n-1):
    if s[i] = s[i+1]:
        cnt += 1
    else:
        c+=cnt
        cnt=1
if s[n-2]==s[n-1]:
    c+=cnt
else:
    c+=1
print(min(c))

### FIXED CODE ###

n=int(input())
s=input()
c=s[1:].count('E')
a=c
for i in range(1,n):
    if s[i-1]=='W':
        c+=1
    if s[i]=='E':
        c-=1
    a=min(a,c)
print(a)
N = int(input())
a = map(int, input().split())

a.sort(reverse=True)

print(sum(a[::2])-sum(a[1::2]))

### FIXED CODE ###

N = int(input())
a = list(map(int, input().split()))
 
a.sort(reverse=True)
 
print(sum(a[::2])-sum(a[1::2]))
x = int(input())
n = 10*10

def blp(dp,num):
    l = 0
    r = len(dp)-1
    while r-l>=0:
        mid = (l+r)//2
        if num == dp[mid]:
            return mid
        elif num >= dp[mid]:
            l = mid+1
        else:
            r = mid-1
    return 0

def bln(dp,num):
    l = 0
    r = len(dp)-1
    while l-r>=0:
        mid = (l+r)//2
        if num == dp[mid]:
            return mid
        elif num >= dp[mid]:
            r = mid+1
        else:
            l = mid-1
    return 0
            
ap = [i**5 for i in range(n)]
an = [-(i**5) for i in range(n)]

for b in range(-n,n):
    num = x + b**5
    a = max(blp(ap,num),bln(an,num))
    if a:
        print(a,b)
        sys.exit()

### FIXED CODE ###

x = int(input())
n = 100000
 
def binp(arr, val):
    left,right = 0,len(arr)-1
    while left <= right:
        mid = (left+right)//2
        if val==arr[mid]: return mid
        elif val>=arr[mid]: left = mid+1
        else: right = mid-1
    return 0
 
def binn(arr, val):
    left,right = 0,len(arr)-1
    while left >= right:
        mid = (left+right)//2
        if val==arr[mid]: return mid
        elif val>=arr[mid]: right = mid+1
        else: left = mid-1
    return 0
 
ap = [i**5 for i in range(n)]
an = [-(i**5) for i in range(n)]
 
for b in range(-n,n):
    val = x + b**5
    a = max(binp(ap, val), binn(an,val))
    if a: print(a,b) ; break
import sys 
import math
try:
	sys.stdin = open('input.txt', 'r') 
	sys.stdout = open('output.txt', 'w')
except:
	pass
input = sys.stdin.readline
for tt in range(1):
	a,b,c,d = map(int,input().split())
	elif math.ceil(c/b) - math.ceil(a/d)<= 0:
		print ("Yes")
	else:
		print("No")
	

### FIXED CODE ###

import sys 
import math
try:
	sys.stdin = open('input.txt', 'r') 
	sys.stdout = open('output.txt', 'w')
except:
	pass
input = sys.stdin.readline
for tt in range(1):
	a,b,c,d = map(int,input().split())
	if math.ceil(c/b) - math.ceil(a/d)<= 0:
		print ("Yes")
	else:
		print("No")
s = input()

cnt = 0
for c in s:
	if c == "1":
		cnt += 1
print(cmt)

### FIXED CODE ###

s = input()

cnt = 0
for c in s:
	if c == "1":
		cnt += 1
print(cnt)
S=input()
l=len(S)
num=0
for i in range(l):
  if S[i]=="A" or S[i]=="G" or S[i]=="C" or S[i]=="T":
    num+=1
  elif num>ans:
    ans=num
    num=0
  else:
    num=0
print(ans)

### FIXED CODE ###

S = input()

ans = 0
tmp = 0
flag = False

for i in S:
    if (i == "A") or (i == "C") or (i == "G") or (i == "T"):
        tmp += 1
        flag = True
    elif (tmp > ans) and flag:
        ans = tmp
        tmp = 0
        flag = False
    elif flag:
        tmp = 0
        flag = False

if (ans < tmp):
    ans = tmp

print(ans)
n = int(input())
a_list = list(map(int, input().split()))
b_list = list(map(int, input().split()))
c_list = list(map(int, input().split()))

score = 0

for val in b_list :
	score +=val
	
for val in range(n-1):
	if a_list[val+1] - a_list[val] == 1:
		score += c_list[a_list[val-1]]
	else:
		pass

print(score)

### FIXED CODE ###

n = int(input())
a_list = list(map(int, input().split()))
b_list = list(map(int, input().split()))
c_list = list(map(int, input().split()))

score = 0

for val in b_list :
	score +=val
	
for val in range(n-1):
	if a_list[val+1] - a_list[val] == 1:
		score += c_list[a_list[val]-1]
	else:
		pass

print(score)
n=int(input())
a=[[int(i) for i in input().split()] for i in range(n)]
x_dis=[0]*(n-1)
y_dis=[0]*(n-1)

for i in range(n-1):
    x_dis[i]=a[i+1][0]-a[i][0]
    y_dis[i]=a[i+1][1]-a[i][1]

import collections

cx=collections.Counter(x_dis).most_common()[0]
cy=collections.Counter(y_dis).most_common()[0]

print(n-min(cx[1],cy[1]))

### FIXED CODE ###

n=int(input())
if n==1:
    print(1)
    exit()
    
x=[0]*n
y=[0]*n

for i in range(n):
    x[i],y[i]=map(int,input().split())
dis=[]
for i in range(n):
    for j in range(n):
        if i==j:
            continue
        dis.append((x[j]-x[i],y[j]-y[i]))
        
from collections import Counter
c=Counter(dis).most_common()[0]
print(n-c[1])
import sys
sys.setrecursionlimit(10**7)
N = int(input())
ts = [int(input()) for _ in range(N)]

def gcd(a,b):
    if b == 0:
        return a
    return gcd(b,a%b)

def lcm(a,b):
    g = gcd(a,b)
    return int(a/g*b)

l = 1
for t in ts:
    l = lcm(l,t)
    
print(l)

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**7)
N = int(input())
ts = [int(input()) for _ in range(N)]

def gcd(a,b):
    if b == 0:
        return a
    return gcd(b,a%b)

def lcm(a,b):
    g = gcd(a,b)
    return a * b // g

l = 1
for t in ts:
    l = lcm(l,t)
    
print(l)