Harryxun/sft_time huggingface dataset:
### BUGGY CODE ###

n,k=map(int,input().split())
l=list(map(int,input().split()))
pr=1
t=[]
for i in range(len(l)):
    if i<k:
        pr*=l[i]
    else:
        pr1=pr
        pr1*=l[i]
        pr1//=l[i-k]
        if pr<pr1:
            print("Yes")
        else:
            print("No")

### FIXED CODE ###

n,k=map(int,input().split())
l=list(map(int,input().split()))
pr=1
t=[]
for i in range(len(l)-k):
    if l[i]<l[i+k]:
        print("Yes")
    else:
        print("No")
### BUGGY CODE ###

n,m = map(int, input().split())
a_list = []
for i in range(m):
    a_list.append(int(input()))

memo = [-1 for _ in range(n)]

DIV_NUM = 1000000007
if 1 in a_list:
    memo[0] = 0
else:
    memo[0] = 1
for i in range(1, n):
    if i == 1:
        if i+1 in a_list:
            memo[i] = 0
        else:
            memo[i] = (memo[0] + 1) % DIV_NUM
    else:
        if i+1 in a_list:
            memo[i] = 0
        else:
            memo[i] = (memo[i-1] + memo[i-2]) % DIV_NUM

print(memo[-1])

### FIXED CODE ###

n,m = map(int, input().split())
a_list = []
for i in range(m):
    a_list.append(int(input()))

# memo = [-1 for _ in range(n)]
step_now = 0
step_1   = 0
step_2   = 0
DIV_NUM = 1000000007
if 1 in a_list:
    a_list.pop(0)
    step_now = 0
else:
    step_now = 1
for i in range(1, n):
    if i == 1:
        step_1 = step_now
        if i+1 in a_list:
            a_list.pop(0)
            step_now = 0
        else:
#             memo[i] = (memo[0] + 1) % DIV_NUM
            step_now = step_1 + 1
    else:
        step_2 = step_1
        step_1 = step_now
        if i+1 in a_list:
            a_list.pop(0)
            step_now = 0
        else:
#             memo[i] = (memo[i-1] + memo[i-2]) % DIV_NUM
            step_now = (step_1 + step_2) % DIV_NUM
    if step_now ==  step_1 == step_2 == 0:
        break

print(step_now)
### BUGGY CODE ###

# from collections import deque
N, M = map(int, input().split())

G = {k: [] for k in range(N+1)}
r = [True]*(N+1)
for _ in range(N+M-1):
    a, b = map(int, input().split())
    r[b] = False
    # 有向グラフ
    G[a].append(b)

for i in range(1, N+1):
    if r[i] is True:
        root = i


P = [-1]*(N+1)
P[root] = 0
dist = [-1]*(N+1)

que = [(root, 0, 0)]


while que:
    ci, pi, d = que.pop()
    if d > dist[ci]:
        P[ci] = pi
        dist[ci] = d

    for ni in G[ci]:
        if d+1 > dist[ni]:
            que.append((ni, ci, d+1))

print(*P[1:], sep='\n')


### FIXED CODE ###

from collections import deque, defaultdict

N, M = map(int, input().split())
ab = []
for _ in range(N + M - 1):
    ab.append(tuple(map(int, input().split())))

in_cnt = defaultdict(int)
rev = defaultdict(list)
outs = defaultdict(list)
for a, b in ab:
    in_cnt[b - 1] += 1
    outs[a - 1].append(b - 1)
    rev[b - 1].append(a - 1)

res = []
queue = deque([i for i in range(N) if in_cnt[i] == 0])
while queue:
    v = queue.popleft()
    res.append(v)
    for v2 in outs[v]:
        in_cnt[v2] -= 1
        if in_cnt[v2] == 0:
            queue.append(v2)

order = [i for i, v in sorted(enumerate(res), key=lambda x: x[1])]

ans = [0] * N
ans[res[0]] = 0
for v in res[:0:-1]:
    ans[v] = max([(order[v2], v2) for v2 in rev[v]])[1] + 1

for a in ans:
    print(a)
### BUGGY CODE ###

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


