Harryxun/stf_run huggingface dataset:
n,k = map(int,input().split())
arrh = list(map(int,input().split())
count = 0
for i in arrh:
            if i >= k:
            	count += 1
print(count)

### FIXED CODE ###

n,k = map(int,input().split())
arrh = list(map(int,input().split()))
count = 0
for i in arrh:
    if i >= k:
        count += 1
print(count)
import math

a,b = map(int, input().split())
print(math.fsum([b] * a))

### FIXED CODE ###

import math
from decimal import *

sa, sb = input().split()
a = Decimal(sa)
b = Decimal(sb)
lb = Decimal(b * Decimal(100))

ans = Decimal(Decimal(a * lb) // Decimal(100))
print(int(ans))
a,b=map(int,input().split(''))
print(a*b 2*a+2*b)

### FIXED CODE ###

a,b=map(int,input().split())
print(a*b,(a+b)*2)
a,b=map(int,input().split())
if (a+b )%2==1:
  print(int((a+b+1)/2)
else:
  print(int((a+b)/2)

### FIXED CODE ###

a,b=map(int,input().split())
if (a+b )%2==1:
  print(int((a+b+1)/2))
else:
  print(int((a+b)/2))
import fractions

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

b=[]
for i in a:
    b.append(abs(x-i))

if n==1:
    print(abs(x-a[0]))

else:
    ans=fractions.gcd(b[0],b[1])

    for i in range(2,n):
        ans = math.gcd(ans ,b[i])

    print(ans)

### FIXED CODE ###

import fractions

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

b=[]
for i in a:
    b.append(abs(x-i))

if n==1:
    print(abs(x-a[0]))

else:
    ans=fractions.gcd(b[0],b[1])

    for i in range(2,n):
        ans = fractions.gcd(ans ,b[i])

    print(ans)
import sys, re
input = sys.stdin.readline

n = int(input())
a = [int(input()) for x in range(n)]

temp_list = sorted(a)
m = temp_list[n-1]


for x in temp_list[::-1]:
  if x == m:
    continue
  else:
    m_dash = x
    break

for a_i in a:
  if a_i == m:
    print(m_dash)
  else:
    print(m)

### FIXED CODE ###

import sys, re
input = sys.stdin.readline

n = int(input())
a = [int(input()) for x in range(n)]

# a をソートして、一番大きい要素を取り出す
temp_list = sorted(a)
m = temp_list[::-1][0]


# 最も大きな数が複数あった場合
if temp_list[::-1][1] == m:
    m_dash = m
else:
    m_dash =temp_list[::-1][1]

for a_i in a:
  if a_i == m:
    print(m_dash)
  else:
    print(m)
d = input()
a, b, c = map(d.split())

if (a < b) and (b < c):
    print("Yes")
else:
    print("No")


### FIXED CODE ###

d = input()
a, b, c = map(int, d.split())
if (a<b) and (b<c):
    print("Yes")
else:
    print("No")
# Hello World program in Python
from collections import Counter as cn

d = int (input())
l = []
for k in range(d):
  r = input()
  p = cn(r)
  l.append(p)

oi = l[0]

for g in range(1,n):
    oi = oi & l[g]
    print(oi)
    
print("".join(sorted(oi.elements())))



### FIXED CODE ###

from collections import Counter
 
n = int(input())
l = []
 
for i in range(n):
    s = input()
    l.append(Counter(s))
    
cnt = l[0]
for i in range(1,n):
        cnt = cnt & l[i]
        
print("".join(sorted(cnt.elements())))
D = input('距離')
T = input('時間')
S = input('速度')
if D/S < T:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

D,T,S = map(int,input().split())

if D/S <= T:
    print('Yes')
else:
  	print('No')
import operator
import functools

import math


A, B = input().split()

A = int(A)
B = int(B)

"""

value = []

count = 0

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

primeA = prime_factorize(A)

primeB = prime_factorize(B)

if len(primeA) < len(primeB):
    for i in range(len(primeA)):
        for j in range(len(primeB)):
            if primeA[i] == primeB[j]:
                value.append(primeA[i])
                primeA[i] = 1
                primeB[j] = 1
                print(primeA)
                print(primeB)
                break
            else:
                continue

else:
    for i in range(len(primeB)):
        for j in range(len(primeA)):
            if primeB[i] == primeA[j]:
                value.append(primeB[i])
                primeA[j] = 1
                primeB[i] = 1
                print(primeA)
                print(primeB)
                break
            else:
                continue

value = value + primeA + primeB

result = functools.reduce(operator.mul, value)

print(result)
"""

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

print(lcm(A, B))

### FIXED CODE ###

import operator
import functools

A, B = input().split()

A = int(A)
B = int(B)

value = []

count = 0

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

primeA = prime_factorize(A)

primeB = prime_factorize(B)


for i in range(len(primeA)):
    for j in range(len(primeB)):
        if primeA[i] == primeB[j]:
            value.append(primeA[i])
            primeA[i] = 1
            primeB[j] = 1
            break
        else:
            continue

value = value + primeA + primeB

result = functools.reduce(operator.mul, value)

print(result)
n=int(input())
m=sum(list(map(int,str(n)))
if n%m==0:
      print('Yes')
      exit()
print("No")

### FIXED CODE ###

n=int(input())
m=list(str(n))
s=0
for i in range(len(m)):
  s+=int(m[i])
if n%s==0:
      print('Yes')
      exit()
print("No")
n=int(input())
A=[int(i) for i in input().split()]

A.sort()
A.append(-1)

dat={i:False for i in range(2*10**5+1)}

ans=0
for i in range(len(A)-1):
    if dat[A[i]]:
        pass
    else:
        if A[i]!=A[i+1]:
            ans+=1
        for i in range(A[i],2*10**5+1,A[i]):
            dat[i]=True

print(ans)

### FIXED CODE ###

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

A.sort()
A.append(-1)

dat={i:False for i in range(10**6+10)}

ans=0
for i in range(len(A)-1):
    if dat[A[i]]:
        pass
    else:
        if A[i]!=A[i+1]:
            ans+=1
        for i in range(A[i],10**6+10,A[i]):
            dat[i]=True

print(ans)
from itertools import *

[N, K] = map(int, input().split())
[a1, b1] = map(int, input().split())
print([a1, b1])
Es = [a1, b1]
for _ in range(1, N-1):
    [a, b] = map(int, input().split())
    Es.append(a)
    Es.append(b)

res = K * (K-1)
res %= 1000000007
for i in range(0, N):
    j = i + 1
    c = Es.count(j)
    if c > K-1:
        res = 0
        break
    res *= len(list(permutations(range(K-2), (c-1))))
    res %= 1000000007

print(res)


### FIXED CODE ###

from itertools import groupby

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

num_of_perms = [1] * (K-1)
for i in range(1, K-1):
    num_of_perms[i] = num_of_perms[i-1] * ((K - 2) - i + 1) % 1000000007

Es = []
for _ in range(0, N-1):
    [a, b] = input().split()
    Es.append(int(a))
    Es.append(int(b))

if N == 1:
    res = K
else:
    res = K * (K-1)
    res %= 1000000007
    for g in groupby(sorted(Es)):
        c = len(list(g[1]))
        if c > K-1:
            res = 0
            break
        res *= num_of_perms[c-1]
        res %= 1000000007

print(res)
a,b=map(input().split())
A=chr(a)
B=chr(b)
if A>B:
  print(">")
elif A<B:
  print("<")
else:
  print("=")


### FIXED CODE ###

S=input()
A=ord(S[0])
B=ord(S[2])

if A>B:
  print(">")
elif A<B:
  print("<")
else:
  print("=")
import sys
input = sys.stdin.readline
n = int(input())
a = []
for i in range(n):
  a.append(int(input()))
a_max = max(a)
b = a
b.remove(max(b))
b_max = max(b)
for j in range(n):
  if a[j] == a_max:
    print(b_max)
  else:
    print(a_max)

### FIXED CODE ###

import sys
input = sys.stdin.readline
n = int(input())
a = []
for i in range(n):
  a.append(int(input()))
a_max = max(a)
b_max = sorted(a)[-2]
for j in range(n):
  if a[j] == a_max:
    print(b_max)
  else:
    print(a_max)
str = input()

count = 0
if str[0] == "1":
  count+=1
if str[1] == "1":
  count+=1
if str[2] == "1":
  count+=1

printt(count)

### FIXED CODE ###

str = input()
 
count = 0
if str[0] == "1":
  count+=1
if str[1] == "1":
  count+=1
if str[2] == "1":
  count+=1
 
print(count)
a = [list(map(int, input().split())) for _ in range(3)]
N = int(input())
b = [int(input()) for _ in range(10)]

c = [[0 for _ in range(3)] for _ in range(3)]
result = ""

for i in range(3):
    for j in range(3):
        if a[j][i] in b:
            c[j][i] = 1

for i in range(3):
    if c[i][0] == c[i][1] == c[i][2] == 1:
        result = "Yes"
        break
    elif c[0][i] == c[1][i] == c[2][i] == 1:
        result = "Yes"
        break

if c[0][0] == c[1][1] == c[2][2] == 1:
    result = "Yes"
elif c[0][2] == c[1][1] == c[2][0] == 1:
    result = "Yes"

if result == "":
    result ="No"

print(result)


### FIXED CODE ###

a = [list(map(int, input().split())) for _ in range(3)]
N = int(input())
b = [int(input()) for _ in range(N)]

c = [[0 for _ in range(3)] for _ in range(3)]
result = ""

for i in range(3):
    for j in range(3):
        if a[j][i] in b:
            c[j][i] = 1

for i in range(3):
    if c[i][0] == c[i][1] == c[i][2] == 1:
        result = "Yes"
        break
    elif c[0][i] == c[1][i] == c[2][i] == 1:
        result = "Yes"
        break

if c[0][0] == c[1][1] == c[2][2] == 1:
    result = "Yes"
elif c[0][2] == c[1][1] == c[2][0] == 1:
    result = "Yes"

if result == "":
    result ="No"

print(result)
n = int(input())
li = list(map(int,input().split()))
ans = 0

def gcd(a,b):
    while b:
        a,b = b,a%b
    return a

def gcd_list2(li):
    a = gcd(li[0],li[1])
    for i in range(n-1):
        a = gcd(a,li[i])
    return a

for i in range(n):
    li2 = li[:i] + li[i+1:]
    a = gcd_list2(li2)
    if a > ans:
        ans = a

print(ans)


### FIXED CODE ###

n = int(input())
li = list(map(int,input().split()))
ans = 0
lgcd = [0]*n
rgcd = [0]*n
lgcd[0] = li[0]
rgcd[-1] = li[-1]

def gcd(a,b):
    while b:
        a,b = b,a%b
    return a

for i in range(n-1):
    lgcd[i+1] = gcd(lgcd[i],li[i+1])
    rgcd[-i-2] = gcd(rgcd[-i-1],li[-(i+2)])

gcd_list = [gcd(lgcd[i],rgcd[i+2]) for i in range(n-2)]

gcd_list.append(lgcd[-2])
gcd_list.append(rgcd[1])

print(max(gcd_list))
import statistics
import marh
a, b = map(int,input().split())
if ((a + b) //2 ) %2 == 0:
    print((a+b)//2)
else:
    print((a+b)//2 +1)

### FIXED CODE ###

a, b = map(int,input().split())
if ((a + b) /2 ) == ((a+b)//2) :
    print((a+b)//2)
else:
    print((a+b)//2 +1)
print((int(input())+int(input()))*int(input()//2)

### FIXED CODE ###

print((int(input())+int(input()))*int(input())//2)
while True:
	li= list(map(int, input().split())
	li.sort()
	if li =[0,0]
		break
	print(*li)


### FIXED CODE ###

while True:
	x,y=sorted(map(int,input().split()))
	if x==0 and y==0:
		break
	print(x, y)
from numba import jit
@jit
n,k=map(int,input().split())
h=list(map(int,input().split()))
cost=[0]
for i in range(1,n):
  wk=[]
  for j in range(1,min(k,i)+1):
    wk.append(cost[i-j]+abs(h[i]-h[i-j]))
  cost.append(min(wk))
print(cost[n-1])

### FIXED CODE ###

n=int(input())
h=list(map(int,input().split()))
cost=[0,abs(h[1]-h[0])]
for i in range(2,n):
  cost.append(min(cost[i-2]+abs(h[i]-h[i-2]),cost[i-1]+abs(h[i]-h[i-1])))
print(cost[n-1])
N,M = map(int,input().split())
A = list(map(int,input()split()))
B = list(map(int,input()split()))
a = [0 for i in range(N*M+1)]
b = [0 for i in range(N*M+1)]
mod = 10**9+7
for i in range(N):
    a[A[i]] += 1
for i in range(M):
    b[B[i]] += 1
for i in range(1,N*M+1):
    a[-i-1] += a[-i]
    b[-i-1] += a[-i]
ans = 1
for i in range(N*M):
    f = 0
    g = 0
    x = N*M - i
    y = i
    if x in A:
        f += 1
    if x in B:
        g += 1
    z = 1
    if f == 0:
        z *= b[x]
    if g == 0:
        z *= a[x]
    z -= i
    if z <= 0:
        print(0)
        quit()
    else:
        ans *= z%mod
print(ans%mod)
    

### FIXED CODE ###

N,M = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
a = [0 for i in range(N*M+1)]
b = [0 for i in range(N*M+1)]
da = [0 for i in range(N*M+1)]
db = [0 for i in range(N*M+1)]
mod = 10**9+7
for i in range(N):
    a[A[i]] += 1
    if da[A[i]] == 1:
        print(0)
        quit()
    da[A[i]] += 1
for i in range(M):
    b[B[i]] += 1
    if db[B[i]] == 1:
        print(0)
        quit()
    db[B[i]] += 1
for i in range(1,N*M+1):
    a[-i-1] += a[-i]
    b[-i-1] += b[-i]
ans = 1
for i in range(N*M):
    f = 0
    g = 0
    x = N*M - i
    y = i
    if da[x] == 1:
        f = 1
    if db[x] == 1:
        g = 1
    z = 1
    if f == 0:
        z = z*a[x]%mod
    if g == 0:
        z = z*b[x]%mod
    if f+g == 0:
        z -= i
    if z <= 0:
        print(0)
        quit()
    else:
        ans = ans*z%mod
print(ans%mod)
a, b, c= map(int, input().split())
kawaiso = 0 
if a==b && a!=c:
    kawaiso = 1

else if b==c && b!=a :
    kawaiso = 1

else if c==a && c!=b :
    kawaiso = 1
else :
    kawaiso = 0

if kawaiso == 1 :
    print ('yes')

else :
    print('No')


### FIXED CODE ###

a, b, c= map(int, input().split())
kawaiso = 0 
if a==b and a!=c:
    kawaiso = 1
 
elif  b==c and b!=a:
    kawaiso = 1
 
elif c==a and c!=b:
    kawaiso = 1
    
else:
    kawaiso = 0
  
 
if kawaiso == 1:
    print ("Yes")
    
else:
    print("No")
M, D = map(int, input().split())
m_list = {m for m in range(1, M + 1)}
ans = 0

for d in range(11, D+1):
  d_10 = int(d/10)
  d_1 = d - (d_10 * 10)
  if (d_10 < 2) or (d_1 < 2):
    continue
  elif:
    if (d_10 * d_1) in m_list:
      ans += 1
      
print(ans)
      

### FIXED CODE ###

M, D = map(int, input().split())
m_list = {m for m in range(1, M + 1)}
ans = 0
 
for d in range(11, D+1):
  d_10 = int(d/10)
  d_1 = d - (d_10 * 10)
  if (d_10 < 2) or (d_1 < 2):
    continue
  else:
    if (d_10 * d_1) in m_list:
      ans += 1
      
print(ans)
n = input()
w = list(map(int, input().split()))
w = np.array(w)
print(np.min(np.abs(2 * np.cumsum(w) -np.sum(w))))

### FIXED CODE ###

import numpy as np
n = input()
w = list(map(int, input().split()))
w = np.array(w)
print(np.min(np.abs(2 * np.cumsum(w) -np.sum(w))))
import numpy as np

def resolve():
    x, n = map(int, input().split())
    if n == 0:
        print(x)
        return
    P = set(map(int, input().split()))

    P_not = np.array(list(set(list(range(1, 101))) - P))
    diff = np.abs(P_not - x)
    print(P_not[diff.argmin()])

resolve()

### FIXED CODE ###

import numpy as np

def resolve():
    x, n = map(int, input().split())
    if n == 0:
        print(x)
        return
    P = set(map(int, input().split()))
    if x not in P:
        print(x)
        return

    P_not = np.array(list(set(list(range(-1, 102))) - P))
    diff = np.abs(P_not - x)
    print(P_not[diff.argmin()])

resolve()
N = int(input())
lis = [(input() + " " + str(i+1)).split() for i in range(N)]

lis = [k for k in lis]

lis.sort(key=lambda k: int(k[1]), reverse=True)
lis.sort(key=lambda k: k[0])


for j in lis:
    print(j[2])
N = int(input())
lis = [(input() + " " + str(i+1)).split() for i in range(N)]

lis = [k for k in lis]

lis.sort(key=lambda k: int(k[1]), reverse=True)
lis.sort(key=lambda k: k[0])


for j in lis:
    print(j[2])


### FIXED CODE ###

N = int(input())
lis = [(input() + " " + str(i+1)).split() for i in range(N)]

lis = [k for k in lis]

lis.sort(key=lambda k: int(k[1]), reverse=True)
lis.sort(key=lambda k: k[0])


for j in lis:
    print(j[2])
import re

s = str(raw_input)
s = re.sub('2018', '2017', s, 1)
print(s)

### FIXED CODE ###

s = str(raw_input())
s = s.replace('2017', '2018', 1)
print(s)
A,B,N = map(int,input().split())
#N=int(input())
#A = list(map(int,input().split()))
#S=str(input())
m=0
if B<N:
    N=B
s=int(B/A)
if s>N:
    print(0)
    exit()
for x in range(s,N+1,s):
    num=int(A*x/B) - A * int(x/B)

    m=max(num,m)

print(m)


### FIXED CODE ###

import itertools
#K = int(input())
N,M,Q = map(int,input().split())
#N = str(input())
#A = list(map(int,input().split()))
nums=[i for i in range(1,M+1)]
count=0
inp=[]
for i in range(Q):
    I=list(map(int,input().split()))
    inp.append(I)

for v in itertools.combinations_with_replacement(nums, N):
    c=0
    v=list(v)
    for i in inp:

        if v[i[1]-1] - v[i[0]-1]==i[2]:
            c+=i[3]
    count=max(count,c)
print(count)
import fractions
from functools import reduce
import math
def lcm_base(x, y):
    return (x * y) // fractions.gcd(x, y)
def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

N,M = map(int,input().split())
List=list(map(int,input().split()))
aa = int(lcm_list(List)/2)
cnt = 0
a=List[0]
while a%2 == 0:
  cnt+=1
  a = int(a/2)
out = 0
if cnt == 0:
  out = 1
  cnt = 1
for i in range(len(List)):
  if List[i] % (2**cnt) == 1:
    out = 1
  elif List[i] % (2**(cnt+1)) == 0:
    out = 1

if out == 1:
  print(0)
else:
  print(int(math.ceil((M / aa)) // 2))

### FIXED CODE ###

N, M = map(int, input().split())
A = list(set(map(lambda x : int(x)//2, input().split())))
def gcd(x, y):
  return x if y == 0 else gcd(y, x % y)
def lcm(x, y):
  return (x * y) // gcd(x, y)
l = A[0]
for a in A[1:]:
  l = lcm(l, a)
ans = (M // l + 1) // 2
for a in A[1:]:
  if (l // a) % 2 == 0:
    ans = 0
    break
print(ans)
from collections import deque


def main():
    vertex = int(input())
    tree = [[] for _ in range(vertex + 1)]
    color = [0] * (vertex + 1)
    for i in range(1, vertex):
        a, b = map(int, input().split())
        tree[a].append((b, i))
        tree[b].append((a, i))
    max_deg = 0
    root = 0
    for i in range(1, vertex):
        if max_deg < len(tree[i]):
            root = i
            max_deg = len(tree[i])
    queue = deque([root])
    while not queue == deque():
        color_list = [i for i in range(1, max_deg + 1)]
        now = queue.pop()
        for i, n in enumerate(tree[now]):
            if color[n[0]] == 0:
                color[n[0]] = color_list[0]
                queue.append(n[1])
                color_list.pop(0)
            else:
                color_list.remove(color[n[0]])
    print(max_deg)
    for c in color[2:]:
        print(c)


if __name__ == '__main__':
    main()



### FIXED CODE ###

from collections import deque


def main():
    vertex = int(input())
    tree = [[] for _ in range(vertex + 1)]
    color = [0] * (vertex + 1)
    parent = [0] * (vertex + 1)
    order = []
    ab = []
    for i in range(vertex - 1):
        a, b = map(int, input().split())
        tree[a].append(b)
        tree[b].append(a)
        ab.append([a, b])
    queue = deque([1])

    # 木の親を決める
    while queue:
        now = queue.popleft()
        order.append(now)
        for t in tree[now]:
            if not t == parent[now]:
                parent[t] = now
                queue.append(t)

    # 色番号を割り当てる
    for ord in order:
        ng = color[ord]
        color_num = 1
        for t in tree[ord]:
            if not t == parent[ord]:
                if color_num == ng:
                    color_num += 1
                color[t] = color_num
                color_num += 1

    print(max(color))
    for a, b in ab:
        if a == parent[b]:
            print(color[b])
        else:
            print(color[a])


if __name__ == '__main__':
    main()
a = list(map(int, input().split()))

re = abs(a[0] - a[1])

for i in range(a[0] - a[1]):
  if abs(a[0] - i) == abs(a[1] - i):
    print(i)
    yes = 1
    break

if yes != 1:
  print('IMPOSSIBLE')

### FIXED CODE ###

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

b = a[0] + a[1]

if b % 2 == 0:
  print(b//2)
else:
  print('IMPOSSIBLE')
import math
from functools import reduce

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

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

def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

lcm_a = lcm(*a)
print(m // (lcm_a//2) - m // lcm_a)


### FIXED CODE ###

import fractions
from functools import reduce

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

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

def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

def count_factorize(n):
    counter = 0
    while n % 2 == 0:
        counter += 1
        n //= 2
    return counter

mod = count_factorize(a[0])
for i in range(1, n):
    if count_factorize(a[i]) != mod:
        print(0)
        exit()
lcm_a = lcm(*a)
print(m // (lcm_a//2) - m // lcm_a)
while 1:
m,f,r = map(int,input().split())
    if (m == -1 or f == -1) or m + f < 30:
        print("F")
    elif 80 <= m + f :
        print("A")
    elif 65 <= m + f < 80:
        print("B")
    elif 50 <= m + f < 65:
        print("C")
    elif 30 <= m + f < 50:
        if r >= 50:
            print("C")
        else:
            print("D")
    elif m == -1 and f == -1 and r == -1:
        break

### FIXED CODE ###

while 1:
    m,f,r = map(int,input().split())
    if m == -1 and f == -1 and r == -1:
        break

    if m == -1 or f == -1 or m + f < 30:
        print("F")
    elif 80 <= m + f :
        print("A")
    elif 65 <= m + f < 80:
        print("B")
    elif 50 <= m + f < 65:
        print("C")
    elif 30 <= m + f < 50:
        if r >= 50:
            print("C")
        else:
            print("D")
x1,y1,x2,y2=map(int,raw_input().split())
x=x2-x1
y=y2-y1
print (x**2+y**2)**0.5

### FIXED CODE ###

(n,m,o,p) = map(float, raw_input().split())
print ((n-o)**2 + (m-p)**2)**0.5
a = int,input()
b = a+(a**2)+a**3
print('b=',b)

### FIXED CODE ###

a = input()
b = int(a)
print(b+b**2+b**3)
s_input = string(input())

s_1 = s_input[0:1]
s_2 = s_input[1:2]
s_3 = s_input[2:3]

count = 0

s_list = [s_1, s_2, s_3]

for s in s_list:
	if s == "1":
		count = count + 1
	elif
    	None
      
print(count)

### FIXED CODE ###

s_input = str(input())
 
s_1 = s_input[0:1]
s_2 = s_input[1:2]
s_3 = s_input[2:3]
 
count = 0
 
s_list = [s_1, s_2, s_3]
 
for s in s_list:
    if s == "1":
        count = count + 1
    else:
        None
      
print(count)
n = int(input())
A = [input() for _ in range(n)]
out = 0
for k in range(n):
    a = A[k:][:] + A[:k][:]
    if ''.join(a) == ''.join(map(''.join, zip(*a))):
        out += n
print(out)

### FIXED CODE ###

from collections import Counter
n = int(input())
A = [int(i) for i in input().split()]
S = [0]*(n+1)
for i in range(n):
    S[i+1] = S[i] + A[i]
def hello(data):
    dt = Counter()
    for i in data:
        dt[str(i)] += 1
    return dt
num = hello(S)
out = [i*(i-1)//2 for i in num.values() if i>1]
print(sum(out))
A, B = map(int, input().split())

max_num = max(A, B)
target = list(range(2, max_num + 1))
primes = set()
while True:
    if len(target) == 0:
        break

    num = min(target)

    if num * num > max_num:
        break

    primes.add(num)

    i = 0
    while i < len(target):
        if target[i] % num == 0:
            target.pop(i)
            continue
        i += 1

count = 1
for prime in primes:
    if A % prime == 0 and B % prime == 0:
        count += 1
print(count)

### FIXED CODE ###

def prime_facorize(N):
    res = {1}
    for i in range(2, int(N ** 0.5) + 1):
        while N % i == 0:
            res.add(i)
            N /= i

        if N <= 1:
            break
    if N > 1:
        res.add(N)
    return res


A, B = map(int, input().split())
commons = prime_facorize(A) & prime_facorize(B)
print(len(commons))
if input() >= 30:
    print('Yes')
else:
    print('No')

### FIXED CODE ###

if int(input()) >= 30:
    print('Yes')
else:
    print('No')