Let's consider a table consisting of n rows and n columns. The cell located at the intersection of i-th row and j-th column contains number i × j. The rows and columns are numbered starting from 1.

You are given a positive integer x. Your task is to count the number of cells in a table that contain number x.


-----Input-----

The single line contains numbers n and x (1 ≤ n ≤ 10^5, 1 ≤ x ≤ 10^9) — the size of the table and the number that we are looking for in the table.


-----Output-----

Print a single number: the number of times x occurs in the table.


-----Examples-----
Input
10 5

Output
2

Input
6 12

Output
4

Input
5 13

Output
0



-----Note-----

A table for the second sample test is given below. The occurrences of number 12 are marked bold.  [Image]

Difficulty: EASY

Solutions:
(a, b) = map(int, input().split())
c = 0
for i in range(1, min(a, b) + 1):
	if i * a >= b and b % i == 0:
		c += 1
print(c)


(n, x) = map(int, input().split())
c = 0
for i in range(1, n + 1):
	if x % i == 0 and x / i <= n:
		c = c + 1
print(c)


(m, x) = map(int, input().split())
if x == 1:
	print(1)
else:

	def divide(n):

		def generator(n):
			divisors = []
			for i in range(1, int(n ** (1 / 2)) + 1):
				if n % i == 0:
					yield i
					if i * i != n:
						divisors.append(n / i)
			for divisor in reversed(divisors):
				yield int(divisor)
		return list(generator(n))[1:-1]
	factors = divide(x)
	for i in range(len(factors)):
		if factors[i] > m:
			j = factors.index(x // factors[i])
			factors = factors[j + 1:i]
			break
	occ = len(factors)
	if x <= m:
		occ += 2
	print(occ)


(n, x) = map(int, input().split(' '))
count = 0
for e in range(1, n + 1):
	if x % e == 0 and x // e <= n:
		count += 1
print(count)


a = list(map(int, input().split(' ')))
n = a[0]
k = a[1]
b = int(k / 2)
total = 0
for i in range(1, n + 1):
	if k % i == 0 and k / i <= n and (i <= n):
		total = total + 1
print(total)


import math
from collections import Counter

def get(f):
	return map(f, input().split())

def divides(a, b):
	return a % b == 0

def main():
	(n, x) = get(int)
	if n * n < x:
		print(0)
	else:
		cnt = 0
		for i in range(1, n + 1):
			if divides(x, i) and math.floor(x / i) <= n:
				cnt += 1
		print(cnt)
main()


(n, x) = map(int, input().split())
c = 0
i = 1
while i * i <= x:
	if x % i == 0 and i <= n and (x // i <= n):
		if i != x // i:
			c += 2
		else:
			c += 1
	i += 1
print(c)


(n, m) = map(int, input().split())
count = 0
for i in range(1, n + 1):
	x = m // i
	y = i
	if m % i == 0 and x <= n:
		count += 1
print(count)


(n, x) = input().split()
n = int(n)
x = int(x)
k = 0
for i in range(1, n + 1):
	if x % i == 0 and x // i <= n:
		k += 1
print(k)


def multi(n, x):
	cell = 0
	i = 1
	while i <= n and i <= x:
		if x % i == 0:
			r = x // i
			if r <= n:
				cell += 1
		i += 1
	return cell
(n, x) = list(map(int, input().split()))
print(multi(n, x))


(n, x) = map(int, input().split())
cnt = 0
for i in range(1, n + 1):
	if i * i > x:
		break
	j = x // i
	if i * j != x:
		continue
	if i == j:
		cnt += 1
	elif j <= n:
		cnt += 2
print(cnt)


(n, x) = map(int, input().split())
a = 0
if n > x:
	en = x
else:
	en = n
for i in range(1, en + 1):
	if x % i == 0 and x / i <= n:
		a += 1
print(a)


from math import *

def main():
	(n, x) = input().split()
	(n, x) = (int(n), int(x))
	totalCount = 0
	if x == 1:
		print(1)
		return ()
	for i in range(1, n + 1):
		if x % i == 0:
			if x / i <= n:
				totalCount += 1
	print(totalCount)
	return ()
main()


(n, x) = map(int, input().split())
t = 0
for j in range(1, n + 1):
	if x % j == 0 and x // j <= n:
		t += 1
print(t)


import math
(n, x) = map(int, input().split(' '))

def divs(n, x):
	div = []
	for i in range(1, n + 1):
		if x % i == 0 and x / i <= n:
			div.append(i)
	return div
divisors = [i for i in divs(n, x)]
print(len(divisors))


(a, b) = [int(i) for i in input().split()]
if b > a ** 2:
	print(0)
else:
	k = 0
	for i in range(1, a + 1):
		if b % i == 0 and b // i <= a:
			k += 1
	print(k)


(n, a) = map(int, input().split())
r = 0
for i in range(1, n + 1):
	if a % i == 0:
		if a / i == i:
			r += 1
		elif a / i < i:
			r += 2
print(r)


l = list(map(int, input().split(' ')))
count_x = 0
n = l[0]
x = l[1]
if n >= x:
	for i in range(1, x + 1):
		if x % i == 0:
			count_x += 1
else:
	for i in range(2, n + 1):
		if x % i == 0 and x // i < n + 1:
			count_x += 1
print(count_x)


(n, x) = map(int, input().split())
print(sum((x % i == 0 and x <= n * i for i in range(1, n + 1))))


z = list(map(int, input().split()))
b = 0
if z[0] > z[1]:
	for i in range(1, z[1] + 1):
		if z[1] % i == 0 and z[1] / i <= z[0]:
			b = b + 1
else:
	for i in range(1, z[0] + 1):
		if z[1] % i == 0 and z[1] / i <= z[0]:
			b = b + 1
print(b)


def tables(n, x):
	res = 0
	t = n
	if n >= x:
		t = x
		res = 1
	for i in range(2, t + 1):
		if x % i == 0 and x / i <= n:
			res += 1
	return res
(n, x) = map(int, input().split())
print(tables(n, x))


import math
(n, x) = map(int, input().split())
l1 = list((p for p in range(1, n + 1)))
l = []
ans = 0
for num in range(1, n + 1):
	if x % num == 0:
		l.append([num, x // num])
for (x, y) in l:
	if x in l1 and y in l1:
		ans += 1
print(ans)


(a, b) = map(int, input().split())
ans = 0
for i in range(1, a + 1):
	if b % i == 0:
		if b // i <= a:
			ans += 1
print(ans)


(n, x) = map(int, input().split())
d1 = {}
for i in range(1, n + 1):
	d1[i] = True
cnt = 0
for i in range(1, n + 1):
	if x % i == 0 and x // i in d1:
		cnt += 1
print(cnt)


x = input().split()
res = 0
for i in range(1, int(x[0]) + 1):
	if i == 1:
		if int(x[0]) >= int(x[1]):
			res += 1
		continue
	if int(x[1]) % i == 0 and i * int(x[0]) >= int(x[1]):
		res += 1
print(res)


def main(count=0):
	(n, x) = map(int, input().split())
	arr = []
	for i in range(1, int(x ** (1 / 2)) + 1):
		if x % i == 0:
			arr.append([i, x // i])
	for k in arr:
		if k[0] == k[1] and k[0] <= n and (k[1] <= n):
			count += 1
		elif k[0] <= n and k[1] <= n:
			count += 2
	return count
print(main())


(size, val) = list(map(int, input().split()))
if size >= val:
	count = 0
	for i in range(1, size + 1):
		if val % i == 0:
			if val / i > size:
				pass
			else:
				count += 1
else:
	count = 0
	for i in range(2, size + 1):
		if val % i == 0:
			if val / i > size:
				pass
			else:
				count += 1
print(count)


(n, k) = map(int, input().split())
if k > n * n or k == 0:
	print(0)
else:
	c = 0
	for i in range(1, n + 1):
		if k % i == 0 and k / i <= n:
			c += 1
	print(c)


(n, x) = map(int, input().strip().split())
res = 0
for i in range(1, n + 1):
	if x % i == 0 and x / i <= n:
		res += 1
print(res)


(n, x) = map(int, input().split())
q = 0
ans = 0
for i in range(1, n + 1):
	if x % i == 0:
		q = x / i
		if q <= n:
			ans += 1
print(ans)


(n, x) = map(int, input().split())
count = 0
coeff = 1
denominators = []
while coeff ** 2 <= x:
	if x % coeff == 0 and coeff <= n:
		denominators.append(coeff)
		if coeff != x // coeff and x // coeff <= n:
			denominators.append(x // coeff)
	coeff += 1
denominators.sort()
for i in denominators:
	for j in denominators:
		if i * j > x:
			break
		elif i * j == x:
			count += 1
print(count)


import math
(n, x) = [int(i) for i in input().split()]
count = 0
for i in range(1, n + 1):
	if x % i == 0 and x // i <= n:
		count += 1
print(count)


(n, x) = map(int, input().split())
a = []
s = 0
for i in range(1, n + 1):
	if x % i == 0 and x / i <= n:
		s += 1
print(s)


def cnt(n, x):
	if x > n * n:
		return 0
	k = 0
	p = max(x // n, 1)
	for i in range(p, n + 1):
		if x % i == 0 and x // i <= n:
			k += 1
	return k
s = input()
ast = [int(i) for i in s.split(' ')]
(n, x) = (ast[0], ast[1])
print(cnt(n, x))


from math import sqrt
(n, x) = map(int, input().split())
lim = int(sqrt(x)) + 3
ans = 0
d = {}
for i in range(1, n + 1):
	if x % i == 0 and max(x // i, i) <= n:
		ans += 1
print(ans)


(n, m) = map(int, input().split())
s = 0
for i in range(1, n + 1):
	if m % i == 0:
		if m / i < n or m / i == n:
			s = s + 1
print(s)


import math
num = input()
arr = []
counting = 0
for m in range(0, len(num)):
	if num[m] == ' ':
		arr.append(int(num[counting:m]))
		counting = m + 1
	elif m == len(num) - 1:
		arr.append(int(num[counting:len(num)]))
dimension = arr[0]
req_value = arr[1]
n = dimension
match = 0
while n > 0:
	val = req_value / n
	if val <= dimension and val % 1 == 0:
		match += 1
	n -= 1
print(match)


cnt = 0
(n, x) = map(int, input().split())
for i in range(2, n + 1):
	if x % i == 0 and x / i <= n:
		cnt += 1
if x <= n:
	cnt += 1
print(cnt)


l = list(map(int, input().strip().split()))
n = l[0]
x = l[1]
count = 0
for i in range(1, n + 1):
	if x % i == 0:
		a = x // i
		if a <= n:
			count = count + 1
print(count)


(n, t) = map(int, input().split())
cnt = 0
a = []
for i in range(1, n + 1):
	if t % i == 0:
		a.append(i)
cnt = len(a)
for i in range(len(a)):
	if a[i] * a[-1] < t:
		cnt -= 1
print(cnt)


import math
(n, x) = str(input()).split()
n = int(n)
x = int(x)
if x == 1:
	print(1)
else:
	value = 0
	level = math.sqrt(x)
	for i in range(1, n + 1):
		if i >= level:
			value *= 2
			if i == level:
				value += 1
			break
		elif x % i == 0:
			if x <= n * i:
				value += 1
	print(value)


(n, a) = [int(x) for x in input().split()]
c = 0
for i in range(1, n + 1, 1):
	if a % i == 0:
		d = a / i
		if d <= n and i <= n:
			c = c + 1
print(c)


import sys
from collections import defaultdict

def stdinWrapper():
	data = '100000 1000000000\n\n'
	for line in data.split('\n'):
		yield line
if '--debug' not in sys.argv:

	def stdinWrapper():
		while True:
			yield input()
inputs = stdinWrapper()

def inputWrapper():
	return next(inputs)

def getType(_type):
	return _type(inputWrapper())

def getArray(_type):
	return [_type(x) for x in inputWrapper().split()]
(n, x) = getArray(int)
if x == 1:
	print('1')
	exit()
result = 0
for i in range(1, n + 1):
	if x % i == 0 and x / i <= n:
		result += 1
print(result)


(n, x) = [int(i) for i in input().split()]
count = 0
if x <= n ** 2:
	for i in range(1, min(n, x) + 1):
		if x % i == 0 and x // i <= n:
			count += 1
print(count)


from sys import stdin, stdout
input = lambda : stdin.readline().strip()
(a, b) = [int(i) for i in input().split()]
min1 = min([a, b])
nd = 0
for i in range(1, min1 + 1):
	if b % i == 0 and b // i <= a:
		nd += 1
print(nd)


def strangeCounter(t):
	count = 0
	for i in range(1, int(t[0]) + 1):
		if int(t[1]) % i == 0 and int(t[1]) // i <= int(t[0]):
			count += 1
	print(count)
t = input().split()
strangeCounter(t)


(n, x) = map(int, input().split())
ans = 0
d = 1
while d * d <= x:
	if d * d == x and d <= n:
		ans += 1
	if d * d < x and d <= n and (x // d <= n) and (x % d == 0):
		ans += 2
	d += 1
print(ans)


(n, x) = map(int, input().split())
ncount = 0
for i in range(1, n + 1):
	if x % i == 0:
		if x / i <= n:
			ncount += 1
print(ncount)


(a, b) = list(map(int, input().split()))
count = 0
for i in range(1, a + 1):
	if b % i == 0 and b // i <= a:
		count += 1
print(count)


from collections import deque
from collections import OrderedDict
import math
import sys
import os
import threading
import bisect
import operator
import heapq
from atexit import register
from io import BytesIO
import io
input = lambda : sys.stdin.readline().rstrip('\r\n')
(n, m) = map(int, input().split())
liD = []
limit = math.sqrt(m)
answer = 0
if math.ceil(limit) - math.floor(limit) == 0 and n >= int(limit):
	answer += 1
	limit -= 1
limit = int(math.floor(limit))
for i in range(1, limit + 1):
	if m % i == 0:
		liD.append(i)
for i in range(len(liD)):
	if m // liD[i] <= n:
		answer += 2
print(answer)


(n, x) = [int(i) for i in input().split()]
ans = 0
for i in range(1, n + 1):
	temp = x % i
	if not temp and x // i <= n:
		ans += 1
print(ans)


import math
(n, k) = map(int, input().split())
divisors = set()
i = 1
while i <= int(math.sqrt(k)):
	if k % i == 0:
		if k / i == i:
			divisors.add(i)
		else:
			divisors.add(i)
			divisors.add(int(k / i))
	i += 1
divisors = set((i for i in divisors if i <= n))
count = 0
for i in divisors:
	for j in divisors:
		if i * j == k:
			count += 1
print(count)


(size, n) = map(int, input().split())
count = 0
i = 1
while i ** 2 <= n:
	if n % i == 0 and i <= size and (n // i <= size):
		if i != n // i:
			count += 2
		else:
			count += 1
	i += 1
print(count)


(n, x) = map(int, input().split())
rez = 0
d = 1
while d * d <= x:
	if x % d == 0 and x != 1 and (x // d <= n):
		if x // d != d:
			rez += 2
		else:
			rez += 1
	elif x == 1:
		rez = 1
	d += 1
print(rez)


(r, n) = map(int, input().split())
a = 1
b = []
while a ** 2 <= n:
	if n % a == 0 and n // a <= r:
		b.append(a)
		if n // a != a:
			b.append(n // a)
	a += 1
	if a > r:
		a = a + n
print(len(b))


(a, b) = map(int, input().split())
i = 1
count = 0
while i <= b ** 0.5:
	if b % i == 0:
		if b == 1:
			count += 1
		elif b // i <= a:
			if i == b ** 0.5:
				count += 1
			else:
				count += 2
	i += 1
print(count)


(n, x) = list(map(int, input().split()))
count = 0
for i in range(1, n + 1):
	if x % i == 0:
		if x // i <= n:
			count += 1
print(count)


(N, X) = map(int, input().split())
count = 0
for i in range(1, N + 1):
	if X % i == 0 and X // i <= N:
		count += 1
print(count)


(x, y) = list(map(int, input().split()))
a = 0
for i in range(1, x + 1):
	if y % i == 0 and y / i <= x:
		a += 1
print(a)


from math import sqrt
line = input().split()
n = int(line[0])
x = int(line[1])
factors = []
for i in range(1, n + 1):
	if x % i == 0:
		div = int(x / i)
		if div <= n:
			factors.append(i)
			factors.append(div)
print(len(set(factors)))


import sys
numlines = 1
total = 0
for line in sys.stdin:
	(n, x) = line.split(' ')
	for i in range(1, int(n) + 1):
		if int(x) % i == 0 and int(x) / i <= int(n):
			total += 1
	numlines -= 1
	if numlines == 0:
		break
print(total)


import math
(n, x) = map(int, input().split())
prime = set()
for i in range(1, int(math.sqrt(x) + 1)):
	if x % i == 0:
		prime.add(i)
		prime.add(x // i)
tmp = 0
for num in list(prime):
	if num > n:
		tmp += 1
print(max(0, len(prime) - 2 * tmp))


import math
(n, x) = input().split()
(n, x) = (int(n), int(x))
ans = 0
for i in range(1, min(n, int(math.sqrt(x))) + 1):
	if i * i > x:
		continue
	elif i * i == x:
		ans += 1
	elif x % i == 0 and x // i <= n:
		ans += 2
print(ans)


(n, x) = (int(x) for x in input().split())
q = 0
for i in range(1, min(n, x) + 1):
	if x % i == 0:
		if x // i <= n:
			q += 1
print(q)


(a, b) = input().split()
a = int(a)
b = int(b)
cnt = 0
for i in range(1, a + 1):
	if i > b:
		break
	if b % i == 0 and b <= i * a:
		cnt += 1
print(cnt)


(n, x) = map(int, input().split())
s = 0
for i in range(1, n + 1):
	if i * i > x:
		break
	if not x % i:
		q = x // i
		if q <= n:
			s += 1
			if i != q:
				s += 1
print(s)


(n, x) = map(int, input().split())
factor = []
times = 0
for i in range(1, int(x ** 0.5) + 1):
	if x % i == 0:
		factor.append([i, x // i])
		factor.append([x // i, i])
		if x // i == i:
			factor.remove([i, i])
for i in factor:
	if i[0] <= n and i[1] <= n:
		times = times + 1
print(times)


(n, x) = map(int, input().split())
ans = 0
for i in range(1, int(x ** 0.5 + 1)):
	if x % i == 0 and i <= n and (x // i <= n):
		ans += 1 if i == x // i else 2
print(ans)


def table(n, k):
	c = 0
	for i in range(1, n + 1):
		tp = k / i
		if tp.is_integer() and tp <= n:
			c += 1
			if k / i < 1:
				break
	print(c)
a = list(map(int, input('').split()))
table(a[0], a[1])


from typing import List

def parse_input() -> List[int]:
	return [int(x) for x in input().split()]

def solve(n: int, x: int) -> int:
	factors = []
	bound = n + 1
	answer = 0
	for factor in range(1, bound):
		if x % factor == 0 and x / factor < bound:
			answer += 1
	return answer
(n, x) = parse_input()
print(solve(n, x))


def main():
	count = 0
	(n, x) = map(int, input().split())
	for i in range(1, n + 1):
		if x % i == 0:
			if x // i <= n:
				count += 1
	print(count)
main()


y = input().split()
n = int(y[0])
x = int(y[1])
count = 0
i = 1
while i <= n:
	if x % i == 0 and i * n >= x:
		count += 1
	i += 1
print(count)


k = input()
s = k.split()
n = int(s[0])
x = int(s[1])
summ = 0
if n < x:
	for i in range(2, n + 1):
		if x % i == 0 and x / i <= n:
			summ = summ + 1
else:
	for i in range(1, n + 1):
		if x % i == 0 and x / i <= n:
			summ = summ + 1
print(summ)


(n1, x1) = input().split()
n = int(n1)
x = int(x1)
s = 0
if n > x:
	for i in range(1, x + 1):
		if x % i == 0:
			s += 1
else:
	for i in range(1, n + 1):
		if x % i == 0 and x / i <= n:
			s += 1
print(s)


import math
s = input().split(' ')
n = int(s[0])
m = int(s[1])
sqr = int(math.ceil(math.sqrt(m)))
ans = 0
for i in range(1, sqr + 1):
	if m % i == 0:
		r = m // i
		if i <= n and r <= n and (i <= r):
			if i == r:
				ans += 1
			else:
				ans += 2
print(ans)


(n, x) = map(int, input().split())
s = int(x ** 0.5)
while s ** 2 < x:
	s += 1
print(sum([x % i == 0 and x // i <= n for i in range(1, s)]) * 2 + (s ** 2 == x) * (s <= n))


import math
(n, x) = map(int, input().split())
cnt = 0
for i in range(1, int(math.sqrt(x)) + 1):
	if x % i == 0:
		if i == x // i:
			if i <= n:
				cnt += 1
		elif x // i <= n:
			cnt += 2
print(cnt)


def binser(r, n, left, right):
	ada = False
	while left <= right:
		m = (left + right) // 2
		if m * r == n:
			ada = True
			break
		elif m * r < n:
			left = m + 1
		else:
			right = m - 1
	return ada
(r, n) = map(int, input().split())
col = r
c = r
answer = 0
for i in range(1, r + 1):
	if binser(i, n, 1, col):
		answer += 1
print(answer)


(n, k) = map(int, input().split())
count = 0
for i in range(1, n + 1):
	if k % i == 0 and int(k / i) <= n:
		count += 1
print(count)


(n, x) = map(int, input().split())
check = n + 1
ans = 0
ran = min(int(x ** 0.5 + 1), check)
for i in range(1, ran):
	if x % i == 0:
		if x // i == i and i <= n:
			ans += 1
		elif x // i != i and i <= n and (x // i <= n):
			ans += 2
print(ans)


import math
(n, x) = map(int, input().split())
ans = 0
for i in range(1, min(math.ceil(x ** 0.5), n)):
	if not x % i and x // i <= n:
		ans += 2
if math.ceil(x ** 0.5) == x ** 0.5 and x ** 0.5 <= n:
	ans += 1
print(ans)


(n, k) = map(int, input().split())
c = 0
for i in range(1, n + 1):
	if k % i == 0 and k // i <= n:
		c = c + 1
	if i > k:
		break
print(c)


(n, x) = input().split(' ')
n = int(n)
x = int(x)
count = 0

def factor_count(x):
	count = 0
	for i in range(1, x + 1):
		if x % i == 0:
			count += 1
	return count

def factor_count_constrained(x, n):
	count = 0
	for i in range(1, n + 1):
		if x % i == 0 and x / i <= n:
			count += 1
	return count
if n > x:
	print(factor_count(x))
else:
	print(factor_count_constrained(x, n))


import math
(n, x) = map(int, input().split())
visited = [False for _ in range(n + 1)]
target_divisor = 0
for i in range(1, n + 1):
	if x % i == 0 and x // i <= n and (visited[i] == False) and (visited[x // i] == False):
		if i != x // i:
			target_divisor += 2
			visited[i] = visited[x // i] = True
		else:
			target_divisor += 1
			visited[i] = True
print(target_divisor)


(k, x) = map(int, input().split())
m = 0
for i in range(1, k + 1):
	if x % i == 0:
		if x / i <= k:
			m += 1
print(m)


w = input().split()
n = int(w[0])
x = int(w[1])
(c, i) = (0, 1)
while i <= n:
	if x % i == 0 and i * n >= x:
		c += 1
	i += 1
print(c)


(n, x) = map(int, input().split())
ans = 0
for d in range(1, int(x ** 0.5) + 1):
	if x % d != 0:
		continue
	(a, b) = (d, x // d)
	if a <= n and b <= n:
		if a == b:
			ans += 1
		else:
			ans += 2
print(ans)


row = input().split()
n = int(row[0])
x = int(row[1])
found = 0
for i in range(1, n + 1):
	if x % i == 0:
		if x / i <= n:
			found += 1
print(found)


(a, b) = map(int, input().split())
i = 1
q = []
while i <= b ** 0.5:
	if b % i == 0:
		q = q + [i] + [b // i]
	if i == b ** 0.5:
		q.remove(i)
	i += 1
q.sort()
while q[-1] > a:
	q = q[1:-1]
	if len(q) == 0:
		break
print(len(q))


import math
ar = []
for i in input().split(' '):
	ar.append(int(i))
n = ar[0]
x = ar[1]
a = math.ceil(pow(x, 0.5)) + 1
count = 0
visited = set()
for i in range(1, a + 1):
	if i > n:
		break
	if x % i == 0 and x / i <= n:
		if int(min(i, x / i)) in visited:
			continue
		if i != int(x / i):
			count = count + 2
			visited.add(int(min(i, x / i)))
		else:
			count = count + 1
			visited.add(int(min(i, x / i)))
print(count)


(n, m) = map(int, input().split())
ans = 0
for i in range(1, min(n, int(m ** 0.5)) + 1):
	if m % i == 0 and m // i == i:
		ans += 1
		break
	if m % i == 0 and m // i <= n:
		ans += 2
print(ans)


(n, x) = list(map(int, input().split()))
p = 0
for i in range(1, n + 1):
	if x % i == 0:
		k = x // i
		if k > n:
			continue
		p += 1
print(p)


(n, x) = map(int, input().split())
a = [i for i in range(1, n + 1)]
a2 = [i ** 2 for i in range(1, n + 1)]
ans = 0
if x > n * n:
	print(0)
	exit()
elif x in a2:
	for i in range(1, int(x ** 0.5) + 1):
		if x % i == 0:
			if i in a and x // i <= n:
				ans += 1
	print(2 * ans - 1)
else:
	for i in range(1, int(x ** 0.5) + 1):
		if x % i == 0:
			if i in a and x // i <= n:
				ans += 1
	print(2 * ans)


from sys import stdin, stdout
(n, m) = map(int, stdin.readline().rstrip().split())
count = 0
for x in range(1, n + 1):
	if m % x == 0 and m // x <= n:
		count += 1
stdout.write(str(count))


(n, x) = map(int, input().split())
a = []
i = 1
while i ** 2 <= x:
	if x % i == 0:
		a.append([i, x // i])
	i += 1
summ = 0
for i in range(len(a)):
	if a[i][0] <= n and a[i][1] <= n:
		if a[i][0] == a[i][1]:
			summ += 1
		else:
			summ += 2
print(summ)


(r, n) = map(int, input().split())
table = []
count = 0
for i in range(1, r + 1):
	if n % i == 0 and n // i <= r:
		count += 1
print(count)


(x, y) = map(int, input().split())
count = 0
for i in range(1, int(y ** 0.5) + 1):
	if y % i == 0:
		if y // i == i:
			if i <= x and i * x >= y:
				count += 1
		else:
			if i <= x and i * x >= y:
				count += 1
			if y // i <= x and y // i * x >= y:
				count += 1
print(count)


z = 0
(x, y) = map(int, input().split())
for q in range(1, x + 1):
	if y % q == 0 and y / q <= x:
		z += 1
print(z)


(n, x) = map(int, input().split())
s = 0
p = set()
r = 0
for i in range(1, min((x + 1) // 2, n) + 1):
	if x % i == 0:
		if x // i <= n and x // i not in p:
			p.add(i)
			if i == x // i:
				r = 1
			else:
				s += 1
print(s * 2 + r)


from sys import stdin, stdout
from collections import Counter

def ai():
	return list(map(int, stdin.readline().split()))

def ei():
	return map(int, stdin.readline().split())

def ip():
	return int(stdin.readline().strip())

def op(ans):
	return stdout.write(str(ans) + '\n')
(n, x) = ei()
ans = 0
for i in range(1, n + 1):
	if x <= i * n and x % i == 0:
		ans += 1
op(ans)


(n, k) = [int(x) for x in input().split()]
counter = 0
b = int(k ** 0.5)

def is_prime(k):
	if k == 2 or k == 3 or k == 5:
		return True
	for d in range(2, b + 1):
		if b % d == 0:
			return False
	return True
if k == 1:
	print('1')
	exit()
elif is_prime(k):
	if k <= n:
		print('2')
		exit()
	else:
		print('0')
		exit()
for i in range(1, b + 1):
	if k % i == 0:
		x = i
		y = k // i
		if x == y:
			if x <= n:
				counter += 1
				break
		if x <= n and y <= n:
			counter += 2
print(counter)


def code(n, x):
	count = 0
	if x == 1:
		return 1
	for i in range(1, n + 1):
		if i == 1 and n >= x:
			count += 1
		elif x % i == 0 and i != 1 and (x <= n * i):
			count += 1
	return count
st = input()
(n, x) = st.split()
(n, x) = (int(n), int(x))
ch = code(n, x)
print(ch)


(n, x) = list(map(int, input().split()))
stop = x ** 0.5
m = 0
for i in range(1, int(stop) + 1):
	if x % i == 0 and i <= n and (x // i <= n):
		if i == x // i:
			m += 1
		else:
			m += 2
print(m)


p = input()
p = p.split()
n = int(p[0])
x = int(p[1])
c = 0
a = min(n, x)
for i in range(1, a + 1):
	if x % i == 0 and x // i <= n:
		c += 1
print(c)


(n, x) = list(map(int, input().split()))
result = 0
for j in range(1, n + 1):
	if 0 < x // j <= n and x // j * j == x:
		result += 1
print(result)


(n, x) = [int(a) for a in input().split()]
ans = 0
if x ** 0.5 > n:
	print(0)
else:
	for t in range(1, int(x ** 0.5) + 1):
		if x % t == 0 and x // t in range(1, n + 1) and (x // t != t):
			ans += 2
		elif x % t == 0 and x // t == t:
			ans += 1
	print(ans)


import sys
import math
import bisect

def main():
	ans = 0
	(n, x) = map(int, input().split())
	for i in range(1, math.floor(math.sqrt(x)) + 1):
		if x % i == 0:
			j = x // i
			if i < j and i <= n and (j <= n):
				ans += 2
			if i == j and i <= n and (j <= n):
				ans += 1
	print(ans)
main()


import sys
(mod, MOD) = (1000000007, 998244353)
from collections import deque, Counter, OrderedDict, defaultdict
from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd, log10, atan, tan

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()

def all_factors(n):
	(small, large) = ([], [])
	for i in range(1, int(n ** 0.5) + 1, 2 if n & 1 else 1):
		if not n % i:
			small.append(i)
			large.append(n // i)
	if small[-1] == large[-1]:
		large.pop()
	large.reverse()
	small.extend(large)
	return small
(n, q) = get_ints()
lst = all_factors(q)
count = 0
for i in range(len(lst)):
	x = lst[i]
	y = lst[len(lst) - i - 1]
	if x <= n and y <= n:
		count += 1
print(count)


def Main():
	(n, x) = map(int, input().split())
	ans = 0
	for i in range(1, n + 1):
		if x % i == 0 and x / i <= n:
			ans += 1
	print(ans)
Main()


n = list(map(int, input().split()))
b = 0
for i in range(1, n[0] + 1):
	if n[-1] % i == 0:
		if n[-1] / i <= n[0]:
			b += 1
print(b)


from sys import stdin as inp
(n, x) = map(int, inp.readline().split())
total = 0
for i in range(1, min(n, int(x ** 0.5)) + 1):
	if x % i == 0 and x / i <= n and (x / i != i):
		total += 2
	elif x / i == i:
		total += 1
print(total)


a = input().split(' ')
b = int(a[1])
n = int(a[0])
c = 0
for i in range(n):
	if b % (i + 1) == 0 and b / (i + 1) <= n:
		c += 1
print(c)


import math
(n, x) = map(int, input().split())
if x == 1:
	cnt = 1
else:
	cnt = 0
	for i in range(1, min(n, int(math.sqrt(x))) + 1):
		if x % i == 0 and x / i <= n:
			if x / i == i:
				cnt += 1
			else:
				cnt += 2
print(cnt)


(n, x) = map(int, input().split())
import math
s = 0
if x ** 0.5 == math.ceil(x ** 0.5):
	up = int(math.ceil(x ** 0.5)) + 1
else:
	up = int(math.ceil(x ** 0.5))
for i in range(1, up):
	if x % i == 0 and x // i <= n:
		s += 1
print(s * 2 - 1 if x ** 0.5 == math.ceil(x ** 0.5) and x <= n ** 2 else s * 2)


def number(n, x):
	col = 1
	ans = 0
	while col <= n:
		if x % col == 0 and x // col <= n:
			ans += 1
		col += 1
	return ans
(n, x) = list(map(int, input().rstrip().split()))
print(number(n, x))


(rij, wil) = map(int, input().split())
count = 0
if rij >= wil:
	for i in range(1, wil + 1):
		if int(wil / int(i)) == wil / int(i) and wil <= rij * int(i):
			count += 1
else:
	for i in range(2, rij + 1):
		if int(wil / int(i)) == wil / int(i) and wil <= rij * int(i):
			count += 1
print(count)


(n, x) = map(int, input().split())
counter = 0
for i in range(1, int(x ** 0.5) + 1):
	if x % i == 0 and x // i <= n:
		if x // i == i:
			counter += 1
			continue
		counter += 2
print(counter)


(n, x) = map(int, input().split())
occur = 0
for i in range(1, n + 1):
	if x % i == 0 and i * n >= x:
		occur += 1
		continue
print(occur)


(n, x) = [int(x) for x in input().split()]
c = 0
for t in range(n):
	if x % (t + 1) == 0 and x / (t + 1) <= n:
		c += 1
print(c)


(n, x) = map(int, input().split())
k = 1
ans = 0
while k <= n:
	g = x // k
	if x % k == 0 and g <= n:
		ans += 1
	k += 1
print(ans)


(n, x) = input().split(' ')
n = int(n)
x = int(x)
aux = 0
for y in range(1, n + 1):
	if y * n >= x:
		if x % y == 0:
			aux += 1
print(aux, end='')


(a, b) = map(int, input().split())
count = []
for i in range(1, a + 1):
	if b % i == 0 and b // i <= a:
		count.append(i)
print(len(count))


(n, m) = [int(i) for i in input().split()]
result = 0
for i in range(1, n + 1):
	if m % i == 0 and m / i <= n:
		result += 1
print(result)


s = input()
s = s.split()
(n, x, c) = (int(s[0]), int(s[1]), 0)
t = min(n, x)
for i in range(1, t + 1, 1):
	if x % i == 0 and i <= n and (x / i <= n):
		c += 1
print(c)


import sys, math
(n, x) = map(int, input().split())
divisor = []
limit = int(math.sqrt(x) + 2)
for i in range(1, limit):
	if x % i == 0:
		if i not in divisor:
			divisor.append(i)
		if int(x / i) not in divisor:
			divisor.append(int(x / i))
c = 0
for i in divisor:
	if x / i <= n and i <= n:
		c += 1
print(c)


(n, x) = list(map(int, input().split()))
out = 0
for i in range(1, min(n, x) + 1):
	if x % i == 0 and x / i <= n:
		out += 1
print(out)


(n, x) = map(int, input().split())
ans = 0
for i in range(min(int(x ** 0.5), n)):
	if x % (i + 1) == 0 and n >= x / (i + 1):
		ans += 1
		ans += int(not int(x / (i + 1)) == i + 1)
print(ans)


(n, x) = (int(x) for x in input().split())
print([x % i == 0 and x // i <= n for i in range(1, n + 1)].count(True))


import math
nx = list(map(int, input().strip().split()))
total = 0
for lol in range(1, int(math.sqrt(nx[1]) + 1)):
	if nx[1] % lol == 0 and nx[1] / lol <= nx[0]:
		k = 0
		if lol == nx[1] / lol:
			k = 1
		total += 2 - k
print(total)


import math
(n, x) = map(int, input().split(' '))
limit = int(math.sqrt(x)) + 1
res = 0
for div in range(1, limit):
	if x % div == 0 and div <= n and (x // div <= n):
		res += 2
if int(math.sqrt(x)) == math.sqrt(x) and math.sqrt(x) <= n:
	res -= 1
print(res)


(n, x) = [int(a) for a in input().split()]
counter = 0
for i in range(1, n + 1):
	if x % i == 0 and x // i <= n:
		counter += 1
print(counter)


import math

def inp():
	return int(input())

def inlist():
	return list(map(int, input().split()))

def instr():
	s = input()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())
(n, x) = invr()
l = int(math.sqrt(x + 1))
res = 0
for i in range(1, l + 1):
	if x % i == 0:
		d1 = i
		d2 = x // i
		if d1 <= n and d2 <= n:
			if d1 != d2:
				res += 2
			else:
				res += 1
print(res)


import math
(n, x) = [int(x) for x in input().split()]
s = 0
if n < x <= n ** 2:
	for i in range(math.ceil(x / n), n + 1):
		if x % i == 0:
			s += 1
if x <= n:
	for i in range(1, x + 1):
		if x % i == 0:
			s += 1
print(s)


(n, m) = map(int, input().split(' '))
L = []
cont = 0
for k in range(1, n + 1):
	if m % k == 0 and m // k <= n:
		cont += 1
print(cont)


nk = list(map(int, input().split(' ')))
n = nk[0]
k = nk[1]
ct = 0
for i in range(1, n + 1):
	if k % i == 0 and (k // i >= 1 and k // i <= n):
		ct += 1
if ct == 0:
	print(0)
else:
	print(ct)


(m, n) = map(int, input().split())
a = []
i = 1
while i ** 2 <= n:
	if n % i == 0 and n // i <= m:
		a.append(i)
		if n // i != i:
			a.append(n // i)
	i = i + 1
a.sort()
print(len(a))


import math
(n, x) = map(int, input().split())
count = 0
a = math.sqrt(x)
if n < int(math.sqrt(x)):
	print(0)
elif int(a) == a:
	for i in range(1, int(a)):
		if x % i == 0 and x / i <= n:
			count += 1
	print(2 * count + 1)
else:
	for i in range(1, int(a) + 1):
		if x % i == 0 and x / i <= n:
			count += 1
	print(2 * count)


(n, x) = [int(s) for s in input().split(' ')]
ans = 0
for i in range(1, n + 1):
	if x % i == 0 and x // i <= n:
		ans += 1
print(ans)


from functools import reduce
from math import sqrt, floor

def findFactors(n):
	return list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))
(n, x) = map(int, input().split())
fac = sorted(findFactors(x))
final_fac = []
i = 0
j = len(fac) - 1
while i < j:
	if fac[j] <= n:
		final_fac.append(fac[i])
		final_fac.append(fac[j])
	j -= 1
	i += 1
c = len(final_fac)
if sqrt(x) - floor(sqrt(x)) == 0 and int(sqrt(x)) <= n:
	c += 1
print(c)


def finder(n, x):
	m = 0
	for i in range(1, n + 1):
		if x % i == 0:
			if x / i <= n:
				m += 1
	return m
inp = input().split(' ')
print(finder(int(inp[0]), int(inp[1])))


(n, k) = input().strip().split()
(n, k) = (int(n), int(k))
i = 1
a = k ** 0.5
ans = 0
while i < a:
	if k % i == 0 and k // i <= n:
		ans += 2
	i += 1
if int(k ** 0.5) == k ** 0.5 and k ** 0.5 <= n:
	ans += 1
print(ans)


import sys
from bisect import *
from math import floor, sqrt, ceil, factorial as F, gcd, pi
from itertools import chain, combinations, permutations, accumulate
from collections import Counter, defaultdict, OrderedDict, deque
from array import array
INT_MAX = sys.maxsize
INT_MIN = -sys.maxsize - 1
mod = 1000000007
ch = 'abcdefghijklmnopqrstuvwxyz'
lcm = lambda a, b: a * b // gcd(a, b)
setbit = lambda x: bin(x)[2:].count('1')
input = lambda : sys.stdin.readline()

def solve():
	(n, x) = map(int, input().split())
	(si, db) = (0, 0)
	for i in range(1, int(sqrt(x)) + 1):
		if x % i == 0:
			if i == x // i:
				if i <= n:
					si += 1
			elif i * (x // i) == x and i <= n and (x // i <= n):
				db += 1
	print(si + db * 2)
solve()


(n, x) = map(int, input().split())
count = 0
i = 1
a = []
R = 0
if n ** 2 >= x:
	while i not in a and i <= n:
		if x % i == 0:
			a.append(i)
			if i <= n and x // i <= n:
				if x / i == i:
					R += 1
				else:
					R += 2
					a.append(x // i)
		i += 1
print(R)


(a, b) = map(int, input().split())
l = [1]
for i in range(2, a + 1):
	if b % i == 0:
		l.append(i)
s = 0
for i in l:
	if i <= a and b // i <= a:
		s += 1
print(s)


import math as m
(n, x) = map(int, input().split())
factors = []
p = 1
mm = x
while p <= int(m.sqrt(mm)) + 1:
	if mm % p == 0:
		factors.append(p)
		factors.append(mm // p)
	p += 1
factors = list(set(factors))
mul = 1
ans = 0
for i in factors:
	if i <= n and mm // i <= n:
		ans += 1
print(ans)


(a, b) = [int(i) for i in input().split()]
li = []
(i, c) = (1, 0)
while i <= b / i:
	if b % i == 0 and b / i <= a:
		if b / i == i:
			c = -1
		li.append(i)
	i += 1
print(len(li) * 2 + c)


from sys import stdin, exit
(n, x) = map(int, stdin.readline().rstrip().split(' '))
t = 0
for i in range(1, n + 1):
	if x % i == 0 and i * n >= x:
		t += 1
print(t)


(n, x) = map(int, input().split())
i = 1
lst = []
count = 0
while i * i <= x:
	if x % i == 0:
		lst.append(i)
		if i != x // i:
			lst.append(x // i)
	i += 1
for j in lst:
	if j * n >= x and j <= n:
		count += 1
print(count)


from math import sqrt
(n, m) = map(int, input().split())
s = 0
f = int(sqrt(m))
if f < n:
	for i in range(f):
		if (i + 1) ** 2 == m:
			s += 1
		elif m % (i + 1) == 0 and m // (i + 1) <= n:
			s += 2
else:
	for i in range(n):
		if m % (i + 1) == 0 and m // (i + 1) <= n:
			s += 1
print(s)


(n, numb) = map(int, input().split())
if numb > n * n:
	print(0)
	exit()
flag = False
if n >= numb:
	n = numb
	flag = True
k = n
count = 0
while k != 1:
	if numb // k <= n and numb % k == 0:
		count += 1
	k -= 1
if flag:
	count += 1
print(count)


(n, x) = map(int, input().split())
kol = 0
for i in range(1, min(n, x) + 1):
	if x % i == 0 and x // i <= n:
		kol += 1
print(kol)


import math
s = input().split()
n = int(s[0])
x = int(s[1])
end = int(math.sqrt(x))
count = 0
for i in range(1, end + 1):
	if x % i == 0:
		if i <= n and x / i <= n:
			if i * i == x:
				count += 1
			else:
				count += 2
print(count)


(a, s) = map(int, input().split())
p = 0
for u in range(1, a + 1):
	if s % u == 0 and s / u <= a:
		p = p + 1
print(p)


from sys import stdin
(n, x) = map(int, stdin.readline().rstrip().split())
c = 0
for a in range(1, min(x, n) + 1):
	if not x % a:
		if x // a <= n:
			c += 1
print(c)


numbers = list(map(int, input().split()))
n = numbers[0]
m = numbers[1]
count = 0
Factors = [i for i in range(1, min(m, n) + 1) if m % i == 0]
for i in Factors:
	for j in Factors:
		if i * j == m:
			count += 1
print(count)


(n, x) = list(map(int, input().split()))
import math
l = 0
if math.ceil(x ** 0.5) != math.floor(x ** 0.5):
	for i in range(1, math.ceil(x ** 0.5)):
		if i * (x // i) == x:
			if i <= n and x // i <= n:
				l = l + 2
if math.ceil(x ** 0.5) == math.floor(x ** 0.5):
	for i in range(1, math.ceil(x ** 0.5) + 1):
		if i * (x // i) == x:
			if i <= n and x // i <= n and (i != x // i):
				l = l + 2
			if i <= n and x // i <= n and (i == x // i):
				l = l + 1
print(l)


(n, x) = [int(x) for x in input().split()]
l = list()
m = min(x + 1, n + 1)
for i in range(1, m):
	if x % i == 0 and i <= n and (x // i <= n):
		l.append(i)
print(len(l))


import math

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True
(n, x) = map(int, input().split())
if x == 1:
	print(1)
elif prime(x) and x <= n:
	print(2)
elif prime(x) and x > n:
	print(0)
else:
	ans = 0
	for i in range(n):
		if x % (i + 1) == 0 and x // (i + 1) <= n:
			ans += 1
	print(ans)


(n, x) = map(int, input().split())
cnt = 0
from math import sqrt
for i in range(1, int(sqrt(x)) + 1):
	j = x // i
	if i * j == x and i <= n and (j <= n):
		cnt += 1
		if i != j:
			cnt += 1
print(cnt)


def solve(n, x):
	s = 0
	for i in range(1, n + 1):
		(d, m) = divmod(x, i)
		if m == 0 and d <= n:
			s += 1
	return s

def main(infile, outfile):
	(n, x) = map(int, infile.readline().split())
	outfile.write(str(solve(n, x)) + '\n')
from sys import stdin, stdout
main(stdin, stdout)


(size_of_table, num_to_search) = [int(a) for a in input().strip().split()]
counter = 0
for row in range(1, size_of_table + 1):
	if num_to_search % row == 0:
		if num_to_search / row <= size_of_table:
			counter += 1
print(counter)


(n, x) = map(int, input().split())
(i, l) = (1, [])
while i * i <= x:
	if x % i == 0 and x // i <= n:
		l.append(i)
		if i != x // i:
			l.append(x // i)
	i += 1
l.sort()
print(len(l))


(n, x) = map(int, input().split())
cnt = 0
nmin = min(n, x)
for i in range(1, nmin + 1):
	if x % i == 0 and x // i <= n and (x // i > 0):
		cnt += 1
print(cnt)


(n, x) = map(int, input().split())
n += 1
ex = 0
i = 1
inc = 1
if x % 2 != 0:
	inc = 2
for i in range(1, n, inc):
	if x % i == 0 and x / i < n:
		ex += 1
print(ex)


import math
(n, x) = map(int, input().split())
ans = 0
for i in range(1, n + 1):
	if x % i == 0:
		if x / i <= n:
			ans += 1
print(ans)


(n, x) = map(int, input().split())
l = [i for i in range(1, n + 1)]
co = 0
for i in range(1, n + 1):
	if x % i == 0 and x // i in l:
		co += 1
print(co)


import math
s = input().split()
n = int(s[0])
x = int(s[1])
dem = 0
if n > math.trunc(math.sqrt(x)):
	m = int(math.trunc(math.sqrt(x)))
else:
	m = n
for i in range(1, m + 1):
	if x % i == 0:
		if x / i <= n and i <= n and (x / i != i):
			dem += 2
		elif x / i == i:
			dem += 1
print(dem)


import math

def factors(x):
	result = set()
	for y in range(1, int(math.sqrt(x)) + 1):
		if not x % y:
			result.add(y)
			result.add(x // y)
	return list(result)

class CodeforcesTask577ASolution:

	def __init__(self):
		self.result = ''
		self.n_x = []

	def read_input(self):
		self.n_x = [int(x) for x in input().split(' ')]

	def process_task(self):
		in_table = 0
		num_factors = factors(self.n_x[1])
		for fac in num_factors:
			if fac <= self.n_x[0] and self.n_x[1] // fac <= self.n_x[0]:
				in_table += 1
		self.result = str(in_table)

	def get_result(self):
		return self.result
Solution = CodeforcesTask577ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


X = list(map(int, input().split()))
Divisible = 0
for i in range(1, min(X) + 1):
	Divisible += 1 if X[1] % i == 0 and X[1] // i <= X[0] else 0
print(Divisible)


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

def sum_occurence(n, x):
	num_occur = 0
	if x == 1:
		num_occur += 1
	elif n == x:
		for i in range(1, n + 1):
			if x % i == 0 and x / i <= n:
				num_occur += 1
	else:
		for i in range(2, n + 1):
			if x % i == 0 and x / i <= n:
				num_occur += 1
	if n > x and x != 1:
		num_occur += 1
	return num_occur
out = sum_occurence(n, x)
print(out)


(n, m) = map(int, input().split())
s = 0
k = 1
while k * k <= m:
	if m % k == 0:
		if k <= n and m // k <= n:
			s += 2
	k += 1
if m ** 0.5 == int(m ** 0.5):
	if m ** 0.5 <= n:
		s -= 1
print(s)


import sys
from random import choice, randint
inp = sys.stdin.readline
out = sys.stdout.write
flsh = sys.stdout.flush
sys.setrecursionlimit(10 ** 9)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def MI():
	return map(int, inp().strip().split())

def LI():
	return list(map(int, inp().strip().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]

def LI_():
	return [int(x) - 1 for x in inp().strip().split()]

def LF():
	return [float(x) for x in inp().strip().split()]

def LS():
	return inp().strip().split()

def I():
	return int(inp().strip())

def F():
	return float(inp().strip())

def S():
	return inp().strip()

def pf(s):
	return out(s + '\n')

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def main():
	(n, x) = MI()
	a = n
	c = 0
	while n > 0:
		if x % n == 0 and x // n <= a:
			c += 1
		n -= 1
	pf(str(c))
main()


from math import ceil
(n, a) = [int(x) for x in input().split()]
ch = 0
for i in range(1, n + 1):
	if i >= ceil(a ** 0.5):
		break
	if a % i == 0 and a // i <= n:
		ch += 2
if ceil(a ** 0.5) ** 2 == a and ceil(a ** 0.5) <= n:
	ch += 1
print(ch)


(n, x) = input().split()
n = int(n)
X = int(x)
if X > n ** 2:
	print(0)
else:
	fin = 0
	for x in range(n):
		v = X / (x + 1)
		fin += v.is_integer() and v <= n
	print(fin)


import itertools as it
import functools
import operator
import collections
import math
import sys

def solve(n, x):
	sqx = int(math.sqrt(x))
	lim = min(sqx, n)
	count = sum((2 for i in range(1, lim + 1) if x % i == 0 and x // i <= n))
	if sqx * sqx == x and sqx <= n:
		count -= 1
	return count

def print_stderr(*args, **kwargs):
	print(*args, file=sys.stderr, **kwargs)

def main():
	[n, x] = [int(i) for i in input().strip().split()]
	result = solve(n, x)
	print(result)
main()


(n, x) = map(int, input().split())
l1 = list((p for p in range(1, n + 1)))
ans = 0
for num in range(1, n + 1):
	if x % num == 0:
		if num in l1 and x // num in l1:
			ans += 1
print(ans)


import sys, math, string, bisect
input = sys.stdin.readline
from collections import deque
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
(n, x) = M()
p = 1
c = 0
while p < x ** 0.5:
	if x % p == 0:
		if p <= n and x // p <= n:
			c += 2
	p += 1
if x % x ** 0.5 == 0:
	if x ** 0.5 <= n:
		c += 1
print(c)


(Number, k) = map(int, input().split())
if k <= Number:
	res = 1
else:
	res = 0
for i in range(2, Number + 1):
	if i > k:
		break
	if k % i == 0:
		x = k / i
		if x <= Number:
			res = res + 1
print(res)


from math import sqrt, pow, log, log2, log10, exp
from copy import deepcopy

def read_ints():
	return list(map(int, input().split()))

def read_int():
	return read_ints()[0]

def read_floats():
	return list(map(float, input().split()))

def read_float():
	return read_floats()[0]

def one_dim_array(value, n):
	return [deepcopy(value) for x in range(n)]

def two_dim_array(value, n, m):
	return [[deepcopy(value) for x in range(m)] for x in range(n)]

def is_prime(n):
	if n == 2:
		return True
	if n % 2 == 0:
		return False
	for i in range(3, sqrt(n) + 1):
		if n % i == 0:
			return False
	return True

def tf_to_yn(b):
	return 'YES' if b else 'NO'
(n, x) = read_ints()
k = 0
for i in range(1, n + 1):
	(d, m) = divmod(x, i)
	if d <= n and m == 0:
		k += 1
print(k)


import sys, math, io, os, time, itertools, collections
mod = 10 ** 9 + 7
sys.setrecursionlimit(10000)
i = sys.stdin.readline
p = sys.stdout.write
global start, end

def isin(l, x):
	left = 0
	right = len(l) - 1
	if x < l[0]:
		return -1
	while left <= right:
		mid = left + (right - left) // 2
		if l[mid] == x:
			return mid
		elif l[mid] < x:
			ans = mid
			left = mid + 1
		else:
			right = mid - 1
	return ans

def ispal(l):
	n = len(l)
	for i in range(n // 2 + 1):
		if l[i] != l[n - i - 1]:
			return False
	return True

def ccarray(l):
	d = {l[k]: k for k in range(len(l))}
	m = sorted(d)
	return [d[m[k]] for k in range(len(l))]

def is_prime(n):
	if n <= 3:
		return n > 1
	if n % 2 == 0 or n % 3 == 0:
		return False
	k = 5
	while k ** 2 <= n:
		if n % k == 0 or n % (k + 2) == 0:
			return False
		k += 6
	return True

def sieve(n):
	prime = [True for k in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for k in range(p * p, n + 1, p):
				prime[k] = False
		p += 1

def main():
	(n, x) = [int(k) for k in i().split()]
	k = 1
	count = 0
	while k * k <= x:
		if x % k == 0:
			if x // k <= n:
				if x // k == k:
					count += 1
				else:
					count += 2
		k += 1
	p(str(count) + '\n')
t = 1
start = time.perf_counter()
for _ in range(t):
	main()
end = time.perf_counter()


import sys
input = sys.stdin.readline

def int_array():
	return list(map(int, input().strip().split()))

def str_array():
	return input().strip().split()

def lower_letters():
	lowercase = [chr(i) for i in range(97, 97 + 26)]
	return lowercase

def how_frequent(lis):
	last = None
	count = []
	each = 1
	for i in range(len(lis)):
		if last != None:
			last = lis[i - 1]
		if last == lis[i]:
			each += 1
		else:
			count.append(each)
			each = 0
		last = lis[i]
	return max(count)

def upper_letters():
	uppercase = [chr(i) for i in range(65, 65 + 26)]
	return uppercase
(n, x) = int_array()
count = 0
for i in range(1, n + 1):
	if x % i == 0 and x // i <= n:
		count += 1
print(count)


num = [int(n) for n in input().split()]
count = 0
for i in range(1, num[0] + 1):
	if num[1] % i == 0 and num[1] / i <= num[0]:
		count = count + 1
print(count)


import math
(n, x) = [int(x) for x in input().split()]
if x > pow(n, 2):
	print(0)
	exit()
if x == 1:
	print(1)
	exit()
k = 0
max_i = min(int(math.sqrt(x)) + 1, n + 1)
for i in range(1, max_i):
	if x % i == 0 and x // i <= n:
		if x // i == i:
			k += 1
		else:
			k += 2
print(k)


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
(n, x) = map(int, input().split())
if x == 1:
	print(1)
else:
	ans = 0
	for a in range(1, n + 1):
		if x % a == 0 and x // a <= n:
			ans += 1
	print(ans)


def multiplicationTable(a, b):
	res = [1 for i in range(1, a + 1) if b % i == 0 and b / i <= a]
	return sum(res)
(a, b) = map(int, input().split())
print(multiplicationTable(a, b))


def multiplication_table(number1, number2):
	count = 0
	for value in range(1, number1 + 1):
		if number2 % value == 0 and number2 // value <= n:
			count += 1
	return count
(n, x) = map(int, input().split())
print(multiplication_table(n, x))


k = input().split()
n = int(k[0])
x = int(k[1])
no = 0
m = n * n
if x == 1 or x == m:
	no += 1
else:
	for i in range(1, int(pow(x, 0.5)) + 1):
		if i > n:
			break
		if x % i == 0:
			k = x // i
			if k <= n and k != i:
				no += 2
			elif k <= n and k == i:
				no += 1
print(no)


(n, x) = map(int, input().split())
ans = 0
for i in range(1, x + 1):
	if i > n:
		break
	if x % i == 0 and x // i <= n:
		ans += 1
print(ans)


from math import *

def divisors(n):
	i = 1
	l = []
	while i <= sqrt(n):
		if n % i == 0:
			if n / i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
		i = i + 1
	return l
(n, x) = map(int, input().split())
if x == 1:
	print(1)
elif x == n ** 2:
	print(1)
else:
	l = divisors(x)
	if len(l) % 2 == 1:
		l.insert(len(l), l[len(l) - 1])
	c = 0
	for i in range(0, len(l), 2):
		if l[i] <= n and l[i + 1] <= n:
			if l[i] == l[i + 1]:
				c += 1
			else:
				c += 2
	print(c)


__author__ = 'suvasish'
inp = list(map(int, input().split(' ')))
count = 0
num = inp[1]
for i in range(1, inp[0] + 1):
	if num % i == 0 and num // i <= inp[0]:
		count += 1
print(count)


(n, x) = [int(x) for x in input().strip().split()]

def getFactor(num):
	factors = set()
	for i in range(1, int(num ** 0.5) + 1):
		if num % i == 0:
			if i in range(1, n + 1) and num // i in range(1, n + 1):
				factors.add(i)
				factors.add(num // i)
	return factors
factors = getFactor(x)
print(len(factors))


a = list(map(int, input().split()))
d = 0
for r in range(1, a[0] + 1):
	if a[1] % r == 0 and a[0] * r >= a[1]:
		d += 1
print(d)


(size, x) = map(int, input().split())
elim = 1
numbers = []
while elim ** 2 <= x:
	if x % elim == 0:
		numbers.append(elim)
		if x % (x // elim) == 0 and x // elim != elim:
			numbers.append(x // elim)
	elim += 1
numbers = [n for n in numbers if x // n <= size and n <= size]
print(len(numbers))


def prime_factors(n):
	i = 2
	factors = []
	if n > 1:
		factors.append((1, n))
	while i * i <= n:
		if n % i:
			i += 1
		else:
			factors.append((i, n // i))
			i += 1
	return factors
args = [int(x) for x in input().split(' ')]
n = args[0]
x = args[1]
if x == 1:
	print('1')
elif x > n ** 2:
	print('0')
else:
	factors = prime_factors(x)
	occ = 0
	for f in factors:
		if f[0] <= n and f[1] <= n:
			if f[0] == f[1]:
				occ += 1
			else:
				occ += 2
	print(occ)


(n, x) = map(int, input().split())
counter = 0
for i in range(1, n + 1):
	if x // i <= i:
		if x // i == i:
			if x / i - x // i == 0:
				counter += 1
			break
		else:
			break
	if x % i is 0:
		if x // i <= n:
			counter += 2
print(counter)


def multiplication_table(number1, number2):
	count = 0
	value = 1
	while value <= number2 ** 0.5:
		if number2 % value == 0 and value <= n and (number2 // value <= n):
			if value != number2 // value:
				count += 2
			else:
				count += 1
		value += 1
	return count
(n, x) = map(int, input().split())
print(multiplication_table(n, x))


import math
(n, x) = [int(i) for i in input().split()]
c = 0
if x == 1:
	print(1)
else:
	for i in range(1, int(math.sqrt(x)) + 1):
		if x % i == 0 and int(x / i) <= n:
			if i == math.sqrt(x):
				c += 1
			else:
				c += 2
	print(c)


(n, x) = [int(i) for i in input().split()]
lst = []
i = 1
while i <= int(x ** 0.5) and i <= n:
	if x % i == 0 and x // i <= n:
		if x // i == i:
			lst.append(i)
		else:
			lst.append(i)
			lst.append(x // i)
	i += 1
print(len(lst))


(n, x) = map(lambda e: int(e), input().split())
print(sum((1 if x % i == 0 and x / i <= n else 0 for i in range(1, n + 1))))


(x, y) = map(int, input().split())
count = 0
for i in range(1, x + 1):
	if y % i == 0:
		if y / i <= x:
			count += 1
print(count)


import math
(n, x) = map(int, input().split())
num = int(math.sqrt(x))
ans = 0
for i in range(1, num + 1):
	if x % i == 0 and x / i <= n:
		if x / i != i:
			ans += 2
		else:
			ans += 1
print(ans)


(x, y) = map(int, input().split())
add = 0
for i in range(1, x + 1):
	if y // i <= x and y % i == 0:
		add += 1
print(add)


import math
(n, m) = map(int, input().split())
c = 0
for i in range(1, n + 1):
	if m % i == 0 and m // i <= n:
		c += 1
print(c)


(size, x) = map(int, input().split())
cnt = [n for n in range(1, size + 1) if x % n == 0 and x // n <= size]
print(len(cnt))


(n, x) = [int(i) for i in list(input().split())]
factors = []
count = 0
for i in range(1, n + 1):
	if x % i == 0:
		factors.append([i, int(x / i)])
for i in factors:
	if (i[0] >= 1 and i[0] <= n) and (i[1] >= 1 and i[1] <= n):
		count += 1
print(count)


import sys
I = sys.stdin.readline
(n, x) = map(int, I().split())
cnt = 0
for i in range(1, int(x ** 0.5) + 1):
	if x % i == 0:
		if i <= n and x // i <= n:
			if i == x // i:
				cnt += 1
			else:
				cnt += 2
print(cnt)


def mp():
	return map(int, input().split())

def lmp():
	return list(map(int, input().split()))
(n, x) = mp()
c = 0
for i in range(1, int(x ** 0.5) + 1):
	if x % i == 0:
		cek = x // i
		if i <= n and cek <= n:
			if cek == i:
				c += 1
			else:
				c += 2
print(c)


(x, n) = map(int, input().split())
p = 1
ans = 0
while p * p <= n:
	if n % p == 0 and p <= x and (n / p <= x):
		ans += 1
		ans += 1 if p * p != n else 0
	p += 1
print(ans)


(n, x) = map(int, input().strip().split(' '))
if x == 1:
	q = 1
elif n >= x:
	q = 2
else:
	q = 0
k = 2
while x >= k * k and k <= n:
	if x == k * k:
		q += 1
	elif x % k == 0 and n >= x / k:
		q += 2
	k += 1
print(q)


string = input()
numbers = string.split(' ')
n = int(numbers[0])
x = int(numbers[1])
total = 0
for y in range(1, n + 1):
	if x <= n * y and x % y == 0:
		total += 1
print(total)


def polycarp():
	x = list(map(int, input().split()))
	count = 0
	for i in range(1, x[0] + 1):
		if x[1] % i == 0 and x[1] / i <= x[0]:
			count += 1
	return count
print(polycarp())


(x, y) = input().split(' ')
x = int(x)
y = int(y)
v = 0
for n in range(1, x + 1):
	if n * x >= y and y % n == 0:
		v += 1
print(v)


is_debug = False
(n, x) = [int(x) for x in input().split()]
c = 0
for i in range(1, n + 1):
	v = int(x / i)
	if v * i == x and v <= n:
		print(f'n={n}, x={x}, i={i}, v={v}\n----') if is_debug else ''
		c = c + 1
print(f'{c}')


import sys
input = sys.stdin.readline
from math import log2, log, ceil

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

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

def nCr(n, k):
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return res

def upper_bound(a, x, lo=0):
	hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(1000000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

def int_array():
	return list(map(int, input().strip().split()))

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
(n, x) = int_array()
ans = 0
for i in range(1, n + 1):
	if x % i == 0:
		if x / i <= n:
			ans += 1
print(ans)


import sys
from math import sqrt

def divs(n):
	res = set()
	res.add(1)
	res.add(n)
	for i in range(2, int(sqrt(n)) + 1):
		if not n % i:
			res.add(i)
			res.add(n / i)
	return sorted(res)
for line in sys.stdin:
	(n, x) = line.strip().split()
	(n, x) = (int(n), int(x))
	sete = divs(x)
	cont = 0
	for m in sete:
		for k in sete:
			if k <= n and m <= n and (m * k == x):
				cont += 1
	print(cont)


def main():
	(n, x) = [int(i) for i in input().split()]
	cnt = 0
	for i in range(1, n + 1):
		if x % i == 0 and x // i <= n:
			cnt += 1
	print(cnt)
main()


from math import ceil, sqrt
(n, x) = map(int, input().split())
cnt = 0
s = set()
for i in range(1, ceil(sqrt(x)) + 1):
	if x % i == 0 and i <= n and (x / i <= n):
		s.add(i)
		s.add(x // i)
print(len(s))


(n, x) = map(int, input().strip().split())
if x == 1:
	print(1)
else:
	ans = 0
	factors = []
	for i in range(2, int(x ** 0.5) + 1):
		if i > n:
			break
		if x // i > n:
			continue
		if x % i == 0:
			factors.append(i)
			if x // i != i:
				factors.append(x // i)
	factors.sort()
	ans = len(factors)
	print(ans if n < x else ans + 2)


def __starting_point():
	arr = input().split()
	s = int(arr[0])
	num = int(arr[1])
	count = 0
	for i in range(1, s + 1):
		if i > num + 1:
			break
		if num % i == 0 and num / i <= s:
			count += 1
	print(count)
__starting_point()


s = str(input()).split()
n = int(s[0])
x = int(s[1])
c = 0
for i in range(1, n + 1):
	if x % i == 0 and n >= x / i:
		c += 1
print(c)


import math
(n, x) = map(int, input().split())
i = 0
for k in range(1, n + 1):
	if x % k == 0:
		if k <= n and x / k <= n:
			i = i + 1
print(i)


import sys, math
(n, x) = map(int, sys.stdin.readline().split())
ans = 0
for i in range(min(n, int(math.sqrt(x))), 0, -1):
	if x % i == 0:
		if x // i > n:
			break
		ans += 1
		if i != x // i:
			ans += 1
print(ans)


n = input().split()
k = []
for i in n:
	k.append(int(i))
dict = {}
n = 0
result = 0
for i in range(1, k[1] + 1):
	if i > k[0]:
		break
	if k[1] % i == 0:
		dict[i] = [i, k[1] // i]
for i in dict.values():
	if i[0] <= k[0] and i[1] <= k[0]:
		result += 1
print(result)


import math
([n, x], num) = ([int(i) for i in input().split()], 0)
for i in range(1, min(n + 1, int(math.sqrt(x)) + 1)):
	num = num + 2 * (x % i == 0 and x // i <= n) - (i * i == x)
else:
	print(num)


line = input().split()
n = int(line[0])
x = int(line[1])
count = 0
for a in range(n):
	if x % (a + 1) == 0 and x / (a + 1) <= n:
		count += 1
print(count)


n = 2
c = 0
arr = list(map(int, input().split()))[:n]
for i in range(1, arr[0] + 1, 1):
	if arr[1] % i == 0:
		l = int(arr[1] / i)
		if l <= arr[0]:
			c = c + 1
print(c)


(n, x) = map(int, input().split())
(t1, c) = (x // 2 + 1, 0)
a = []
for i in range(1, n + 1):
	if x % i == 0 and x // i <= n:
		if i not in a:
			a.append(i)
		if x // i not in a:
			a.append(x // i)
	if i > x // 2 + 1:
		break
print(len(a))


import math
a = input().split(' ')
n = int(a[0])
x = int(a[1])
if n * n < x:
	print(0)
	exit(0)
if x == 1 or n * n == x:
	print(1)
	exit(0)
result = 0
i = 1
while i <= n:
	if x % i == 0:
		if x // i <= n:
			result = result + 1
	i = i + 1
print(result)


def fn():
	(x, y) = map(int, input().split())
	cn = 0
	for a in range(1, x + 1):
		if y % a == 0 and y / a <= x:
			cn += 1
	print(cn)
fn()


import math

def printDivisors(n):
	A = []
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n / i == i:
				A.append(i)
			else:
				A.append(i)
				A.append(n // i)
		i += 1
	return sorted(A)
(m, x) = map(int, input().split())
A = printDivisors(x)
n = len(A)
i = n - 1
while n > 0:
	if m >= A[i]:
		break
	n -= 2
	i -= 1
if n > 0:
	print(n)
else:
	print(0)


def get_pairs_of_divisors(x):
	a = []
	for i in range(1, int(x ** 0.5) + 1):
		if x % i == 0:
			a.append([i, x // i])
	return a
(n, x) = map(int, input().split())
ans = 0
for e in get_pairs_of_divisors(x):
	if 1 <= e[0] <= n and 1 <= e[1] <= n:
		ans += 1 if e[0] == e[1] else 2
print(ans)


import math
input_s = input().split()
n = int(input_s[0])
x = int(input_s[1])
result = 0
for i in range(1, n + 1):
	if x % i == 0:
		if n >= x / i:
			result += 1
print(result)


from math import *
(n, k) = map(int, input().split())
ans = 0
for i in range(1, int(sqrt(k)) + 1):
	if k % i == 0:
		a = i
		b = k // i
		if max(a, b) <= n:
			ans += 2
			if a == b:
				ans = ans - 1
print(ans)


z = input()
s = [int(n) for n in z.split()]
k = 0
x = s[0]
y = s[1]
for n in range(1, x + 1):
	if y % n == 0 and y / n <= x:
		k += 1
print(k)


import math
(n, x) = map(int, input().split())
c = 0
y = math.sqrt(x)
for i in range(1, math.ceil(y)):
	if x % i == 0 and i <= n and (x / i <= n):
		c = c + 2
if y == int(y) and y <= n:
	c = c + 1
print(c)


from math import *
(n, m) = map(int, input().split())
answer = 0
for i in range(1, int(sqrt(m))):
	if m % i == 0 and m // i <= n:
		answer += 1
answer *= 2
if m % int(sqrt(m)) == 0 and m // int(sqrt(m)) <= n and (int(sqrt(m)) != m // int(sqrt(m))):
	answer += 2
elif int(sqrt(m)) ** 2 == m and int(sqrt(m)) <= n:
	answer += 1
print(answer)


a = [int(x) for x in input().split()]
x = 1
count = 0
while x <= a[0] and x <= a[1]:
	if a[1] % x == 0:
		if a[1] // x <= a[0]:
			count += 1
	x += 1
print(count)


(n, x) = map(int, input().split())
print(len([i for i in range(1, n + 1) if not (x % i or n < x // i)]))


(n, x) = map(int, input().split())
ans = 0
for i in range(1, n + 1):
	(d, r) = divmod(x, i)
	if r == 0 and 1 <= d <= n:
		ans += 1
print(ans)


(n, m) = map(int, input().split())
r = 0
for i in range(1, n + 1):
	if not m % i and n * i >= m:
		r += 1
print(r)


def factors(number, n):
	factor = 0
	for k in range(1, int(n ** 0.5) + 1):
		if not n % k:
			m = n // k
			if m <= number:
				factor += 2 if len(set([k, m])) > 1 else 1
	return factor
(table, number) = map(int, input().split())
print(factors(number=table, n=number))


(dim, num) = map(int, input().split())
count = 0
for i in range(1, dim + 1):
	if num / i == num // i and num / i <= dim:
		count += 1
print(count)


import math
(size, number) = map(int, input().split())
result = 0
for num in range(1, int(number / 2) + 1, 1):
	if size < num:
		break
	if number % num == 0 and size >= number / num and (num <= size):
		result += 1
if number <= size:
	result += 1
print(result)


def func(x, n):
	c = 0
	for i in range(1, n + 1):
		if x % i == 0 and x / i <= n:
			c += 1
	return c
(n, x) = map(int, input().split())
d = func(x, n)
print(d)


import math
(n, x) = map(int, input().split())
w = 0
c = min(n, x)
for i in range(1, int(math.sqrt(x)) + 1):
	if x % i == 0:
		if x // i == i and i <= n:
			w += 1
		elif x // i <= n and i <= n:
			w += 2
print(w)


from sys import stdin, stdout
input = stdin.readline
(n, x) = map(int, input().split())
ans = 0
for i in range(1, n + 1):
	if x % i == 0:
		if x / i <= n:
			ans += 1
stdout.write(str(ans))


from math import *
(N, X) = map(int, input().split())
ans = 0
for i in range(1, int(sqrt(X)) + 1):
	if X % i == 0 and X // i <= N and (i <= N):
		if i != X // i:
			ans += 2
		else:
			ans += 1
print(ans)


args = input().split()
n = int(args[0])
x = int(args[1])
count = 0
for i in range(1, n + 1):
	if x % i == 0 and x / i <= n:
		count += 1
print(count)


import math
s = input().split()
(n, x) = (int(s[0]), int(s[1]))
multiset = set()
for i in range(1, min(int(math.sqrt(x)), n) + 1):
	if i not in multiset and x % i == 0 and (x // i <= n):
		multiset = multiset | set([i, x // i])
print(len(multiset))


str = input().split()
n = int(str[0])
x = int(str[1])
ctr = 0
for i in range(1, int(x ** 0.5) + 1):
	if x % i == 0 and i <= n:
		if x / i <= n:
			ctr += 2
		if x / i == i:
			ctr -= 1
print(ctr)


(a, b) = map(int, input().split())
li = [x for x in range(1, a + 1)]
ans = 0
for i in li:
	if b % i == 0 and i * a >= b:
		ans += 1
print(ans)


(x, y) = input().split()
x = int(x)
y = int(y)
c = 0
for i in range(1, x + 1):
	if y % i == 0 and y / i <= x:
		c += 1
print(c)


from sys import stdin, stdout, maxsize
tup = lambda : map(int, stdin.readline().split())
I = lambda : int(stdin.readline())
lint = lambda : [int(x) for x in stdin.readline().split()]
S = lambda : stdin.readline().replace('\n', '').strip()
stpr = lambda x: stdout.write(f'{x}' + '\n')
from _collections import defaultdict
(n, x) = tup()
ans = set()
for i in range(1, int(x ** 0.5) + 1):
	if x % i == 0:
		if x / i == i:
			if x / i <= n:
				ans.add(x / i)
		elif x / i <= n and i <= n:
			ans.add(x / i)
			ans.add(i)
print(len(ans))


import sys
(n, x) = map(int, sys.stdin.readline().split())
s = 0
for i in range(1, n + 1):
	if x % i == 0 and x / i <= n:
		s += 1
print(s)


(n, m) = map(int, input().split())
count = 0
i = 1
while i * i <= m:
	aa = m // i
	cc = m % i
	if m % i == 0 and m // i <= n:
		if i != m // i:
			count += 2
		else:
			count += 1
	i += 1
print(count)


(n, k) = list(map(int, input().split()))
p = 0
for i in range(1, n + 1):
	t = k / i
	if int(t) == t:
		if t <= n:
			p += 1
print(p)


p = input().rstrip().split(' ')
a = int(p[0])
b = int(p[1])
Y = 0
for i in range(1, a + 1):
	if b % i == 0:
		g = b // i
		if g <= a:
			Y += 1
print(Y)


(n, x) = (int(x) for x in input().split())
if x > n * n:
	print(0)
else:
	r = 0
	for i in range(1, n + 1):
		if x % i == 0 and x // i <= n:
			r += 1
	print(r)


from math import sqrt
(n, x) = map(int, input().split())
pairs_number = 0
bound = int(sqrt(x))
for i in range(1, min(n, bound) + 1):
	j = x // i
	if j <= n and j * i == x:
		pairs_number += 2
if bound <= n and bound ** 2 == x:
	pairs_number -= 1
print(pairs_number)


nx = input().split(' ')
n = int(nx[0])
x = int(nx[1])
i = 1
ans = 0
while i ** 2 <= x and i <= n:
	if x % i == 0:
		if x // i != i and x // i <= n:
			ans += 2
		elif x // i == i:
			ans += 1
	i += 1
print(ans)


n = input().split(' ')
a = int(n[0])
b = int(n[1])
count = 0
for i in range(1, a + 1):
	r = b % i
	n = b / i
	if r == 0 and n <= a:
		count = count + 1
print(count)


(n, x) = map(int, input().split())
result = set()
i = 1
while i <= x and i <= n:
	if x % i == 0 and x // i <= n:
		result.update({i, x // i})
	i += 1
print(len(result))


def kilk_dil(ma, n):
	k = 0
	if n == 1:
		return 1
	if ma == 1:
		return 0
	for i in range(1, int(n ** 0.5) + 1):
		if i ** 2 == n and i <= ma:
			k += 1
		elif n % i == 0 and i <= ma and (n // i <= ma):
			k += 2
	return k
(m, n) = map(int, input().split())
print(kilk_dil(m, n))


(tabela, x) = map(int, input().split())
count = 0
for a in range(1, tabela + 1):
	if x % a == 0 and x / a <= tabela:
		count += 1
print(count)


st = input().split()
n = int(st[0])
x = int(st[1])
res = 0
for temp in range(1, n + 1):
	if temp > x ** (1 / 2):
		break
	if x % temp == 0 and x / temp <= n:
		if temp ** 2 == x:
			res += 1
		else:
			res += 2
print(res)


import sys

def main():
	pass

def binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def isPrime(n):
	if n == 1:
		return False
	else:
		root = int(n ** 0.5)
		root += 1
		for i in range(2, root):
			if n % i == 0:
				return False
		return True

def lts(l):
	s = ''.join(map(str, l))
	return s

def stl(s):
	l = list(s)
	return l

def sq(a, target, arr=[]):
	s = sum(arr)
	if s == target:
		return arr
	if s >= target:
		return
	for i in range(len(a)):
		n = a[i]
		remaining = a[i + 1:]
		ans = sq(remaining, target, arr + [n])
		if ans:
			return ans

def SieveOfEratosthenes(n):
	cnt = 0
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	for p in range(2, n + 1):
		if prime[p]:
			cnt += 1
	return cnt

def nCr(n, r):
	f = math.factorial
	return f(n) // f(r) // f(n - r)
mod = int(1000000000.0) + 7

def ssinp():
	return sys.stdin.readline().strip()

def iinp():
	return int(input())

def nninp():
	return map(int, sys.stdin.readline().strip().split())

def llinp():
	return list(map(int, sys.stdin.readline().strip().split()))

def p(xyz):
	print(xyz)

def p2(a, b):
	print(a, b)
import math
(n, x) = nninp()
ans = 0
for i in range(1, n + 1):
	if x % i == 0 and x // i <= n:
		ans += 1
p(ans)


(size, integer) = map(int, input().split())
occurances = 0
for i in range(1, size + 1):
	if not integer % i:
		if integer // i <= size:
			occurances += 1
print(occurances)


(n, x) = map(int, input().split())
count = 0
i = 1
while i < n + 1:
	if x % i == 0:
		if x / i <= n:
			count += 1
	i += 1
print(count)


from math import ceil
(n, x) = map(int, input().split(' '))
i = 1
count = 0
while i <= n:
	if x % i == 0 and x // i <= n:
		count += 1
	i += 1
print(count)


(n, x) = map(int, input().split())
l = set()
for i in range(1, n + 1):
	if x % i == 0:
		l.add(i)
ans = 0
for i in l:
	if x // i <= n:
		ans += 1
print(ans)


def main():
	(N, X) = map(int, input().split())
	ans = 0
	for i in range(1, min(N, X) + 1):
		ans += X % i == 0 and X // i <= N
	print(ans)
main()


(n, k) = list(map(int, input().split()))
c = 0
for i in range(1, n + 1):
	if k % i == 0:
		if k / i <= n:
			c += 1
print(c)


l = [int(i) for i in input().split()]
n = l[0]
k = l[1]
c = 0
for i in range(1, n + 1):
	if k % i == 0 and k // i <= n:
		c = c + 1
print(c)


import math
(n, x) = map(int, input().split())
temp = int(math.sqrt(x) + 0.01)
ans = 0
for i in range(1, temp + 1):
	if x % i == 0:
		if x // i <= n:
			if x // i == i:
				ans += 1
			else:
				ans += 2
print(ans)


(n, x) = [int(j) for j in input().split()]
count = 0
for j in range(1, n + 1):
	j2 = int(x / j)
	if j2 * j == x and j2 <= n:
		count += 1
print(count)


(n, x) = list(map(int, input().split(' ')))
a = int(x ** 0.5)
ans = 0
for j in range(1, a + 1):
	if x % j == 0 and j * j != x and (x / j <= n):
		ans += 2
	elif x % j == 0 and j * j == x and (x / j <= n):
		ans += 1
print(ans)


(n, x) = [int(y) for y in input().split()]
num = 0
import math
for i in range(1, int(math.sqrt(x)) + 1):
	if x / i == int(x / i):
		a = x / i
		if a <= n and i == math.sqrt(x):
			num = num + 1
		elif a <= n and i != math.sqrt(x):
			num = num + 2
		a = 0
print(num)


(n, x) = map(int, input().split())
k = 0
if n > x:
	n = x
for i in range(2, n + 1):
	if x % i == 0:
		if x // i <= n:
			k += 1
if n == x:
	k += 1
print(k)


def main():
	(n, x) = [int(i) for i in input().split()]
	k = 0
	lmt = min(n + 1, int(x ** 0.5) + 1)
	for i in range(1, lmt):
		if x % i == 0:
			(a, b) = (x // i, i)
			if a <= n and b <= n:
				if a != b:
					k += 2
				else:
					k += 1
	print(k)
main()


p = list(map(int, input().split()))
n = p[0]
x = p[1]
import math
q = 0
for i in range(2, int(math.sqrt(x)) + 1):
	if x % i == 0 and i <= n and (x / i <= n):
		if i == x / i:
			q = q + 1
		else:
			q = q + 2
if x <= n and x != 1:
	q = q + 2
elif x <= n and x == 1:
	q = 1
print(q)


(n, x) = map(int, input().split())
o = 0
i = 1
l = []
while i ** 2 <= x:
	if x % i == 0 and i <= n:
		l.append(i)
		if i != x // i and x // i <= n:
			l.append(x // i)
	i += 1
l.sort()
while len(l) > 0:
	d = x // l[-1]
	if d in l and d != 1:
		if d != l[-1]:
			o += 2
			l.remove(d)
			l.pop()
		else:
			o += 1
			l.pop()
	elif l[0] * n >= x:
		o += 1
		l.pop()
	else:
		l.pop()
print(o)


(n, x) = [int(i) for i in input().split()]
if n >= x:
	res = 1
else:
	res = 0
for i in range(2, n + 1):
	if x % i == 0 and i * n >= x:
		res += 1
print(str(res))


s = input()
l = s.split(' ')
n = int(l[0])
x = int(l[1])
i = 1
count = 0
while i <= x and i <= n:
	if x % i == 0 and int(x / i) <= n:
		count += 1
	i += 1
print(count)


import time

def countMultipliers(size, lval):
	qty = 0
	for x in range(1, size + 1):
		mod = lval % x
		if mod == 0 and lval / x <= size:
			qty += 1
	return qty

def solve():
	(x, num) = [int(x) for x in input().split()]
	start_time = time.time()
	qtyNum = countMultipliers(x, num)
	print(qtyNum)
solve()


(n, x) = map(int, input().split())
r = 0
for d1 in range(1, int(x ** 0.5) + 1):
	if not x % d1:
		d2 = x / d1
		if d2 > n:
			continue
		if d2 == d1:
			r += 1
		else:
			r += 2
print(r)


(n, x) = tuple(map(int, input().split()))
d = 1
res = 0
while d * d < x:
	if d > n or x / d > n:
		d += 1
		continue
	if x % d == 0:
		res += 1
	d += 1
res *= 2
if d * d == x and d <= n:
	res += 1
print(res)


(x, n) = map(int, input().split())
t = round(n ** 0.5)
p = t * t == n and t <= x
ans = -int(p)
for i in range(t, 0, -1):
	if n / i > x:
		break
	if n % i == 0:
		ans += 2
print(ans)


a = input().split(' ')
n = int(a[0])
m = int(a[1])
count = 0
for i in range(1, n + 1):
	if m % i == 0 and m // i <= n:
		count += 1
print(count)


entrance = input().split(' ')
(n, x) = (int(entrance[0]), int(entrance[1]))
cont = 0
for i in range(1, n + 1):
	if not x % i and x // i <= n:
		cont += 1
print(cont)


(n, x) = [int(x) for x in input().split()]
check = 0
if n * n < x:
	print(0)
else:
	for i in range(1, int(pow(x, 0.5) + 1)):
		if x % i == 0 and x != i * i and (x / i <= n):
			check += 2
		elif x % i == 0 and x == i * i and (x / i <= n):
			check += 1
	print(check)


(n, k) = [int(x) for x in input().split()]
tot = 0
for i in range(1, n + 1):
	if k > i * n:
		continue
	if k % i == 0:
		tot += 1
print(tot)


(n, x) = map(int, input().split())
import math
k = 0
for i in range(1, round(math.sqrt(x)) + 1):
	if x % i == 0 and x / i <= n:
		if i == x / i:
			k += 1
		else:
			k += 2
print(k)


s = input().split()
(size, search) = (int(s[0]), int(s[1]))
count = 0
for i in range(1, size + 1):
	if search % i == 0 and search / i <= size:
		count += 1
print(count)


l = input()
l = l.split(' ')
n = int(l[0])
x = int(l[1])
compt = 0
for i in range(1, n + 1):
	if x % i == 0 and x // i <= n:
		compt = compt + 1
print(compt)


def main(n, x):
	c = 0
	for i in range(1, n + 1):
		if not x % i and x / i <= n:
			c += 1
	return c
(n, x) = list(map(int, input().split()))
print(main(n, x))


row = input()
row = row.split()
num = int(row[1])
row = int(row[0])
c = 0
for i in range(1, row + 1):
	if num % i == 0:
		if num // i <= row:
			c += 1
print(c)


(n, m) = map(int, input().strip().split())
c = 0
for i in range(1, n + 1):
	if m % i == 0 and m / i <= n:
		c += 1
print(c)


(n, x) = map(int, input().split())
count = 0
for i in range(1, int(pow(x, 0.5)) + 1):
	if x % i == 0:
		if x // i <= n:
			count += 2
dec = int(str(pow(x, 0.5)).split('.')[1])
if dec == 0 and count != 0:
	print(count - 1)
else:
	print(count)


read = lambda : map(int, input().split())
(n, x) = read()
result = 0
for i in range(1, n + 1):
	if x % i == 0 and x // i <= n:
		result += 1
print(result)


import math
(N, X) = map(int, input().split())
ans = 0
for x in range(1, math.floor(math.sqrt(X)) + 1):
	if X % x == 0:
		y = X // x
		if x <= N and y <= N:
			if x == y:
				ans += 1
			else:
				ans += 2
print(ans)


import math
import cmath
import string
import sys
import bisect
import ctypes
from queue import Queue, LifoQueue, PriorityQueue
from itertools import permutations, combinations
from collections import deque, Counter
ans = 0
(n, x) = list(map(int, input().split()))
for i in range(1, n + 1):
	if n * i >= x and x % i == 0:
		ans += 1
print(ans)


def solve():
	(n, x) = [int(x) for x in input().split()]
	count = 0
	if x <= n:
		count += 1
	for j in range(2, n + 1):
		exists = x % j == 0
		row = x // j <= n
		if exists and row:
			count += 1
	print(count)
	return
solve()


(n, x1) = input().split()
(n, x1) = (int(n), int(x1))
c = 0
for i in range(1, n + 1):
	if x1 % i == 0 and x1 // i <= n:
		c += 1
print(c)


(n, m) = map(int, input().split())
i = 1
t = 0
while i * i <= m:
	if m % i == 0 and i <= n and (int(m / i) <= n):
		if i * i == m:
			t += 1
		else:
			t += 2
	i += 1
print(t)


(n, x) = map(float, input().split())
schet = 0
znachen = round(x ** 0.5 + 1)
for i in range(1, znachen):
	if x % i == 0 and i <= n and (x / i <= n):
		schet += 1
schet *= 2
if x ** 0.5 % 1 == 0 and x ** 0.5 <= n:
	schet -= 1
print(schet)


import math as m
(n, x) = map(int, input().split())
count = 0
k = int(m.sqrt(x)) + 1
for i in range(1, k):
	j = x / i
	if j == int(j) and j <= n and (j != i):
		count += 2
	elif j == int(j) and j == i and (j <= n):
		count += 1
if x == 1:
	count = 1
print(count)


(n, x) = input().split()
(n, x) = (int(n), int(x))
import math
rt = math.sqrt(x)
count = 0
res = min(n, int(rt))
for i in range(1, res + 1):
	if x % i == 0 and x / i <= n:
		count = count + 1
count = 2 * count
if int(rt) == rt and count > 0:
	count = count - 1
print(count)


import sys
import itertools
import math
import collections
from collections import Counter

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 1
	prime[0] = prime[1] = False
	r = [p for p in range(n + 1) if prime[p]]
	return r

def divs(n, start=1):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def ceil(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

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

def prr(a, sep=' '):
	print(sep.join(map(str, a)))

def dd():
	return collections.defaultdict(int)
(n, x) = mi()
print(len([i for i in divs(x) if i <= n and x // i <= n]))


def kil(n, a):
	s = 0
	for i in range(1, int(a ** 0.5) + 1):
		if a % i == 0:
			if i <= n and a // i <= n:
				s = s + 1
			if a // i <= n and i != a // i:
				s = s + 1
	return s
(n, x) = map(int, input().split())
ki = kil(n, x)
print(ki)


(n, x) = map(int, input().split())
ans = 0
for f in range(1, n + 1):
	if x % f == 0 and x // f <= n:
		ans += 1
print(ans)


from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
(n, t) = map(int, input().split())
ans = 0
for i in factors(t):
	if 1 <= i <= n and 1 <= t // i <= n:
		ans += 1
print(ans)


(n, x) = map(int, input().split())
from math import sqrt
k = int(sqrt(x))
sum = 0
for i in range(1, min(n + 1, k + 1)):
	if x % i == 0 and x // i <= n:
		sum = sum + 2
if x == k * k and k <= n:
	sum = sum - 1
print(sum)


arr = [int(i) for i in filter(None, input().split(' '))]
max = arr[0]
n = arr[1]
sum = 0
for i in range(1, max + 1):
	if n % i == 0 and n // i <= max and (i <= max):
		sum += 1
print(sum)


def multiplication_table(n, x):
	a = [v + 1 for v in range(n) if x % (v + 1) == 0]
	return len([(r, s) for r in a for s in a if r * s == x])
f = lambda : map(int, input().split())
(m, y) = f()
print(multiplication_table(m, y))


(n, m) = map(int, input().split())
i = 1
cont = 0
while i <= n:
	if m % i == 0 and m / i <= n:
		cont += 1
	i += 1
print(cont)


import math
arr = list(map(int, input().rstrip().split()))
rangg = min(arr[0], arr[1])
count = 0
for i in range(1, rangg + 1):
	leftfact = arr[1] // i
	if leftfact == arr[1] / i and leftfact <= arr[0]:
		count += 1
print(count)


l1 = [int(x) for x in input().split()]
(n, x) = (l1[0], l1[1])
c = []
for y in range(1, min(n + 1, int(x ** (1 / 2)) + 1)):
	if x % y == 0 and x / y <= n:
		c.append(y)
		c.append(x // y)
print(len(set(c)))


line = input().split()
n = int(line[0])
g = int(line[1])
cnt = 0
for i in range(1, n + 1):
	if g % i == 0 and g // i <= n:
		cnt = cnt + 1
print(cnt)


from sys import stdin, stdout
from math import sqrt

def main():
	inp = [int(x) for x in stdin.readline().split()]
	x = 0
	for i in range(inp[0]):
		if inp[1] % (i + 1) == 0 and inp[1] / (i + 1) <= inp[0]:
			x += 1
	stdout.write(str(x))
main()


inputz = input().split()
n = int(inputz[0])
x = int(inputz[1])
count = 0
for i in range(1, n + 1):
	if not x % i and x // i <= n:
		count += 1
print(count)


import math

def Divisors(n):
	i = 1
	factors = []
	while i <= math.sqrt(n):
		if n % i == 0:
			if n / i == i:
				factors.append(i)
			else:
				factors.append(i)
				factors.append(int(n / i))
		i = i + 1
	return factors
(n, x) = map(int, input().split())
factors = Divisors(x)
factors.sort()
if n >= factors[-1]:
	print(len(factors))
else:
	counter = 0
	i = 0
	while factors[i] <= n:
		if int(x / factors[i]) <= n:
			counter += 1
		i += 1
	print(counter)


inp = input().split()
n = int(inp[0])
x = int(inp[1])

def cnt(p):
	c = 0
	for i in range(1, int(p ** 0.5) + 1):
		if p % i == 0 and i <= n and (p // i <= n):
			if i == p // i:
				c += 1
			else:
				c += 2
	return c
print(cnt(x))


str = input().split(' ')
[n, x] = [int(str[i]) for i in range(len(str))]
cnt = 0
for i in range(1, n + 1):
	cnt += x % i == 0 and x <= i * n
print(cnt)


(n, x) = map(int, input().split())
if x == 1:
	print(1)
	exit()
ans = 0
for i in range(2, n + 1):
	m1 = i * 2
	m2 = i * n
	if m1 <= x <= m2 and x % i == 0:
		ans += 1
if 2 <= x <= n:
	ans += 2
print(ans)


import math
s = input().split()
n = int(s[0])
x = int(s[1])
t = int(math.sqrt(x))
T = t
count = 0
while True:
	if t == 0 or int(x / t) > n:
		break
	if x % t == 0:
		count += 2
	t -= 1
if T * T == x and T <= n:
	count -= 1
print(count)


(n, x) = map(int, input().split())
res = 0
for i in range(1, n + 1):
	if x % i == 0:
		tmp = x // i
		if tmp <= n:
			res += 1
print(res)


(a, b) = map(int, input().split())
c = int(b ** 0.5)
d = set()
e = min(c, a)
for i in range(1, e + 1):
	if b % i == 0:
		j = b // i
		if j <= a:
			d.add((i, j))
			d.add((j, i))
print(len(d))


(n, p) = map(int, input().split())
if p <= n:
	cnt = 1
else:
	cnt = 0
for i in range(2, n + 1):
	if p % i == 0 and p / i <= n:
		cnt += 1
print(cnt)


(size, target) = map(int, input().split())
ans = 0
for i in range(1, size + 1):
	if target // i * i == target and target // i <= size:
		ans += 1
print(ans)


def get_value():
	(size, number) = [int(val) for val in input().split()]
	result = 0
	for i in range(1, size + 1):
		if number % i == 0 and number // i <= size:
			result += 1
	return result
print(get_value())


import math
(n, x) = map(int, input().split())
c = 0
s = int(math.sqrt(x))
if x == 1:
	c += 1
else:
	for i in range(1, s + 1):
		if i > n:
			break
		if n * n == x:
			c += 1
			break
		if x % i == 0 and i <= n:
			if i * i == x:
				c += 1
			elif x // i >= 1 and x // i <= n and (i * i != x):
				c += 2
print(c)


from sys import stdin
from collections import deque
from math import sqrt, floor, ceil, log, log2, log10, pi, gcd, sin, cos, asin

def ii():
	return int(stdin.readline())

def fi():
	return float(stdin.readline())

def mi():
	return map(int, stdin.readline().split())

def fmi():
	return map(float, stdin.readline().split())

def li():
	return list(mi())

def lsi():
	x = list(stdin.readline())
	x.pop()
	return x

def si():
	return stdin.readline()

def sieve(x):
	a = [True] * (x + 1)
	sq = floor(sqrt(x))
	for i in range(3, sq + 1, 2):
		if a[i]:
			for j in range(i * i, x + 1, i):
				a[j] = False
	if x > 1:
		p = [2]
	else:
		p = []
	for i in range(3, x + 1, 2):
		if a[i]:
			p.append(i)
	return p
(n, x) = mi()
c = 0
i = 1
while i * i <= x:
	if not x % i:
		z = x // i
		if z <= n:
			c += 2
			if z == i:
				c -= 1
	i += 1
print(c)


(r, k) = list(map(int, input().rstrip().split()))
c = 0
for i in range(1, r + 1):
	if k % i == 0 and k // i <= r:
		c += 1
print(c)


(n, x) = map(int, input().split())
f = list(set(sum([[i, x // i] for i in range(1, int(x ** 0.5) + 1) if i <= n and x // i <= n and (x % i == 0)], [])))
print(len(f))


count = 0
(N, x) = map(int, input().split())
for i in range(2, int(x ** 0.5) + 1):
	if x % i == 0:
		if x // i <= N and i != x ** 0.5:
			count += 2
		elif i == x ** 0.5 and x ** 0.5 <= N:
			count += 1
if x == 1:
	count = 1
elif x <= N:
	count += 2
print(count)


(mat_size, find) = map(int, input().split(' '))
print(len([i for i in range(1, mat_size + 1) if find % i == 0 and find // i <= mat_size]))


(n, m) = map(int, input().strip().split()[:2])
count = 0
for x in range(1, n + 1):
	if m % x == 0:
		k = m // x
		if 1 <= k and k <= n:
			count += 1
print(count)


(n, m) = map(int, input().split())
a = []
i = 1
while i * i <= m:
	if m % i == 0:
		a.append(i)
		if i * i != m:
			a.append(m // i)
	i += 1
print(len([i for i in a if i <= n and m // i <= n]))


__author__ = 'dwliv_000'

def isPrime(n):
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			return False
	return True
(n, m) = (int(i) for i in input().split())
k = 0
for j in range(1, n + 1):
	if m / j == m // j and m / j <= n:
		k = k + 1
print(k)


n_x = input().split()
counter = 0
for i in range(1, int(n_x[0]) + 1):
	if int(n_x[1]) % i == 0 and int(n_x[1]) / i <= int(n_x[0]):
		counter += 1
print(counter)


j = input().split()
k = int(j[0])
n = int(j[1])
c = 0
for i in range(1, k + 1):
	if n % i == 0:
		if n // i <= k:
			c += 1
print(c)


(n, t) = map(int, input().split())
c = 0
for i in range(1, n + 1):
	if t % i == 0:
		if t // i <= n:
			c = c + 1
print(c)


(n, t) = [int(i) for i in input().split()]
m = 0
s = 0
d = 0
h = 0
for i in range(1, n + 1):
	if t % i == 0 and t // i <= n:
		m = m + 1
print(m)


import math
__author__ = 'artyom'

def main():
	(n, x) = read(3)
	c = 0
	for i in range(1, int(math.sqrt(x) + 1)):
		if x % i == 0:
			r = x // i
			if r <= n:
				c += 1
				if i * i < x:
					c += 1
	return c

def read(mode=1, size=None):
	if mode == 0:
		return input().strip()
	if mode == 1:
		return int(input().strip())
	if mode == 2:
		return input().strip().split()
	if mode == 3:
		return list(map(int, input().strip().split()))
	a = []
	for _ in range(size):
		a.append(read(3))
	return a

def write(s='\n'):
	if s is None:
		s = ''
	if isinstance(s, tuple) or isinstance(s, list):
		s = ' '.join(map(str, s))
	s = str(s)
	print(s, end='\n')
res = main()
write(res)


(n, m) = map(int, input().split())
if m == 1:
	l = 1
elif m <= n:
	l = 2
else:
	l = 0
for i in range(2, int(m ** 0.5) + 1):
	if m % i == 0:
		if m // i == i and i <= n:
			l += 1
		elif m // i <= n:
			l += 2
print(l)


import sys
import math

def factors(x):
	for i in range(1, int(math.sqrt(x)) + 1):
		if x % i == 0:
			yield i
			if x / i != i:
				yield (x / i)
(n, x) = map(int, sys.stdin.readline().split())
if n * n < x:
	print(0)
	exit()
occurrences = [(row, x / row) for row in filter(lambda f: f <= n, factors(x)) if x / row <= n]
print(len(occurrences))


(n, x) = map(int, input().split())
(q, r) = (int(x ** 0.5) + 1, [])
for i in range(1, q):
	if x % i == 0:
		o = x / i
		if o <= n:
			a = [i, o]
			a.sort()
			if a not in r:
				r.append(a)
q = len(r)
if q == 0:
	print(0)
elif x ** 0.5 % 1 == 0:
	print((q - 1) * 2 + 1)
else:
	print(2 * q)


(n, x) = input().split()
n = int(n)
x = int(x)
if n * n < x:
	print(0)
else:
	i = 1
	s = 0
	while i * i <= x:
		if x % i == 0 and x / i <= n:
			s += 1
			if i * i != x:
				s += 1
		i += 1
	print(s)


(n, x) = map(int, input().split())
list1 = []
for i in range(1, min(n + 1, x + 1)):
	if x % i == 0 and x // i <= n:
		list1.append(i)
print(len(list1))


from functools import reduce
(n, x) = [int(a) for a in input().split()]
if n == 1:
	if x == 1:
		print(1)
	else:
		print(0)
elif x == 1:
	print(1)
else:
	total = 0

	def factors(n):
		return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
	factorsX = sorted(factors(x))
	limit = len(factorsX) // 2 - 1
	if len(factorsX) % 2:
		limit += 1
		if factorsX[len(factorsX) // 2] <= n:
			total += 1
	for factor in range(len(factorsX) - 1, limit, -1):
		if factorsX[factor] <= n:
			total += 2
	print(total)


(n, x) = [int(y) for y in input().split()]
c = 0
for i in range(1, n + 1):
	if x % i == 0:
		j = x // i
		if x == i * i:
			c += 1
		elif j <= n and x == i * j:
			c += 1
print(c)


(x, y) = map(int, input().split())
divisors = []
for i in range(1, int(y ** 0.5) + 1):
	if y % i == 0:
		divisors.append(i)
		divisors.append(y // i)
divisors = set(divisors)
total = len(divisors)
for i in divisors:
	if i > x or y // i > x:
		total -= 1
print(total)


(n, x) = [int(i) for i in input().split(' ')]
cnt = 0
for i in range(1, n + 1):
	if x % i == 0:
		if x // i <= n:
			cnt += 1
print(cnt)


A = input().split()
A = [int(i) for i in A]
n = A[0]
x = A[1]
counter = 0
for i in range(1, n + 1):
	if i > x:
		break
	elif x % i == 0:
		if x // i <= n:
			counter += 1
print(counter)


(n, x) = [int(x) for x in input().split()]
count = 0
if n >= x:
	count += 1
i = 2
while i <= n:
	if x % i == 0 and x // i <= n:
		count += 1
	i += 1
print(count)


(n, x) = list(map(int, input().split()))
a = 1
res = 0
while a <= n:
	if x % a == 0 and x / a <= n:
		res += 1
	a += 1
print(res)


(n, x) = map(int, input().split())
S = 0
for i in range(1, int(x ** (1 / 2)) + 1):
	if x % i == 0:
		if i <= n and x // i <= n:
			if i ** 2 == x:
				S += 1
			else:
				S += 2
if x == 1 or n ** 2 == x:
	print(S)
else:
	print(S)


(a, b) = map(int, input().split())
count = 0
for i in range(1, a + 1):
	if b % i == 0:
		x = b // i
		if x <= a:
			count += 1
print(count)


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

def func(num, div, n):
	if num % div == 0:
		x = num // div
		if 1 <= x <= n:
			return True
	return False
vetor = [func(x, i, n) for i in range(1, n + 1)]
print(vetor.count(True))


(n, q) = list(map(int, input().split()))
count = 0
for var in range(1, n + 1):
	if q / var % 1 == 0 and q // var <= n:
		count += 1
print(count)


from sys import stdin
input = stdin.readline
(n, x) = map(int, input().split())
cnt = 0
for i in range(1, n + 1):
	cnt += int(not x % i and x // i <= n)
print(cnt)


S = input().split()
n = int(S[0])
a = int(S[1])
k = 0
for i in range(1, n + 1):
	if a % i == 0:
		if a // i <= n:
			k = k + 1
print(k)


(n, x) = map(int, input().split())
answer = []

def factors(n, x):
	if x > n:
		i = 2
		while i <= n:
			if x % i == 0:
				if x // i == i:
					answer.append(i)
				elif x // i != i and x // i <= n:
					answer.append(x // i)
			i = i + 1
	else:
		i = 1
		while i <= n:
			if x % i == 0:
				if x // i == i:
					answer.append(i)
				else:
					answer.append(x // i)
			i = i + 1
factors(n, x)
print(len(answer))


a = input().split()
n = int(a[0])
x = int(a[1])
z = 0
y = 1
while y < n + 1:
	if x % y == 0 and x / y <= n:
		z = z + 1
	y = y + 1
print(z)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	(n, x) = LI()
	r = 0
	for i in range(1, n + 1):
		if x % i != 0:
			continue
		if x // i <= n:
			r += 1
	return r
print(main())


(n1, x1) = input().split()
n = int(n1)
x = int(x1)
count = 0
for i in range(1, n + 1):
	test = x / i
	if int(test) <= n and x % i == 0:
		count = count + 1
print(count)


(n, x) = map(int, input().split())
p = 0
for __ in range(1, n + 1):
	if x % __ == 0 and x / __ <= n:
		p += 1
print(p)


def tablica(n, x):
	count = 0
	for i in range(1, n + 1):
		if x % i == 0 and x // i <= n:
			count += 1
	return count
(m, y) = [int(j) for j in input().split()]
print(tablica(m, y))


(n, m) = [int(x) for x in input().split()]
print(len([x for x in range(1, n + 1) if m % x == 0 and m / x <= n]))


n = list(map(int, input().split()))
i = 1
m = 0
if n[1] > n[0] ** 2:
	i += n[0]
while i <= n[0]:
	if n[1] == 1:
		m = 1
		i += n[0]
	if n[1] % i == 0 and n[1] <= n[0] * i:
		m += 1
	i += 1
print(m)


(n, x) = input().split()
n = int(n)
x = int(x)
otv = 0
i = 1
while i <= n:
	if x % i == 0 and int(x / i) <= n:
		otv += 1
	i += 1
print(otv)


(n, x) = input().split(' ')
n = int(n)
x = int(x)
ns = 0
for i in range(1, n + 1):
	if i ** 2 == x:
		ns = ns + 1
	elif x % i == 0 and x / i <= n:
		ns += 1
print(ns)


info = list(map(int, input().split()))
n = info[0]
num = info[1]
ans = 0
for i in range(1, n + 1):
	if num % i == 0 and num / i <= n and (num / i > 0):
		ans += 1
print(ans)


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

def countDivisors(n, maxx):
	cnt = 0
	for i in range(1, maxx + 1):
		if n % i == 0 and n // i <= maxx:
			cnt += 1
	return cnt
print(countDivisors(x, n))


(n, x) = map(int, input().split())
t = 0
if n ** 2 < x:
	print(0)
else:
	import math
	u = int(math.sqrt(x))
	for i in range(1, u + 1):
		if x % i == 0:
			j = x // i
			if j <= n and i != j:
				t += 2
			elif j <= n and i == j:
				t += 1
	print(t)


(n, x) = map(int, input().split())
div = []
j = 1
rr = int(x ** 0.5)
while j <= rr:
	if x % j == 0:
		a = j
		b = x // j
		if a <= n and b <= n:
			div.append(a)
			if a != b:
				div.append(b)
	j += 1
print(len(div))


import itertools, functools, math

def solve():
	(n, x) = map(int, input().split())
	r = 0
	for op in range(1, min(n, x) + 1):
		if x % op == 0:
			other = x // op
			if other <= n:
				r += 1
	return r
print(solve())


(n, x) = (int(y) for y in input().split())
count = 0
for i in range(1, n + 1):
	div = x / i
	if div == int(div) and div >= 1 and (div <= n):
		count += 1
print(count)


(n, x) = map(int, input().split(' '))
ans = 0
high = n if n < x else x
low = 0
for i in range(high, low, -1):
	if x % i == 0 and x / i <= n:
		ans += 1
print(ans)


(n, x) = (int(x) for x in input().split())
ans = 0
for i in range(1, n + 1):
	if x % i == 0:
		j = x // i
		if 1 <= j <= n:
			ans += 1
print(ans)


x = list(map(int, input().split()))
t = 0
for i in range(1, x[0] + 1):
	if x[1] in range(i, i * x[0] + 1, i):
		t += 1
print(t)


(n, m) = map(int, input().split())
sum = 0
if n >= m:
	sum += 1
for i in range([n, m][n >= m], 1, -1):
	if m % i == 0:
		if m // i <= n:
			sum += 1
print(sum)


import unittest
import sys

class Table:

	def __init__(self, test_inputs=None):
		it = iter(test_inputs.split('\n')) if test_inputs else None

		def uinput():
			return next(it) if it else sys.stdin.readline().rstrip()
		[self.n, self.m] = map(int, uinput().split())

	def calculate(self):
		result = 0
		for i in range(1, self.n + 1):
			if self.m % i == 0 and self.m // i <= self.n:
				result += 1
		return str(result)

class unitTests(unittest.TestCase):

	def test_single_test(self):
		test = '10 5'
		d = Table(test)
		self.assertEqual(d.n, 10)
		self.assertEqual(d.m, 5)
		self.assertEqual(Table(test).calculate(), '2')
		test = '6 12'
		self.assertEqual(Table(test).calculate(), '4')
		test = '5 13'
		self.assertEqual(Table(test).calculate(), '0')
		test = '2 2'
		self.assertEqual(Table(test).calculate(), '2')

	def time_limit_test(self, nmax):
		import random
		import timeit
		test = str(nmax) + ' ' + str(nmax) + '\n'
		numnums = [str(i) + ' ' + str(i + 1) for i in range(nmax)]
		test += '\n'.join(numnums) + '\n'
		nums = [random.randint(1, 10000) for i in range(nmax)]
		test += ' '.join(map(str, nums)) + '\n'
		start = timeit.default_timer()
		d = Table(test)
		calc = timeit.default_timer()
		d.calculate()
		stop = timeit.default_timer()
		print('\nTimelimit Test: ' + '{0:.3f}s (init {1:.3f}s calc {2:.3f}s)'.format(stop - start, calc - start, stop - calc))
sys.setrecursionlimit(100000)
if sys.argv[-1] == '-ut':
	unittest.main(argv=[' '])
sys.stdout.write(Table().calculate())


import math
(n, x) = [int(x) for x in input().split(' ')]
s = math.floor(math.sqrt(x)) + 1
a = 0
if x != 1:
	for y in range(1, s):
		if y > n or x > n ** 2:
			break
		if x % y == 0:
			c = x / y
			if c <= n:
				if c == y:
					a += 1
				else:
					a += 2
	print(a)
else:
	print(1)


import math

def val_search(arr):
	x = int(arr[1])
	n = int(arr[0])
	c = 0
	for i in range(1, n + 1):
		if x % i == 0 and x / i <= n:
			c += 1
	print(c)
input_arr = input().split(' ')
val_search(input_arr)


(n, m) = [int(x) for x in input().split()]
a = []
for i in range(1, n + 1):
	if m % i == 0 and m // i <= n:
		a.append(i)
print(len(a))


z = list(map(int, input().split()))
a = 0
for i in range(1, z[0] + 1):
	if z[1] % i == 0 and z[1] <= i * z[0]:
		a += 1
print(a)


(num, target) = map(int, input().strip().split(' '))
cnt = 0
for x in range(1, num + 1):
	if target % x == 0 and target / x <= num:
		cnt += 1
print(cnt)


a = input().split(' ')
n = int(a[0])
x = int(a[1])
count = 0
for i in range(1, n + 1):
	if i == 1 and n >= x:
		count += 1
	elif x % i == 0 and i != 1 and (x <= n * i):
		count += 1
print(count)


(a, b) = map(int, input().split())
import math
c = 0
for i in range(1, min(a + 1, int(math.sqrt(b)) + 1)):
	if b % i == 0 and b // i <= a:
		if i * i == b:
			c += 1
		else:
			c += 2
print(c)


tmp = str(input()).split(' ')
result = 0
for i in range(1, int(tmp[0]) + 1):
	if int(tmp[1]) % i == 0 and int(tmp[1]) / i <= int(tmp[0]):
		result += 1
print(result)


(a, b) = input().split()
a = int(a, 10)
b = int(b, 10)
l = 0
k = a * a
for i in range(1, a + 1):
	k1 = int(b / i)
	if k1 * i == b and k1 <= a:
		l += 1
print(l)


def solve():
	(n, m) = map(int, input().split())
	ans = 0
	for i in range(1, n + 1):
		if m / i <= n and m % i == 0:
			ans = ans + 1
	print(ans)
solve()


from math import sqrt
(N, X) = input().split()
N = int(N)
X = int(X)
res = set()
for i in range(1, max(int(sqrt(X) + 1), N)):
	if X % i != 0:
		continue
	if X // i <= N:
		res.add((i, X // i))
		res.add((X // i, i))
print(len(res))


(n, x) = map(int, input().split())
l2 = []
if n >= x:
	for i in range(1, n + 1):
		if x % i == 0:
			l2.append(i)
else:
	for i in range(2, n + 1):
		if x % i == 0:
			if x // i <= n:
				l2.append(i)
print(len(l2))


(n, x) = input().split()
nb = 0
n = int(n)
x = int(x)
div = [y for y in range(1, n + 1) if x % y == 0]
for i in div:
	for j in div:
		if i * j == x:
			nb += 1
		j += 1
	i += 1
print(nb)


def main():
	(n, x) = [int(x) for x in input().split()]
	ret = 0
	for i in range(1, n + 1):
		if x % i == 0:
			g = int(x / i)
			if g >= 1 and g <= n:
				ret += 1
	print(ret)
main()


nx = input().split()
n = int(nx[0])
x = int(nx[1])
z = int(x ** 0.5)
count = 0
for i in range(1, z + 1):
	if x % i == 0:
		if i <= n and x // i <= n:
			if i * i != x:
				count += 2
			else:
				count += 1
	else:
		count += 0
print(count)


(b, a) = [int(x) for x in input().split()]
if a == 1:
	print(1)
else:
	ans = 0
	for i in range(2, b):
		if i > int(a ** 0.5 // 1):
			break
		if a % i == 0 and a // i <= b and (i ** 2 != a):
			ans += 2
	if int(a ** 0.5) ** 2 == a and int(a ** 0.5) <= b:
		ans += 1
	if a <= b:
		ans += 2
	print(ans)


__author__ = 'taras-sereda'
(n, x) = map(int, input().split())
r = 0
for i in range(1, n + 1):
	(c, o) = divmod(x, i)
	if o == 0 and c <= n:
		r += 1
print(r)


w = input().split()
x = int(w[0])
y = int(w[1])
c = 0
i = 1
while i <= x:
	z = i * x
	if y % i == 0 and y <= z:
		c += 1
	i += 1
print(c)


(n, y) = map(int, input().split())
counter = 0
for i in range(1, n + 1):
	if y <= i * n and y % i == 0:
		counter += 1
print(counter)


from math import sqrt
(n, a) = map(int, input().split())
c = 0
for i in range(1, n + 1):
	if a % i == 0:
		if a // i <= n:
			c += 1
print(c)


import math
from collections import defaultdict, Counter, deque
INF = float('inf')

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

def isPrime(n):
	if n <= 1:
		return False
	i = 2
	while i ** 2 <= n:
		if n % i == 0:
			return False
		i += 1
	return True

def vars():
	return map(int, input().split())

def array():
	return list(map(int, input().split()))

def main():
	(n, x) = vars()
	i = 1
	cnt = 0
	while i * i <= x:
		if x % i == 0:
			j = x // i
			if i <= n and j <= n:
				if i != j:
					cnt += 1
				cnt += 1
		i += 1
	print(cnt)
t = 1
for _ in range(t):
	main()


(n, x) = map(int, input().split())
c = 0
if n * n < x:
	print(0)
else:
	for i in range(1, n + 1):
		if x % i == 0:
			j = x // i
			if j <= n:
				c += 1
	print(c)


(n, m) = [int(i) for i in input().split()]
i = 1
count = 0
while i <= n:
	if m % i == 0 and m // i <= n:
		count += 1
	i += 1
print(count)


from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
(n, x) = map(int, input().split())
b = []
l = list(factors(x))
for i in l:
	q = int(x / i)
	if q <= n and i <= n:
		b.append(i)
		b.append(q)
print(len(set(b)))


(n, x) = input().split()
(n, x) = (int(n), int(x))
t = 0
for i in range(1, n + 1):
	t += x // i == x / i and x // i <= n
print(t)


from math import sqrt
a = input().split()
a = list(map(int, a))
n = a[0]
x = a[1]
d = 0
for i in range(1, min(x, n) + 1):
	if x % i == 0:
		if x // i <= n:
			d += 1
print(d)


print((lambda n, x: sum([1 for f in range(1, n + 1) if x % f == 0 and x // f <= n]))(*map(int, input().split())))


(l, x) = map(int, input().split())
cnt = 0
for i in range(1, l + 1):
	if x % i == 0 and x / i <= l:
		cnt += 1
print(cnt)


import math
(n, x) = map(int, input().split(' '))
res = 0
q = int(math.sqrt(x) + 1)
for i in range(1, q):
	if x % i == 0:
		if i <= n and x // i <= n:
			res += 2
			if i == x // i:
				res -= 1
print(res)


from math import sqrt
(n, x) = map(int, input().split())
c = 0
t = []
for i in range(1, n + 1):
	if x % i == 0 and int(x / i) <= n:
		c = c + 1
print(c)


(n, m) = map(int, input().split())
l = [i for i in range(1, n + 1) if m % i == 0 and m // i <= n]
print(len(l))


(n, x) = [int(a) for a in input().split()]
cnt = 0
for i in range(1, n + 1):
	if i * i == x:
		print(cnt * 2 + 1)
		break
	elif i * i > x:
		print(cnt * 2)
		break
	if x % i == 0 and x // i <= n:
		cnt += 1
else:
	print(cnt)


(n, x) = map(int, input().split())
a = {1, 2}
a.remove(1)
a.remove(2)
for i in range(1, n + 1):
	if x % i == 0 and x / i <= n:
		a.add(i)
print(len(a))


import math
(n, m) = map(int, input().split())
ans = 0
for i in range(1, int(math.sqrt(m)) + 1):
	if m % i == 0:
		if i <= n and m // i <= n:
			ans += 2
if int(math.sqrt(m)) == math.sqrt(m) and math.sqrt(m) <= n:
	ans -= 1
print(ans)


def sol():
	(n, x) = map(int, input().split())
	s = 0
	i = 1
	cnt = 0
	while i <= n:
		if x % i == 0 and x / i <= n:
			cnt += 1
		i += 1
	print(cnt)
sol()


(m, n) = map(int, input().split())
a = 0
for i in range(1, m + 1):
	if i > n:
		break
	if n <= m * i and n % i == 0:
		a += 1
print(a)


def primeFactors(n):
	l = []
	i = 2
	n1 = n
	while n1 > 1:
		while n1 % i == 0:
			l.append(i)
			n1 = n1 // i
		i = i + 1
	return l
import sys
import math
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
q = inlt()
n = q[0]
x = q[1]
ct = 0
for i in range(1, n + 1):
	if x % i == 0:
		if i <= n:
			if x // i <= n:
				ct = ct + 1
print(ct)


t = 1
while t > 0:
	t -= 1
	(n, x) = map(int, input().split())
	cnt = 0
	for i in range(1, n + 1):
		if x % i == 0 and x / i <= n:
			cnt += 1
	print(cnt)


x = list(map(int, input().split()))
fact = 0
for i in range(1, x[0] + 1):
	if x[1] % i == 0 and x[1] / i <= x[0]:
		fact += 1
print(fact)


(n, nx) = map(int, input().split())
ans = 0
for i in range(1, n + 1):
	if nx % i == 0 and nx / i <= n:
		ans += 1
print(ans)


from math import sqrt
(m_r, divi) = [int(i) for i in input().split()]
m_div = int(sqrt(divi)) + 1
divis = []
for div in range(1, m_div):
	if not divi % div:
		r = divi // div
		if not r > m_r:
			divis.append(div)
			if not r == div:
				divis.append(r)
print(len(divis))


l = [int(x) for x in input().split()]
n = l[0]
count = 0
x = l[1]
p = []
for i in range(1, n + 1):
	if x % i == 0:
		p.append(i)
for i in range(len(p)):
	y = int(x / p[i])
	if y in p:
		count = count + 1
print(count)


(x, n) = map(int, input().split())
d = 1
res = 0
while d < n ** 0.5:
	if n % d == 0 and d <= x and (n // d <= x):
		res += 2
	d += 1
if d * d == n and d <= x:
	res += 1
print(res)


import math
(n, x) = map(int, input().split(' '))
c = 0
for j in range(2, n + 1):
	if not x % j:
		p = x // j
		if p <= n:
			c += 1
if x <= n:
	c += 1
print(c)