def zero(n,a,l):
    count = 0
    for i in range(l - n + 1):
        part = a[i:i +n]
        if sum(part) == 0:
            count = count + 1
    return count


count_1 = 0
for j in range(1, leng+1):
    count_1 = count_1 + zero(j,A,leng)

print(count_1)

### FIXED CODE ###

N = int(input())
A = [int(i) for i in input().split()]
ca = [A[0]] + [0]*(N-1)

for i in range(1,N):
    ca[i] = ca[i-1] + A[i]

count = 1
number = 0
number += ca.count(0)
sca = sorted(ca) + ['hoge']
for i in range(1,N+1):
    if sca[i] == sca[i-1]:
        count += 1
    else:
        number += count*(count - 1)/2
        count = 1


print(int(number))
### BUGGY CODE ###

import sys
input = sys.stdin.readline
N,M=map(int,input().split())
R=list(range(N))
L=list(map(int,input().split()))
for i in range(M):
  t,u=map(int,input().split())
  if L[t-1]<=L[u-1] and t-1 in R:
    R.remove(t-1)
  if L[t-1]>=L[u-1] and u-1 in R:
    R.remove(u-1)
print(len(R))

### FIXED CODE ###

import sys
sys.setrecursionlimit(10 ** 7)
def input() : return sys.stdin.readline().strip()
def INT()   : return int(input())
def MAP()   : return map(int,input().split())
def LIST()  : return list(MAP())
def NIJIGEN(H): return [list(input()) for i in range(H)]
N,M=MAP()
H=LIST()
L=[[0] for i in range(N)]
for i in range(M):
  a,b=MAP()
  a-=1
  b-=1
  L[a].append(H[b])
  L[b].append(H[a])
ans=0
for i in range(N):
  if max(L[i])<H[i]:
    ans+=1
print(ans)
### BUGGY CODE ###

N,M=map(int,input().split())
list=[0 for i in range(5*10**5+1)]
mod=10**9+7
list[0]=1
for i in range(len(list)-1):
  list[i+1]=list[i]*(i+1)%mod
def c(m,n):
  a=list[m]*pow(list[m-n],mod-2,mod)*pow(list[n],mod-2,mod)
  return a
def p(m,n):
  a=list[m]*pow(list[m-n],mod-2,mod)
  return a
ans=p(M,N)**2
for i in range(1,N+1):
  ans+=c(N,i)*(-1)**i*p(M,i)*p(M-i,N-i)**2%mod
  ans%=mod
print(ans)

### FIXED CODE ###

N,M=map(int,input().split())
list=[0 for i in range(5*10**5+1)]
mod=10**9+7
list[0]=1
for i in range(len(list)-1):
  list[i+1]=list[i]*(i+1)%mod
def c(m,n):
  a=list[m]*pow(list[m-n],mod-2,mod)*pow(list[n],mod-2,mod)
  return a
def p(m,n):
  a=list[m]*pow(list[m-n],mod-2,mod)
  return a
ans=pow(p(M,N),2)
g=pow(list[M-N],mod-2,mod)
g2=pow(g,2,mod)
nn=list[N]
mm=list[M]
nmg=nn*mm*g2%mod
for i in range(1,N+1):
  ans+=nmg*pow(list[N-i],mod-2,mod)*pow(list[i],mod-2,mod)*list[M-i]*(-1)**i
  ans%=mod
print(ans)
### BUGGY CODE ###

# t=int(input())
# for _ in range(t):
#     n=int(input())
#     arr=[int(x) for x in input().split()]
def sumall(n):
    sum=0
    while n:
        #print(n%10)
        sum+=n%10
        n=n//10
    #print(sum)
    return sum
    
n=int(input())
if sumall(n)%9 == 0:
    print("Yes")
else:
    print("No")
#print(t*need)

### FIXED CODE ###

# t=int(input())
# for _ in range(t):
#     n=int(input())
#     arr=[int(x) for x in input().split()]
n=int(input())
if n%9 == 0:
    print("Yes")
else:
    print("No")
### BUGGY CODE ###

