Harryxun/stf_run huggingface dataset:
s=input()
s=s.split(' ')
maisuu = int(s[0])
maney  = int(s[1])

minn_man = int(maney/10000)+1
minn_sen = int(maney / 1000 )+1
minn_go  = int(maney / 5000) +1
flg=True
for man in range(0,minn_man):
	for go in range(0,minn_go):
		for sen in range(0,minn_sen):
			if man+go+sen == maisuu:
				if man*10000+ go*5000 + sen*1000 == maney:
					print(str(man)+","+str(go)+","+str(sen))
					flg=False
		if flg!=True:
			break
	if flg!=True:
		break
if flg:
	print('-1,-1,-1')


### FIXED CODE ###

s=input()

data = s.split('/')
out = '2018/01/'+data[2]

print(out)
s=input()
if s[-1]="s":
  print(s[-1].replace("s","es"))
else:
  s1=s+"s"
print(s1)

### FIXED CODE ###

s=input()
if(s[-1:]=='s'):
  s1=s+"es"
  print(s1)
else:
  s2=s+"s"
  print(s2)
import sys
import bisect
import math
input = sys.stdin.readline

n = int(input())
l = [list(map(int, input().split())) for _ in range(n)]

mc = max(l)[1]
mc_sqrt = math.sqrt(mc)

prime = [i for i in range(2, mc + 1)]
c = 0
while True:
    if c >= len(prime):
        break
    t = prime[c]
    prime = [v for v in prime if v == t or v % t != 0]
    c = c + 1
    if c >= mc_sqrt:
        break
        
cum = [0 for i in range(mc + 1)]
for i in range(len(cum)):
    prime_index = bisect.bisect_left(prime, i)
    
    n2 = (i + 1) / 2
    prime_index2 = bisect.bisect_left(prime, n2)
    if len(prime) > prime_index and len(prime) > prime_index2 and prime[prime_index] == i and prime[prime_index2] == n2:
        cum[i] = cum[i - 1] + 1
    else:
        if i - 1 < 0:
            cum[i] = 0
        else:
            cum[i] = cum[i - 1]
        
for x, y in l:
    p = cum[x] - cum[x - 1]
    if x != y:
        p += cum[y] - cum[x]
    print(p)

### FIXED CODE ###

import sys
import bisect
import math
input = sys.stdin.readline

n = int(input())
l = [list(map(int, input().split())) for _ in range(n)]

mc = 0
for v in l:
    mc = max(mc, v[1])
mc_sqrt = math.sqrt(mc)

prime = [i for i in range(2, mc + 1)]
c = 0
while True:
    if c >= len(prime):
        break
    t = prime[c]
    prime = [v for v in prime if v == t or v % t != 0]
    c = c + 1
    if c >= mc_sqrt:
        break
        
cum = [0 for i in range(mc + 1)]
for i in range(len(cum)):
    prime_index = bisect.bisect_left(prime, i)
    
    n2 = (i + 1) / 2
    prime_index2 = bisect.bisect_left(prime, n2)
    if len(prime) > prime_index and len(prime) > prime_index2 and prime[prime_index] == i and prime[prime_index2] == n2:
        cum[i] = cum[i - 1] + 1
    else:
        if i - 1 < 0:
            cum[i] = 0
        else:
            cum[i] = cum[i - 1]

for t in l:
    x, y = t[0], t[1]
    p = 0
    if 0 <= x - 1:
        p = cum[x] - cum[x - 1]
    if x != y:
        p += cum[y] - cum[x]
    print(p)
n,m=[int(x) for x in input().split()]
a=[0 for _ in range(n)]
b=[0 for _ in range(n)]
for _ in range(m):
  p,q=input().split()
  if q=="AC": a[int(p)-1]=1+b[int(p)-1]
    else : b[int(p)-1]+=1
xg=0
for x in a:
  if x>0: xg+=1
print(xg,sum(a))