# -*- coding: utf-8 -*-
from fractions import Fraction
def main():
    N,K = map(int,input().split())
    countlist = []
    answer = 0
    for i in range(N):
        count = 0
        while i <= K-1:
            i = i*2
            count +=1
        countlist.append(count)
    for j in countlist:
        answer += Fraction(1,N) * Fraction(1,2)**j
    print(answer)

if __name__ == '__main__':
    main()

### FIXED CODE ###

# -*- coding: utf-8 -*-
def main():
    N,K = map(int,input().split())
    ans = 0
    for i in range(1,N+1):
        tmp = i
        n = 0
        while tmp < K:tmp*=2;n+=1
        ans += ((1/N)*(1/2)**n)
    print(ans)

if __name__ == '__main__':
    main()
### BUGGY CODE ###

n=int(input())
a=list(map(int,input().split()))
mod=10**9+7
lcm=1
d=dict()
P = 10**9 + 7
N = 1000001 #使う最大値+1以上にする、値に注意3*10^5とかにしとくと安心
inv = [0] + [1] # 1/x
for i in range(2,N):
  inv += [inv[P % i] * (P - int(P / i)) % P]
for i in range(n):
  k=a[i]
  for j in range(1,int(a[i]**0.5)+1):
    cnt=0
    while k%(j+1)==0:
      k//=j+1
      cnt+=1
    if j+1 in d:
      if d[j+1]<cnt:
        lcm*=(j+1)**(cnt-d[j+1])%mod
        d[j+1]=cnt
    else:
      lcm*=(j+1)**cnt%mod
      d[j+1]=cnt
  if k in d:
    if d[k]<1:
      lcm*=k
      d[k]=1
  else:
    lcm*=k
    d[k]=1
ans=0
lcm%=mod
for i in range(n):
  ans+=lcm*inv[a[i]]%mod
print(ans%mod)

### FIXED CODE ###

from fractions import gcd
P = 10**9 + 7
N = 1000001 #使う最大値+1以上にする、値に注意3*10^5とかにしとくと安心
inv = [0] + [1] # 1/x
for i in range(2,N):
  inv += [inv[P % i] * (P - int(P / i)) % P]