### FIXED CODE ###

n,m=[int(x) for x in input().split()]
a=[0 for _ in range(n)]
b=[0 for _ in range(n)]
xg=0
for _ in range(m):
  p,q=input().split()
  #print(p,q)
  if q=="AC": 
    #print("fir")
    rg=a[int(p)-1]
    if rg==0: a[int(p)-1]=1; xg+=b[int(p)-1]
  else : 
    #print("sec")
    b[int(p)-1]+=1
print(sum(a),xg)
A, B, K = map(int,input().split())
  for _ in range(K):
    if A >= 1:
      A -= 1
    elif B >= 1:
      B -= 1
    else:
      break
print(A,B)

### FIXED CODE ###

a,b,c = map(int, input().split())
if a<=c:
    if b<=c-a:
        print('0 0')
    else:
        print('0 {}'.format(a+b-c))
else:
    print('{} {}'.format(a-c,b))
import bisect

def number(num):
  #0bのぶんを引きます
  number_len = len(num)-2
  #numと同じ桁数で各桁が全て1である数を求めます。
  f ＝ 2**number_len - 1
  #排他的論理和をとって1を足したものを返します
  return (num^f)+1

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

count=0

while len(line)>0:
  #最後の数を取ってくる(最後尾なのでO(1)で済む)
  k=line.pop()
  #整数でないならその数は存在しないと同義なので処理を行わない
  if int(k) != k:
    continue
  x=number(k)
  #もしlineの最大値よりxが大きければ条件を満たすxは存在しないので処理を行わない
  if x>line[-1]:
    continue
  #その数が存在するならば、その数をlistから消去して、カウントする
  if line[bisect.bisect_left(line,x)]==x:
    #0.5を足すことでremoveの代わりとする
    line[bisect.bisect_left(line,x)] += 0.5
    count+=1

print(count)

### FIXED CODE ###

import bisect
def reversed_num(num):
  num_len=len(bin(num))-2
  f=2**num_len-1
  return num^f
n=int(input())
number=list(map(int,input().split()))
number.sort()
count=0
while len(number)>0:
  k=number.pop()
  if len(number)==0:
    break
  if k==int(k):
    x=reversed_num(k)+1
    y=bisect.bisect_left(number,x)
    if x>number[-1]:
      y-=1
    if number[y] ==x:
      number[y]-=0.5
      count+=1
print(count)
def BinarySearchLowerBound(_arr, _ele): # arr is strictly increasing
    low_ind = 0
    up_ind = len(_arr) - 1
    found = None
    if _arr[low_ind] >= _ele:
        return low_ind
    while (up_ind - low_ind) > 1:
        mid = (up_ind + low_ind) / 2
        if _arr[mid] < _ele:
            low_ind = mid
        elif _arr[mid] > _ele:
            up_ind = mid
        elif _arr[mid] == _ele:
            found = mid
            break
    if found is not None:
        cnt = found
    else:
        cnt = up_ind
    return cnt

def solve():
    N, Q = [int(_) for _ in raw_input().split()]
    STX = []
    for i in range(N):
        Si, Ti, Xi = [int(_) for _ in raw_input().split()]
        STX.append((Si - Xi, Ti - Xi, Xi))
    D = []
    for i in range(Q):
        D.append((int(raw_input()), i))
    STX.sort(key = lambda x:x[2])
    # D have already been sorted based on settings on problem
    ans = [-1] * Q
    for i in range(N):
        Li, Ri, Xi = STX[i]
        it = BinarySearchLowerBound(D, (Li, -1))
        while it < len(D):
            if D[it][0] >= Ri:
                break
            ans[D[it][1]] = Xi
            D.pop(it)
    for i in range(Q):
        print ans[i]

if __name__ == '__main__':
    solve()


### FIXED CODE ###

import bisect

def solve():
    N, Q = [int(_) for _ in raw_input().split()]
    STX = []
    for i in range(N):
        Si, Ti, Xi = [int(_) for _ in raw_input().split()]
        STX.append((Si - Xi, Ti - Xi, Xi))
    D = []
    for i in range(Q):
        D.append((int(raw_input()), i))
    STX.sort(key = lambda x:x[2])
    # D have already been sorted based on settings on problem
    ans = [-1] * Q
    l = [None] * Q
    for i in range(N):
        Li, Ri, Xi = STX[i]
        lit = bisect.bisect_left(D, (Li, -1))
        rit = bisect.bisect_left(D, (Ri, -1))
        while lit < rit:
            if l[lit] is not None:
                lit = l[lit]
            else:
                ans[D[lit][1]] = Xi
                l[lit] = rit
                lit += 1
    for i in range(Q):
        print ans[i]

if __name__ == '__main__':
    solve()
a,b = map(int, input().split())
 
ans = a + b
if ans < 24:
    print(s)
else:
    print(s - 24)

### FIXED CODE ###

a, b = map(int, input().split())
ans = a + b

if ans < 24:
    print(ans)
else:
    print(ans - 24)
N, A, B, C, D = list(map(int, input().split()))

S = input()

# 以下indexに変更
A-=1
B-=1
C-=1
D-=1

L = [1]*N

# 0を岩、1を通路とする
for i in range(N):
    if S[i] == '#':
        L[i] =  0


def search(idx, g, reversed_goal):
    L[idx] =0
    if reversed_goal:
        if idx == g:
            if idx+1 <= g and L[idx-1] and L[idx+1]:
                return True
                
            return False
    else:
        if idx == g:
            return True 

    if reversed_goal and idx+2 <= g and L[idx+2] and L[idx+1]:
        L[idx] =1
        L[idx+1] = 0
        return True


    if idx+2 <= g and L[idx+2]:
        L[idx] = 1
        return search(idx+2, g, reversed_goal)
    
    if idx+1 <= g and L[idx+1]:
        L[idx] = 1
        return search(idx+1, g, reversed_goal)
    
    return False

def main():
    reversed_goal = C > D
    if not reversed_goal:
        if search(B,D,False):
            if search(A,C,False):
                return 'Yes'
            
        return 'No'

    else:
        if search(B,D,True):
            if search(A,C,False):
                return 'Yes'

        return 'No'

ans = main()
print(ans)

### FIXED CODE ###

if __name__ == '__main__':
    N, A, B, C, D = map(int, input().split())
    S = str(input())
 
    answer = "-1"
 
    if C < D:
       if S[A:D:].count("##") >= 1:
           answer = "No"
       else:
           answer = "Yes"
    else:
       if S[B-2:D+1:].count("...") >= 1:
           answer = "Yes"
       else:
           answer = "No"
 
    print(answer)
N=int(input())
S=[list(map(int,input().split())) for i in range(N)]
m=0
a=0
r=0
c=0
h=0
for i in range(N):
  if S[i][0]=="M":
    m+=1
  if S[i][0]=="A":
    a+=1
  if S[i][0]=="R":
    r+=1
  if S[i][0]=="C":
    c+=1
  if S[i][0]=="H":
    h+=1
print(m*a*r+m*a*c+m*a*h+m*r*c+m*r*h+m*c*h+a*r*c+a*r*h*a*c*h+r*c*h)

### FIXED CODE ###

N=int(input())
s=[]
for i in range(N):
  S=input()
  s.append(S)
m=0
a=0
r=0
c=0
h=0
for i in range(N):
  if s[i][0]=="M":
    m+=1
  if s[i][0]=="A":
    a+=1
  if s[i][0]=="R":
    r+=1
  if s[i][0]=="C":
    c+=1
  if s[i][0]=="H":
    h+=1