n=int(input())
a=list(map(int,input().split()))
lcm=a[0]
mod=10**9+7
for i in range(1,n):
  lcm=(lcm//gcd(lcm,a[i]))*a[i]
ans=0
lcm%=mod
for i in range(n):
  ans=(ans+lcm*inv[a[i]])%mod
print(ans%mod)
### BUGGY CODE ###

def bisect_right_reverse(a, x):
    if a[0] < x:
        return 0
    if x <= a[-1]:
        return len(a)
    ok = len(a) - 1
    ng = 0
    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if a[mid] < x:
            ok = mid
        else:
            ng = mid
    return ok

#import bisect
X, Y, A, B, C = map(int, input().split())
red = [int(x) for x in input().split()]
gre = [int(x) for x in input().split()]
non = [int(x) for x in input().split()]
red.sort(reverse=True)
gre.sort(reverse=True)
non.sort()
ans = red[:X] + gre[:Y]
ans.sort(reverse=True)
times = len(non)
for i in range(times):
    c = non[-1]
    index = bisect_right_reverse(ans, c)
    ans.insert(index, c)
    non.pop(-1)
    ans.pop(-1)
print(sum(ans))

### FIXED CODE ###

X, Y, R, G, N = map(int, input().split())
r = [int(x) for x in input().split()]
g = [int(x) for x in input().split()]
n = [int(x) for x in input().split()]
r = sorted(r)[R-X:]
g = sorted(g)[G-Y:]
n = sorted(n, reverse=True)

nr = 0; ng = 0; nn = 0
for i in range(N):
    if n[nn] <= min(r[nr], g[ng]):
        break
    if r[nr] < g[ng]:
        r[nr] = n[nn]
        nr += 1
        if nr == X:
            nr = X-1
    else:
        g[ng] = n[nn]
        ng += 1
        if ng == Y:
            ng = Y-1
    nn += 1

print(sum(r) + sum(g))
### BUGGY CODE ###

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

nums = list(set(a))
for _ in range(n):
  ans = 0
  t = a.pop(0)
  for j in nums:
    s = a.count(j)
    ans += s*(s-1)//2
  print(ans)
  a.append(t)

### FIXED CODE ###

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

nums = [0]*(n+1)
for i in a:
  nums[i] += 1
  
t = 0
for j in nums:
  t += j*(j-1)//2

for k in a:
  print(t+1-nums[k])
### BUGGY CODE ###

n, x, m = [int(x) for x in input().split()]
A = [x]
while len(A) < n:
    a = (A[-1] * A[-1]) % m
    if a not in A:
        A.append(a)
    else:
        i = A.index(a)
        loop_len = len(A) - i
        print(sum(A[:i]) + sum(A[i:]) * ((n - i) // loop_len) + sum(A[i:i + ((n - i) % loop_len)]))
        break
else:
    print(sum(A))


### FIXED CODE ###

n, x, m = [int(x) for x in input().split()]
A = [x]
while len(A) < n:
    a = (A[-1] * A[-1]) % m
    if a not in A:
        A.append(a)
    else:
        i = A.index(a)
        loop_len = len(A) - i
        print(sum(A[:i]) + sum(A[i:]) * ((n - i) // loop_len) + sum(A[i:i + ((n - i) % loop_len)]))
        break
else:
    print(sum(A))
### BUGGY CODE ###

N, M = map(int, input().split())
a = list(map(int, input().split()))
a = list(set(a))
N = len(a)
for k in range(N):
  a[k] //= 2


count = 0
foo = 1

while a[0]%2 == 0:
  foo *= 2
  a[0] // 2
for k in range(1, N):
  if a[k] % foo == 0 and a[k]%(2*foo) !=0:
    a[k] //= foo
    continue
  else:
    print(0)
    exit()
ans = 0




import math
lcm = a[0]
for k in range(1, N):
  lcm = lcm * a[k] // math.gcd(lcm, a[k])
lcm *= foo
ans = int((M / lcm -1)//2 + 1)
print(ans)

### FIXED CODE ###

N, M = map(int, input().split())
a = list(map(int, input().split()))
for k in range(N):
  a[k] //= 2

foo = 1
while a[0]%2 == 0:
  foo *= 2
  a[0] //= 2
for k in range(1, N):
  if a[k] % foo == 0 and a[k]%(2*foo) !=0:
    a[k] //= foo
    continue
  else:
    print(0)
    exit()
ans = 0

import math
lcm = a.pop()
for k in range(1, N):
  b = a.pop()
  lcm = lcm * b // math.gcd(lcm, b)
  if lcm* foo > M:
    print(0)
    exit()
lcm *= foo
ans = int((M / lcm -1)//2 + 1)
print(ans)
### BUGGY CODE ###

n=int(input())
S=input()
R=[]
G=[]
B=[]
for i in range(n):
	if S[i]=='R':
		R.append(i+1)
	elif S[i]=='G':
		G.append(i+1)
	else:
		B.append(i+1)
r=len(R)
g=len(G)
b=len(B)

c=0
for i in R:
	for j in G:
		d=abs(i-j)
		min_n=min(i,j)
		max_n=max(i,j)
		if max_n+d in B:
			c+=1
		if (i+j)/2 in B:
			c+=1
		if min_n-d in B:
			c+=1

print(r*g*b-c)

### FIXED CODE ###

n=int(input())
S=input()
R=[]
G=[]
B=[]
for i in range(n):
	if S[i]=='R':
		R.append(i)
	elif S[i]=='G':
		G.append(i)
	else:
		B.append(i)
r=len(R)
g=len(G)
b=len(B)

c=0
for i in range(n):
	for j in range(i+1,n):
		k=2*j-i
		if k<n:
			if len(set([S[i],S[j],S[k]]))==3:
				c+=1

print(r*g*b-c)
### BUGGY CODE ###

import math

n, m = map(int, input().split())
A = list(map(int, input().split()))
As = sorted(A, reverse = True)
aas = As[0:m]
bs = As[m:]
for i in range(m):
    ii = math.floor(aas[0]/2)
    aas[0] = ii
    if len(aas) > 1:
        if aas[0] < aas[1]:
            aas = sorted(aas, reverse=True)


print(int(sum(aas)+sum(bs)))


### FIXED CODE ###

import math
import heapq

n, m = map(int, input().split())
A = list(map(int, input().split()))
A = list(map(lambda x:x*(-1), A))
heapq.heapify(A)
for i in range(m):
    min = (-1)*((-1)*(heapq.heappop(A))//2)
    heapq.heappush(A, min)


print(int(sum(A))*(-1))
### BUGGY CODE ###

import math

MOD = 10 ** 9 + 7

N, M = map(int, input().split())
a = [-1] + [int(input()) for i in range(M)] + [N + 1]

c = {}
def nCr(n, r):
    if (n, r) in c:
        return c[(n, r)]
    a = math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
    c[(n, r)] = a
    return a

d = {}
def step(n):
    if n in d:
        return d[n]
    a = 0
    for k in range(n // 2 + 1):
        a += nCr(n - k, k)
    d[n] = a
    return a

ans = 1
for i in range(M + 1):
    n = a[i + 1] - a[i] - 2
    if n < 0:
        ans = 0
    else:
        ans *= step(n)
print(ans % MOD)


### FIXED CODE ###

from collections import defaultdict

N, M = map(int, input().split())
a = defaultdict(lambda: True)
for i in range(M):
    a[int(input())] = False

dp = defaultdict(int)
dp[0] = 1
for i in range(1, N + 1):
    if a[i]:
        dp[i] = dp[i - 1] + dp[i - 2]
print(dp[N] % (10 ** 9 + 7))
### BUGGY CODE ###

from collections import deque


def merge(a_list, b_list):
    res = deque()

    while len(a_list) > 0 and len(b_list) > 0:
        if a_list[0] > b_list[0]:
            res.append(a_list.popleft())
        else:
            res.append(b_list.popleft())


    if len(a_list) > 0:
        res.extend(a_list)
    if len(b_list) > 0:
        res.extend(b_list)

    return res


N, M = map(int, input().split())
ab_list = [ list(map(int, input().split())) for i in range(N)]

score_list = [[] for i in range(M+1)]


for ab in ab_list:
    if ab[0] <= M:
        score_list[ab[0]].append(ab[1])

scores = [deque() for i in range(M+1)]
for i in range(len(score_list)):
    scores[i] = deque(sorted(score_list[i], reverse=True))
ans = 0
for i in range(0, M+1):
    if len(scores[i]) == 0:
        continue
    ans += scores[i].popleft()
    if i < M and len(scores[i]) > 0:
        scores[i+1] = merge(scores[i], scores[i+1])


print(ans)

### FIXED CODE ###

import heapq


N, M = map(int, input().split())
ab_list = [ list(map(int, input().split())) for i in range(N)]

score_list = [[] for i in range(M+1)]


for ab in ab_list:
    if ab[0] <= M:
        score_list[ab[0]].append(ab[1])


ans = 0
candidates = []

for i in range(0, M+1):

    for s in score_list[i]:
        heapq.heappush(candidates, -s)
    if len(candidates) == 0:
        continue
    ans -= heapq.heappop(candidates)


print(ans)
### BUGGY CODE ###

S = input()
Q = int(input())
query_list = []
for i in range(Q):
    query_list.append(input())
#print(S, Q, query_list)

result = S

for i in range(Q):
    #print(i + 1)
    q = query_list[i]
    #print(q)
    t = int(q[0])
    if t == 1:
        result = result[::-1]
    else:
        t, f, c = q.split()
        f = int(f)
        if f == 1:
            result = c + result
        else:
            result = result + c
    #print(t, f, c, result)
    #print("--------")
print(result)

### FIXED CODE ###

S = input()
Q = int(input())
query_list = []
for i in range(Q):
    query_list.append(input())
# print(S, Q, query_list)

M = 10 ** 6
start_position = int(M / 2)
left_position = start_position
right_position = start_position + len(S)
result = ["-"] * M
for i in range(len(S)):
    # print(i + left_position)
    result[i + left_position] = S[i]

# result = "".join(result[left_position:right_position])
# print(result)
# exit(0)
reverse_flag = False

for i in range(Q):
    # print(i + 1)
    # print(result[left_position:right_position])
    q = query_list[i]
    # print(q)
    t = int(q[0])
    if t == 1:
        reverse_flag = not reverse_flag
    else:
        t, f, c = q.split()
        f = int(f)
        c = c
        if f == 1:
            if reverse_flag:
                result[right_position] = c
                right_position += 1
            else:
                result[left_position - 1] = c
                left_position -= 1
        else:
            if reverse_flag:
                result[left_position - 1] = c
                left_position -= 1
            else:
                result[right_position] = c
                right_position += 1
    # print(t, f, c, result)
    # print("--------")
    #print(result[left_position:right_position])
# result = str(result)
# result = "".join(result)
# print(result)
# print(result[left_position:right_position])

result = "".join(result[left_position:right_position])
if reverse_flag:
    result = result[::-1]
print(result)
### BUGGY CODE ###

N,K = (int(x) for x in input().split())
mod = 10**9+7 #出力の制限
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル

def cmb(n, r, mod):
    if ( r<0 or r>n ):
        return 0
    r = min(r, n-r)
    return g1[n] * g2[r] * g2[n-r] % mod

for i in range( 2, N + 1 ):
    g1.append( ( g1[-1] * i ) % mod )
    inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
    g2.append( (g2[-1] * inverse[-1]) % mod )

K2 = K-2
a = list(map(int, input().split()))
a.sort()
ans = 0
for i in range(N):
    for j in range(i):
        ans += (a[i]-a[j])*(cmb(i-j-1,K2,mod))
        ans = ans % mod
print(ans)

### FIXED CODE ###

N,K = (int(x) for x in input().split())
mod = 10**9+7 #出力の制限
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル

def cmb(n, r, mod):
    if ( r<0 or r>n ):
        return 0
    r = min(r, n-r)
    return g1[n] * g2[r] * g2[n-r] % mod

for i in range( 2, N + 1 ):
    g1.append( ( g1[-1] * i ) % mod )
    inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
    g2.append( (g2[-1] * inverse[-1]) % mod )

K1 = K-1
NK = N-K+1
a = list(map(int, input().split()))
a.sort()
ans = 0
maxs = 0
mins = 0
for i in range(N):
    if i < K1:continue
    maxs += a[i] * cmb(i,K1,mod)
    maxs = maxs%mod
for i in range(NK):
    mins += a[i] * cmb(N-i-1,K1,mod)
    mins = mins%mod
print((maxs - mins)%mod)
### BUGGY CODE ###

import sys
import math
readline = sys.stdin.readline


def main():
    k = int(input())
    sumGCD = 0
    for a in range(1, k + 1):
        for b in range(1, k + 1):
            for c in range(1, k + 1):
                sumGCD += gcd(a, b, c)
    print(sumGCD)


def gcd(a, b, c):
    return math.gcd(math.gcd(a, b), c)


if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys
import math
import time
readline = sys.stdin.readline


def main():
    listSum = [1, 3, 6]
    k = int(input())
    sumGCD = 0
    for a in range(1, k + 1):
        for b in range(a, k + 1):
            for c in range(b, k + 1):
                sumGCD += gcd(a, b, c) * listSum[len(set([a, b, c])) - 1]
    print(sumGCD)


def gcd(a, b, c):
    return math.gcd(math.gcd(a, b), c)


if __name__ == '__main__':
    s = time.time()
    main()
    # print(time.time() - s)
### BUGGY CODE ###

import sys

s = ''
while True:
    try:
        s += sys.stdin.readline().lower()
    except:
        break

for c in 'abcdefghijklmnopqrstuvwxyz':
    print('{} : {}'.format(c, s.count(c)))

### FIXED CODE ###

s = ''
while True:
    try:
        s += input().lower()
    except EOFError:
        break

for c in 'abcdefghijklmnopqrstuvwxyz':
    print('{} : {}'.format(c, s.count(c)))
### BUGGY CODE ###

# coding: utf-8

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

p = 0
for i in range(n):
    j = i + 1
    t = 0
    while j < k:
        j **= 2
        t += 1
    p += ((1/2)**t)/n

print(p)


### FIXED CODE ###

# coding: utf-8

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

p = 0
for i in range(n):
    j = i + 1
    t = 0
    while j < k:
        j *= 2
        t += 1
    p += ((1/2)**t)/n

print(p)
### BUGGY CODE ###

# vim: fileencoding=utf-8


def main():
    N = int(input())
    for n in range(1, N + 1):
        ans = 0
        if n <= 5:
            print(ans)
            continue
        for x in range(1, int((N + 1) / 6) + 1):
            tx = x ** 2
            if tx >= n:
                break
            for y in range(1, int((N + 1) / 6) + 1):
                ty = tx + y ** 2 + x * y
                if ty >= n:
                    break
                for z in range(1, int((N + 1) / 6) + 1):
                    t = ty + z ** 2 + y * z + z * x
                    if t == n:
                        ans += 1
                    if t >= n:
                        break
        print(ans)


if __name__ == "__main__":
    main()


### FIXED CODE ###

# vim: fileencoding=utf-8


def main():
    N = int(input())
    ans = [0] * N
    for x in range(1, 101):
        for y in range(1, 101):
            for z in range(1, 101):
                t = x ** 2 + y ** 2 + z ** 2 + x * y + y * z + z * x - 1
                if t >= len(ans):
                    break
                ans[t] += 1

    print(*ans)


if __name__ == "__main__":
    main()
### BUGGY CODE ###

import collections


def main():
    n = int(input())
    word_list = []

    for _ in range(n):
        word_list.append(input())

    c = collections.Counter(word_list)
    most_freq_word = sorted([i for i in c if c[i] == max(c.values())])
    print('\n'.join(most_freq_word))


if __name__ == '__main__':
    main()

### FIXED CODE ###

import collections


def main():
    n = int(input())
    word_list = []

    for _ in range(n):
        word_list.append(input())

    c = collections.Counter(word_list)
    max_freq = max(c.values())
    most_freq_word = sorted([i for i in c if c[i] == max_freq])
    print('\n'.join(most_freq_word))


if __name__ == '__main__':
    main()
### BUGGY CODE ###

from scipy.sparse.csgraph import dijkstra, csgraph_from_dense, floyd_warshall
xs,ys,xg,yg = map(int, input().split())
N = int(input())
xyr = [(xs,ys,0)]
xyr.extend([list(map(int, input().split())) for i in range(N)])
xyr.append((xg,yg,0))
graph = [[0] * (N+2) for _ in range(N+2)]

max_val = 10**9

for i in range(N+2):
    graph[i][i] = max_val

for i in range(N+2):
    for j in range(i+1,N+2):
        x1,y1,r1 = xyr[i]
        x2,y2,r2 = xyr[j]
        d = max(0, ((x1-x2)**2 + (y1-y2)**2) ** 0.5 - r1 - r2)
        graph[i][j] = graph[j][i] = d

g = csgraph_from_dense(graph,null_value=max_val)
dij = dijkstra(g)
print(dij[0][-1])

### FIXED CODE ###

from scipy.sparse.csgraph import dijkstra, csgraph_from_dense
xs,ys,xg,yg = map(int, input().split())
N = int(input())
xyr = [(xs,ys,0)]
xyr.extend([list(map(int, input().split())) for i in range(N)])
xyr.append((xg,yg,0))
graph = [[0] * (N+2) for _ in range(N+2)]

max_val = 10**9

for i in range(N+2):
    graph[i][i] = max_val

for i in range(N+2):
    for j in range(i+1,N+2):
        x1,y1,r1 = xyr[i]
        x2,y2,r2 = xyr[j]
        d = max(0, ((x1-x2)**2 + (y1-y2)**2) ** 0.5 - r1 - r2)
        graph[i][j] = graph[j][i] = d

g = csgraph_from_dense(graph,null_value=max_val)
print(dijkstra(g,indices=0)[-1])