print(m*a*r+m*a*c+m*a*h+m*r*c+m*r*h+m*c*h+a*r*c+a*r*h+a*c*h+r*c*h)
n = int(input())
a = list(map(int,input().split()))
b = [[0,0]　for i in range (n)]
c = []
for i in range(n):
    b[i][1] = a[i]
    b[i][0] = i+1
b.sort(key=lambda x:x[1])
for i in range(n):
    c.append(b[i][0])
print(*c)


### FIXED CODE ###

n = int(input())
a = list(map(int,input().split()))
b = [[0,0] for i in range (n)]
c = []
for i in range(n):
    b[i][1] = a[i]
    b[i][0] = i+1
b.sort(key=lambda x:x[1])
for i in range(n):
    c.append(b[i][0])
print(*c)
# encoding:utf-8
import copy
import numpy as np
import random

n,q = map(int,input().split())
s = list(str(input()))
L = []
for i in range(q):
    l,r = map(int,input().split())
    L.append([l,r])

# count_ac = np.zeros([n])
count_ac = []
count = 0
i = 0
while (i<n-1):
    if s[i] == "A" and s[i+1] == "C":
        count_ac.append(count)
        count += 1
        count_ac.append(count)
        i += 2
    else:
        count_ac.append(count)
        i += 1


for i in range(q):
    ans = count_ac[L[i][1]-1]-count_ac[L[i][0]-1]
    print(int(ans))


### FIXED CODE ###

# encoding:utf-8
import copy
import numpy as np
import random

n,q = map(int,input().split())
s = list(str(input()))
L = []
for i in range(q):
    l,r = map(int,input().split())
    L.append([l,r])

# count_ac = np.zeros([n])
count_ac = []
count = 0
i = 0
while i < n-1:
    if s[i] == "A" and s[i+1] == "C":
        count_ac.append(count)
        count += 1
        count_ac.append(count)
        i += 2
    else:
        count_ac.append(count)
        i += 1

count_ac.append(count)


# print(count_ac)
for i in range(q):
    ans = count_ac[L[i][1]-1]-count_ac[L[i][0]-1]
    print(int(ans))
def main():

    n = int(input())
    table = [0]*(n+1)
    x = input()
    k = x.count("1")
    for i in range(1,n+1):
        tmp=str(bin(i)).count("1")
        table[i]=i%tmp
    tmp = 0
    j=n
    for i in range(n):
        if(x[i]=="1"):
            tmp += 2**(j-1)
        j-=1
    j=n
    res = [0]*n
    for i in range(n):
        tmp2=k#1の数
        tmp3 = tmp#１０進数表記
        if(x[i]=="1"):
            tmp2-=1
            tmp3 -= (2**(j-i-1))
        else:
            tmp2+=1
            tmp3 += 2**(j-i-1)
        next = tmp3%tmp2

        if(next==0):
            res[i]=1
        else:
            res[i]+=1
            while(next!=0):
                res[i]+=1
                next = table[next]

    for i in range(n):
        print(res[i])


if __name__ == '__main__':
    main()


### FIXED CODE ###

def main():
    l,r,d=map(int, input().split())
    res = 0
    for i in range(l,r+1):
        if(i%d==0):
            res+=1
    print(res)

if __name__ == '__main__':
    main()
n = int(input())
a = list(map(int,input().split()))
w = [0 for i in range(9)]
count = 0
for i in a:
    if i < 3200 and w[i//400]==0:
        count+=1
    w[i//400]+=1
if count == 0:
    print(1,w[8])
elif w[8] == 0:
    print(count,count)
else:
    print(count,count+w[8])

### FIXED CODE ###

n = int(input())
a = list(map(int,input().split()))
w = [0 for i in range(8)]
count = 0
sup = 0
for i in a:
    if i < 3200 and w[i//400]==0:
        count+=1
        w[i//400] += 1
    elif i >= 3200:
        sup += 1
if count == 0:
    print(1,sup)
elif sup == 0:
    print(count,count)
else:
    b= count+sup
    print(count,b)
a,b = map(int, input().split())
dis = b - a
cnt = 0
for i in range(dis):
    nm = str(i + dis)
    if nm[0] == nm[4]:
        if nm[1] == nm[3]:
            cnt += 1

print(cnt)

### FIXED CODE ###

n = input().split()
dis = int(n[1]) - int(n[0])
cnt = 0
for i in range(dis+1):
    nm = str(i + int(n[0]))
    if nm[0] == nm[-1]:
        if nm[1] == nm[-2]:
            cnt += 1

print(cnt)
import sys
input = sys.stdin.readline

def main():
    N,Q = list(map(int,input().split()))

    road = []
    x_list = []
    for i in range(N):
        s,t,x = list(map(int,input().split()))
        road.append((s-x,x,0))
        road.append((t-x,x,1))
        x_list.append(x)

    for i in range(Q):
        d = int(input())
        road.append((d,i,2))

    road.sort(lambda x:x[2])
    road.sort(lambda x:x[0])

    x_list = list(set(x_list))
    x_list.sort()

    x2i_dict = {}
    for i,x in enumerate(x_list):
        x2i_dict[x]=i


    class BIT:
            
        def __init__(self, L):
            self.N = len(L)
            self.bit = [0]*self.N
            for i,l in enumerate(L):
                self.add(i,l)

        def add(self, a, w):
            x = a + 1
            for i in range(1000):
                self.bit[x-1] += w
                 x += x & -x
                if x > self.N:
                    break

        def sum(self, a):
            x = a+1
            ret = 0
            for i in range(1000):
                ret += self.bit[x-1]
                x -= x & -x
                if x <= 0:
                    break        
           return ret


    bit = BIT([0]*xn)
    bitadd = bit.add
    bitsum = bit.sum
    def bisectR(l,r,bit):
        while r-l>1:
            if bitsum((l+r)//2)>0:
                r = (l+r)//2
            else:
                l = (l+r)//2
        return r

    xn=len(x_list)

    ans = [0]*Q
    for r in road:
        if r[2]==0:
             bitadd(x2i_dict[r[1]],1)
        elif r[2]==1:
            bitadd(x2i_dict[r[1]],-1)
        else:
            if bitsum(xn-1)==0:
               ans[r[1]]=-1
            elif bitsum(0)>0:
                ans[r[1]]=x_list[0]
            else:
                i = bisectR(0,xn-1)
                ans[r[1]] = x_list[r]
    for a in ans:
        print(a)

if __name__ == '__main__':
    main()

### FIXED CODE ###

import sys

sys.setrecursionlimit(500000)
def input():
    return sys.stdin.readline()[:-1]

def main():
    N,Q = list(map(int,input().split()))

    road = []
    x_list = []

    for i in range(N):
        s,t,x = list(map(int,input().split()))
        road.append([0,s-x,x])
        road.append([1,t-x,x])

    for i in range(Q):
        road.append([2,int(input()),i])

    from collections import defaultdict

    counter = defaultdict(int)
    counter[10**27] = 1
    ans = [0]*Q

    road.sort(key=lambda x:x[0])
    road.sort(key=lambda x:x[1])

    q = [10**27]

    from heapq import heappop,heappush

    for id,_,x in road:
        if id==0:
            heappush(q,x)
            counter[x]+=1
        elif id==1:
            counter[x]-=1
        else:
            while counter[q[0]]==0:
                heappop(q)
            #print(q)
            if q[0]<10**27:
                ans[x] = q[0]
            else:
                ans[x] = -1
    print("\n".join(map(str,ans)))

if __name__ == '__main__':
    main()
import numpy as np

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

matrix = np.ones(num[0]) * (-1)
sign_0 = []
sign_1 = []
ans = 0

if num[1] == 0:
  if not matrix[0] == 0:
    ans = 10**(num[0]-1)
  elif matrix[0] == 0:
    ans = -1

elif not num[1] == 0:
  for i in range(0,num[1]):
    temp = list(map(int,input().split()))
    if (temp[0] in sign_0 and) (temp not in sign_1) :
      ans = -1
      break
    else:
      matrix[temp[0]-1] = temp[1]
      sign_0.append(temp[0])
      sign_1.append(temp)
  
  if not ans == -1:
    if matrix[0] == -1:
       matrix[0] = 1
        
    for i in range(1,num[0]):
      if matrix[i] == -1:
        matrix[i] = 0
        
    ans = matrix[0]*(10**(num[0]-1))
    
    for i in range(1,num[0]):
      ans = ans + matrix[i]*(10**(num[0]-1-i))
    ans = int(ans)
      
  judge_a = len(list(str(ans)))
  judge = judge_a - num[0]
  
  if not judge == 0:
    ans = -1
    
  
print(int(ans))

### FIXED CODE ###

import numpy as np
n,m = map(int,input().split())
base = np.zeros(n)
seen = np.zeros(n)
base[0] = 1
sign = 0

for i in range(m):
  s,c = map(int,input().split())
  if (seen[s-1] == 0) or (base[s-1] == c):
    base[s-1] = c
    seen[s-1] = 1
    sign = 1
  else:
    sign = 2
    break
ans = 0
if (sign == 2) or ((base[0] == 0) and (n > 1)):
  ans = -1
else:
  for i in range(1,len(base)+1):
    ans += base[-i]*(10**(i-1))
    
if (m == 0) and (n == 1):
  ans = 0
print(int(ans))
import sys,queue,math,copy,itertools,bisect,collections
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
_LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())

X,Y,Z,K = LI()
A = LI()
B = LI()
C = LI()

if len (C) > len(A) and len(C) > len(B):
    A,C = C,A
elif len(B) > len(A) and len(B) > len(C):
    A,B = B,A

AB = [a + b for a in A for b in B]
AB.sort(reverse=True)
C.sort(reverse=True)
max_abc = AB[0] + C[0]

l = 0
h = max_abc

while h > l+1:
    m = (h+l) // 2

    num = 0
    j = len(C) - 1
    for i in AB:
        while i + C[j] < m:
            j -= 1
            if j < 0: break
        else:
            num += j + 1
            continue
        break
    if num > K:
        l = m
    else:
        h = m

ans = []
j = len(C) - 1
for i in AB:
    while i + C[j] < l:
        j -= 1
        if j < 0: break
    else:
        for k in range(j+1):
            ans.append(i+C[k])
ans.sort(reverse=True)
print (*ans[:K],sep='\n')



### FIXED CODE ###

import sys,queue,math,copy,itertools,bisect,collections
LI = lambda : [int(x) for x in sys.stdin.readline().split()]

X,Y,Z,K = LI()
A = LI()
B = LI()
C = LI()

A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)

h = A[0] + B[0] + C[0]
l = 0
while h > l+1:
    m = (h+l) // 2

    num = 0
    for a in A:
        j = len(C) - 1
        for i in B:
            while i + C[j] < m - a:
                j -= 1
                if j < 0: break
            else:
                num += j + 1
                continue
            break
    if num > K:
        l = m
    else:
        h = m

ans = []
cnt = 0
for a in A:
    j = len(C) - 1
    last_cnt = cnt
    for i in B:

        while i + C[j] <= l - a:
            j -= 1
            if j < 0: break
        else:
            for k in range(j+1):
                ans.append(a+i+C[k])
                cnt += 1
            continue
        break
ans.sort(reverse=True)
for _ in range(K-len(ans)):
    ans.append(l)
print (*ans[:K],sep='\n')
b = int(input())
if b == "A":
    print("T")
elif b == "C":
    print("G")
elif b == "T":
    print("A")
else:
    print("C")


### FIXED CODE ###

b = (input())
if b == "A":
    print("T")
elif b == "C":
    print("G")
elif b == "T":
    print("A")
else:
    print("C")
x,y,z = map(int,input().split())

a,b = b,a
a,c = c,a
print(a,b,c)

### FIXED CODE ###

x,y,z = map(int,input().split())

x,y = y,x
x,z = z,x
print(x,y,z)
N = int(input())
A = list(map(int,input().split()))

A = A % (1*10**9 + 7)
value = 0
plus = 0
ans = 0

for i in range(N-1):
    for j in range(N-i-1):
        value = (A[i]*A[i+j+1]+value) % (1*10**9 + 7)
        

print(value)


### FIXED CODE ###

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

A_sum = sum(A)

value = 0
ans = 0

for i in range(N-1):
    A_sum -= A[i]
    value += A[i]*A_sum

ans = value % (1*10**9+7)

print(ans)
from itertools import product
import numpy as np

N, M, X = map(int, input().split())
C = [0] * N
A = [[0] * M for _ in range(N)]
for i in range(N):
    c = list(map(int, input().split()))
    C[i] = c[0]
    A[i] = c[1:]

def calc(p):
    cnt = np.dot(np.array(list(p)), np.array(A))
    return np.dot(np.array(list(p)), np.array(C)) if all(i >= X for i in cnt) else 10 ** 30

ans = 10 ** 30
for p in product(range(2), repeat=N):
    ans = min(ans, calc(p))

print(ans if ans < 10 ** 30 else -1)


### FIXED CODE ###

from itertools import product
N, M, X = map(int, input().split())
C = [0] * N
A = [[0] * M for _ in range(N)]
for i in range(N):
    c = list(map(int, input().split()))
    C[i] = c[0]
    A[i] = c[1:]

def calc(p):
    ret = 0
    cnt = [0] * M
    for i, v in enumerate(p):
        if v == 1:
            for ia, a in enumerate(A[i]):
                cnt[ia] += a
            ret += C[i]
    return ret if all(i >= X for i in cnt) else 10 ** 30
    

ans = 10 ** 30
for p in product(range(2), repeat=N):
    ans = min(ans, calc(p))

print(ans if ans < 10 ** 30 else -1)
N, K = map(int, input().split())

def f(N, K):
    for i in range(N+1):
        a = i*(i-1)//2
        for j in range(N+1):
            for k in range(N+1):
                if i+j+k+1==N and a+j+k==K:
                    return (i, j, k)
    return (-1, -1, -1)

i, j, k = f(N, K)
if i==-1 and j==-1 and k==-1:
    print(-1)
else:
    l = []
    for a in range(2, 2+i):
        l.append((1,a))

    p = a
    for a in range(p, p+j+1):
        l.append((a, a+1))
    p = a

    for a in range(p+j+1, N+1):
        for b in range(a+1, N+1):
            l.append((a,b))
    
    print(len(l))
    for a, b in l:
        print(a, b)

### FIXED CODE ###

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

amax = (N-1)*(N-2)//2
if amax-K>=0:
    print(amax-K+N-1)
    for i in range(N-1):
        print(1, i+2)
    cnt = 0

    def out(x):
        cnt = 0
        for i in range(2, N+1):
            for j in range(i+1, N+1):
                if cnt == amax-K:
                    return
                print(i, j)
                cnt += 1
    out(amax-K)
else:
    print(-1)
from math import floor, sqrt

N = int(input())
ans = 0
for o in range(1, N + 1, 2):
	cnt = 0
    for n in range(1, 1 + floor(sqrt(o))):
    	if o % n == 0:
            cnt += 2
    if cnt == 8:
      ans += 1
print(ans)
        

### FIXED CODE ###

from math import floor, sqrt
 
N = int(input())
ans = 0
for o in range(1, N + 1, 2):
    cnt = 0
    for n in range(1, 1 + floor(sqrt(o))):
    	if o % n == 0:
            cnt += 2
    if cnt == 8:
        ans += 1
print(ans)