Ivan has number $b$. He is sorting through the numbers $a$ from $1$ to $10^{18}$, and for every $a$ writes $\frac{[a, \,\, b]}{a}$ on blackboard. Here $[a, \,\, b]$ stands for least common multiple of $a$ and $b$. Ivan is very lazy, that's why this task bored him soon. But he is interested in how many different numbers he would write on the board if he would finish the task. Help him to find the quantity of different numbers he would write on the board.


-----Input-----

The only line contains one integer — $b$ $(1 \le b \le 10^{10})$.


-----Output-----

Print one number — answer for the problem.


-----Examples-----
Input
1

Output
1
Input
2

Output
2


-----Note-----

In the first example $[a, \,\, 1] = a$, therefore $\frac{[a, \,\, b]}{a}$ is always equal to $1$.

In the second example $[a, \,\, 2]$ can be equal to $a$ or $2 \cdot a$ depending on parity of $a$. $\frac{[a, \,\, b]}{a}$ can be equal to $1$ and $2$.

Difficulty: EASY
Tags: Number theory

Mathematics

Starter code:

Solutions:
import math
entrada = int(input())
mutiplos = 0
for i in range(1, int(math.sqrt(entrada)) + 1):
	if entrada % i == 0:
		if entrada / i == i:
			mutiplos += 1
		else:
			mutiplos += 2
print(mutiplos)


n = int(input())
p = 0
for j in range(1, int(n ** 0.5) + 1):
	if n % j == 0:
		p += 1
		if n // j != j:
			p += 1
print(p)


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


b = int(input())
(r, x) = (0, 1)
while x * x < b:
	if b % x < 1:
		r += 2
	x += 1
if x * x == b:
	r += 1
print(r)


I = lambda : map(int, input().split())
n = int(input())
s = sum((n % i == 0 for i in range(1, int(n ** 0.5) + 1)))
if int(n ** 0.5) ** 2 == n:
	print(2 * s - 1)
else:
	print(s * 2)


b = int(input())
ar = set()
i = 1
while i * i <= b:
	if b % i == 0:
		ar.add(i)
		ar.add(b // i)
	i += 1
print(len(ar))


from math import *
from itertools import *
from functools import *

def scanLine(dtype):
	return list(map(dtype, input().split()))
b = scanLine(int)[0]
pfactors = [1]
for p in range(2, b):
	if p * p > b:
		break
	k = 0
	while b % p == 0:
		b /= p
		k += 1
	if k > 0:
		pfactors.append(k + 1)
if b > 1:
	pfactors.append(2)
print(reduce(int.__mul__, pfactors))


import math

def countDivisors(n):
	cnt = 0
	for i in range(1, int(math.sqrt(n)) + 1):
		if n % i == 0:
			if n / i == i:
				cnt = cnt + 1
			else:
				cnt = cnt + 2
	return cnt
b = int(input())
print(countDivisors(b))


n = int(input())
c = 0
a = []
for i in range(1, int(n ** 0.5 + 1)):
	if n % i == 0:
		if n // i == i:
			a.append(i)
		else:
			a.append(n // i)
			a.append(i)
print(len(a))


from math import sqrt
b = int(input())
sqb = int(sqrt(b))
res = 0
for i in range(1, sqb + 1):
	if b % i == 0:
		res = res + 2
if sqb ** 2 == b:
	res = res - 1
print(res)


b = int(input())
i = 1
count = 0
while i <= b ** 0.5:
	if b % i == 0:
		count += 1
		if i * i != b:
			count += 1
	i += 1
print(count)


def divuntil(n, div):
	k = 0
	while int(n) % div == 0:
		n = n / div
		k += 1
	return (int(n), k)

def divexps(n):
	start = 2
	while n > 1:
		k = 0
		for i in range(start, int(n ** 0.5 + 1), 2 if start > 2 else 1):
			if n % i == 0:
				(n, k) = divuntil(n, i)
				start = i
				yield (k, start)
				break
		else:
			yield (1, n)
			break

def countdiv(n):
	if n > 1:
		count = 1
		for (divexp, div) in divexps(n):
			count *= divexp + 1
		return count
	else:
		return 1
n = int(input())
print(countdiv(n))


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)))
b = int(input())
result = 2
result += len(factors(b)) - 2
print(result)


import sys
for _ in range(1):
	n = int(input())
	c = 0
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			if i * i != n:
				c += 2
			else:
				c += 1
	print(c)


a = int(input())
ans = 0
for i in range(1, int(a ** 0.5) + 1):
	if i * i == a:
		ans += 1
	elif a % i == 0:
		ans += 2
print(ans)


b = int(input())
cnt = 1
for i in range(2, 10 ** 5, 1):
	c = 0
	while b % i == 0:
		c += 1
		b //= i
	cnt *= c + 1
if b > 1:
	cnt *= 2
print(cnt)


def divisors(n):
	divisior = 0
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			if n / i == i:
				divisior += 1
			else:
				divisior += 2
	return divisior
print(divisors(int(input())))


import math
b = int(input())
ans = 0
krai = math.ceil(math.sqrt(b))
for i in range(1, krai):
	if b % i == 0:
		ans += 1
if krai * krai == b:
	print(2 * ans + 1)
else:
	print(ans * 2)


a = int(input())
(cnt, i) = (0, 1)
while i * i < a:
	if a % i == 0:
		cnt += 2
	i += 1
print([cnt, cnt + 1][i * i == a])


import math

def is_prime(x):
	for i in range(2, int(math.sqrt(x)) + 1):
		if not x % i:
			return False
	return True

def factorize(n):
	if n == 1:
		return 1
	else:
		factors = 1
		s = math.sqrt(n) + 1
		x = 2
		start = n
		while x <= s:
			if is_prime(x):
				result = 1
				while not n % x:
					result += 1
					n //= x
				if result >= 2:
					factors *= result
			x += 1
		if is_prime(n) and n > 1:
			factors *= 2
		if factors == 1:
			factors = 2
		return factors

class CodeforcesTask1068BSolution:

	def __init__(self):
		self.result = ''
		self.b = 0

	def read_input(self):
		self.b = int(input())

	def process_task(self):
		self.result = str(factorize(self.b))

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


a = int(input())
x = 0
p = int(a ** 0.5)
k = p * p == a
for i in range(1, p + 1 - k):
	if a % i == 0:
		x += 2
x += k
print(x)


n = int(input())
fact_set = set()
sq_x = int(n ** 0.5)
for i in range(1, sq_x + 1):
	(q, r) = (n / i, n % i)
	if r == 0:
		fact_set.add(q)
		fact_set.add(i)
print(len(fact_set))


b = int(input())
s = 2
d = 2
while d * d <= b:
	if b % d == 0:
		s += 2
	d += 1
if b ** 0.5 == int(b ** 0.5):
	s -= 1
print(s)


n = int(input())
k = 0
for i in range(2, int(n ** 0.5) + 1):
	if n % i == 0:
		k += 1
k *= 2
if n != 1:
	k += 2
else:
	k += 1
if n % int(n ** 0.5) == 0 and n ** 0.5 - int(n ** 0.5) == 0 and (n != 1):
	k -= 1
print(k)


n = int(input())
c = 0
for i in range(1, int(n ** 0.5) + 1):
	c += (n % i == 0) * 2
c -= int(n ** 0.5) ** 2 == n
print(c)


a = int(input())
ans = 0
i = 1
while i * i < a:
	if a % i == 0:
		ans += 2
	i = i + 1
if i * i == a:
	ans += 1
print(ans)


n = int(input())
s = set()
for i in range(1, int(n ** 0.5) + 1):
	if n % i == 0:
		s.add(i)
		s.add(n // i)
print(len(s))


def get_int():
	from sys import stdin
	return int(stdin.readline().replace('\n', ''))

def test(b):
	n_div_b = 0
	i = 1
	while i ** 2 <= b:
		if b % i == 0:
			n_div_b += 1
			if i ** 2 != b:
				n_div_b += 1
		i += 1
	return n_div_b
print(test(get_int()))


s = 0
a = int(input())
from math import *
for i in range(1, floor(sqrt(a)) + 1):
	if a % i == 0:
		s += 2 - (i == ceil(a / i))
print(s)


import math
t = int(input())
p = math.pow(t, 0.5)
i = 1
c = 0
while i <= p:
	if t % i == 0:
		j = t // i
		if j != i:
			c += 2
		else:
			c += 1
	i += 1
print(c)


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

def fact(n):
	ss = n ** 0.5
	ss = int(ss) + 1
	c = 0
	for i in range(1, ss):
		if n % i == 0:
			if n // i == i:
				c += 1
			else:
				c += 2
	return c
b = int(input())
if isPrime(b):
	print(2)
else:
	print(fact(b))


import sys
import math
import itertools
import functools
import collections
import operator
import fileinput
import copy
ORDA = 97

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

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

def li():
	return [int(i) for i in input().split()]

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

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

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

def divs(n, start=2):
	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 divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

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

def convn(number, base):
	new_number = 0
	while number > 0:
		new_number += number % base
		number //= base
	return new_number

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

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

def main():
	a = int(input())
	(cnt, i) = (0, 1)
	while i * i < a:
		if a % i == 0:
			cnt += 2
		i += 1
	print([cnt, cnt + 1][i * i == a])
main()


from math import sqrt
n = int(input())
c = 0
for i in range(1, int(sqrt(n)) + 1):
	if n % i == 0:
		if n // i == i:
			c += 1
		else:
			c += 2
print(c)


from math import *
n = int(input())
summ = 0
for i in range(1, int(sqrt(n)) + 1):
	if n % i == 0 and i != sqrt(n):
		summ += 2
	if i == sqrt(n):
		summ += 1
print(summ)


from math import sqrt
b = int(input())
ans = sum((b % i == 0 for i in range(1, max(2, int(sqrt(b) + 1)))))
print(ans * 2 - (int(sqrt(b)) * int(sqrt(b)) == b))


from collections import Counter

def primes(n):
	primfac = []
	cnt = Counter()
	d = 2
	while d * d <= n:
		while n % d == 0:
			cnt[d] += 1
			n //= d
		d += 1
	if n > 1:
		cnt[n] += 1
	return list(cnt.values())

def run():
	b = int(input())
	occ = primes(b)
	res = 1
	for e in occ:
		res *= e + 1
	print(res)
run()


import math
n = int(input())
s = int(0)
for i in range(1, int(math.sqrt(n)) + 1):
	if n % i == 0:
		if i == math.sqrt(n):
			s += 1
		else:
			s += 2
print(s)


import math, itertools

def p_fact(n):
	factors = []
	dividor = 2
	lim = int(n ** 0.5) + 1
	while n > 1 and dividor < lim:
		while n % dividor == 0:
			factors.append(dividor)
			n //= dividor
		dividor += 1
	if n != 1:
		factors.append(n)
	return factors
prime_factors = p_fact(int(input()))
ways = 1
prime_factors.append(-1)
this_factor_count = 0
for (i, f) in enumerate(prime_factors[:-1]):
	this_factor_count += 1
	if f != prime_factors[i + 1]:
		ways *= this_factor_count + 1
		this_factor_count = 0
print(ways)


def noofdivisors(n):
	i = 1
	s = 0
	while i * i <= n:
		if n % i == 0:
			if i * i == n:
				s += 1
				i += 1
			else:
				s += 2
				i += 1
		else:
			i += 1
	else:
		return s
n = int(input())
print(noofdivisors(n))


import sys, bisect

def factorization(num):
	res = dict()
	for i in range(2, int(num ** 0.5) + 1):
		while num % i == 0:
			if i not in res:
				res[i] = 1
			else:
				res[i] += 1
			num //= i
	if num > 1:
		res[num] = 1
	return res
n = int(sys.stdin.readline())
res = factorization(n)
ans = 1
for i in res:
	ans *= res[i] + 1
print(ans)


def fact(n):
	if n == 1:
		return 1
	elif n == 2:
		return 2
	elif n == 3:
		return 2
	else:
		c = 0
		x = int(n ** 0.5)
		if x * x == n:
			for i in range(1, x):
				if n % i == 0:
					c += 2
			c += 1
			return c
		else:
			x = x + 1
			for i in range(1, x):
				if n % i == 0:
					c += 2
			return c
n = int(input())
print(fact(n))


import math
b = int(input())
ans = set([1])
for i in range(1, int(math.sqrt(b)) + 1):
	if b % i == 0:
		ans.add(b // i)
		ans.add(i)
ans.add(b)
print(len(ans))


import sys
input = sys.stdin.readline

def print(val):
	sys.stdout.write(str(val) + '\n')
a = int(input())
divisors = 0
for i in range(1, int(a ** 0.5) + 1):
	if a % i == 0:
		divisors += 1
if int(a ** 0.5) ** 2 == a:
	total = 2 * divisors - 1
else:
	total = 2 * divisors
print(total)


[n] = map(int, input().split())
from math import sqrt

def div_count(x):
	if x == 1:
		return 1
	r = int(sqrt(x))
	ans = -(r * r == n)
	for i in range(1, r + 1):
		if x % i == 0:
			ans += 2
	return ans
print(div_count(n))


def prime(b):
	i = 1
	if b == 1:
		return 1
	count = 0
	while i * i <= b:
		if b % i == 0:
			if i * i != b:
				count += 2
			else:
				count += 1
		i += 1
	return count
b = int(input())
print(prime(b))


import math

def number(b):
	count = 0
	for i in range(1, int(math.sqrt(b)) + 1):
		if b % i == 0:
			count = count + 1
	if math.sqrt(b).is_integer() == True:
		return 2 * count - 1
	else:
		return 2 * count
b = int(input())
print(number(b))


def print_return(func):

	def wrapper(*args, **kwargs):
		retval = func(*args, **kwargs)
		print(retval)
		return retval
	return wrapper

class Solve:

	@print_return
	def solve_a(lines=None):
		if lines is None:
			(n, m, k, l) = (int(x) for x in input().split())
		else:
			(n, m, k, l) = (int(x) for x in lines[0].split())
		x = k + l + m - 1
		x //= m
		if x * m > n:
			return -1
		return x

	@print_return
	def solve_b(lines=None):
		if lines is None:
			b = int(input())
		else:
			b = int(lines[0])
		divisors = set()
		for x in range(1, int(b ** 0.5) + 5):
			if b % x == 0:
				divisors.add(x)
				divisors.add(b // x)
		return len(divisors)

	@print_return
	def solve_c(lines=None):
		if lines is None:
			(n, m) = (int(x) for x in input().split())
			good_pairs = [tuple((int(x) for x in input().split())) for _ in range(m)]
		else:
			(n, m) = (int(x) for x in lines[0].split())
			good_pairs = [tuple((int(x) for x in lines[j + 1].split())) for j in range(m)]
Solve.solve_b()


b = int(input())
i = 1
resp = 0
while i * i <= b:
	if b % i == 0:
		resp += 1
		if i * i != b:
			resp += 1
	i += 1
print(resp)


import math
C = 10 ** 18

def main():
	n = int(input())
	cnt = 0
	for i in range(1, 1 + int(math.sqrt(n))):
		if n % i == 0:
			cnt += 2
			if n // i == i:
				cnt -= 1
	print(cnt)
main()


from math import *
from itertools import *
from functools import *

def ceilInt(a, b):
	return a if b == 1 else (a + b - 1) // b

def scanLine(dtype):
	return list(map(dtype, input().split()))
b = scanLine(int)[0]

def factorize(b, p):
	k = 0
	while b % p == 0:
		b /= p
		k += 1
	return (b, k + 1)
(b, ans) = factorize(b, 2)
p = 3
while p * p <= b:
	(b, k) = factorize(b, p)
	p += 2
	ans *= k
if b != 1:
	ans *= 2
print(ans)


from math import sqrt

def num_divs(n):
	ans = 0
	for d in range(1, int(sqrt(n)) + 1):
		if n % d == 0:
			ans += 1
			ans += n // d > int(sqrt(n))
	return ans
print(num_divs(int(input())))


import math

def prime_factors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(i)
			n = n / i
	if n > 2:
		l.append(n)
	return l
n = int(input())
if n == 1:
	print(1)
else:
	l = prime_factors(n)
	if len(l) == 1:
		print(2)
	else:
		z = list(set(l))
		x = []
		for i in z:
			x.append(l.count(i) + 1)
		res = 1
		for i in x:
			res *= i
		print(res)


from math import *
from itertools import *
from functools import *

def scanLine(dtype):
	return list(map(dtype, input().split()))
B = scanLine(int)[0]
C = int(floor(sqrt(B)))
print(sum((1 for p in range(2, C + 1) if B % p == 0)) * 2 + 2 - 1 * (C * C == B))


import math

def GCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def printDivisors(n):
	i = 1
	li = []
	while i <= math.sqrt(n):
		if n % i == 0:
			if n / i == i:
				li.append(i)
			else:
				li.append(i)
				li.append(n // i)
		i = i + 1
	return li
b = int(input())
l = printDivisors(b)
print(len(l))


import math

def lcm():
	n = int(input())
	count = 0
	for i in range(1, int(math.sqrt(n)) + 1):
		if n % i == 0 and i != math.sqrt(n):
			count += 2
		elif n % i == 0 and i == math.sqrt(n):
			count += 1
	print(count)
lcm()


n = int(input())
c = 0
for i in range(1, int(pow(n, 0.5)) + 1):
	if n % i == 0:
		if n // i == i:
			c += 1
		else:
			c += 2
print(c)


import math

def div(n):
	k = math.ceil(math.sqrt(n))
	ans = 0
	for i in range(1, k):
		if n % i == 0:
			ans += 2
	if k * k == n:
		ans += 1
	return ans
n = int(input())
print(div(n))


b = int(input())
mas = []
i = 1
while i * i <= b:
	if b % i == 0:
		mas.append(i)
		mas.append(b // i)
	i += 1
mas = list(set(mas))
print(len(mas))


import sys
from math import *

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

def mint():
	return int(minp())

def mints():
	return map(int, minp().split())
MAX = 10 ** 5 + 1
sieve = [True] * MAX
sieve[0] = False
sieve[1] = False
primes = []
for i in range(2, MAX):
	if sieve[i]:
		primes.append(i)
		for j in range(i + i, MAX, i):
			sieve[j] = False
n = mint()
i = 0
r = 1
while True:
	x = primes[i]
	if x * x > n:
		if n != 1:
			r *= 2
		break
	c = 0
	while n % x == 0:
		n //= x
		c += 1
	if c != 0:
		r *= c + 1
	i += 1
print(r)


b = int(input())
c = 0
i = 1
while i <= b ** 0.5:
	if i == b ** 0.5:
		c += 1
	elif b % i == 0:
		c += 2
	i += 1
print(c)


import math
b = int(input())
ans = 0
for i in range(1, int(math.sqrt(b)) + 1):
	if b % i == 0:
		ans += 1
		c = b // i
		if i != c:
			ans += 1
print(ans)


n = int(input())
answer = 0
i = 1
while i * i < n:
	if n % i == 0:
		answer += 2
	i += 1
if i * i == n:
	answer += 1
print(answer)


n = int(input())
x = int(n ** 0.5)
res = 0
for i in range(1, x + 1):
	if n % i == 0:
		res += 2 - (i ** 2 - n == 0)
print(res)


import math

def printDivisors(n):
	s = set()
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n / i == i:
				s.add(i)
			else:
				s.add(i)
				s.add(n // i)
		i = i + 1
	return len(s)
n = int(input())
print(printDivisors(n))


from math import sqrt as S

def num_div(n):
	if n == 1:
		return 1
	c = 2
	for i in range(2, int(S(n)) + 1):
		if n % i == 0:
			if i == n // i:
				c += 1
			else:
				c += 2
	return c
print(num_div(int(input())))


import math

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a
a = int(input())
b = set()
b.add(a)
b.add(1)
for i in range(2, math.ceil(math.sqrt(a)) + 1):
	if a % i == 0:
		b.add(i)
		b.add(a // i)
print(len(b))


from math import ceil, sqrt

def main():
	b = int(input())
	A = set()
	for a in range(1, ceil(sqrt(b)) + 1):
		if b % a == 0:
			A.add(a)
			A.add(b // a)
	print(len(A))
main()


from functools import reduce
n = int(input())
print(len(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))))


from functools import reduce

def factors(n):
	return len(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))

def prime(n):
	if n == 1:
		return False
	i = 2
	while i * i <= n:
		if n % i == 0:
			return False
		i += 1
	return True
b = int(input())
x = prime(b)
if x:
	print(2)
else:
	print(factors(b))


from sys import stdin, stdout
from collections import *
from math import factorial
st = lambda : list(stdin.readline().strip())
li = lambda : list(map(int, stdin.readline().split()))
mp = lambda : map(int, stdin.readline().split())
inp = lambda : int(stdin.readline())
pr = lambda n: stdout.write(str(n) + '\n')
dx = [-1, 1, 0, 0]
dy = [0, 0, 1, -1]

def solve():
	n = inp()
	i = 1
	ans = 0
	while i * i <= n:
		if n % i == 0:
			ans += 1
			if i != n // i:
				ans += 1
		i += 1
	pr(ans)
for _ in range(1):
	solve()


z = input
mod = 10 ** 9 + 7
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0:
			return 0
	return 1
z = input
mod = 10 ** 9 + 7
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0:
			return 0
	return 1
n = int(z())
c = 0
i = 1
while i * i <= n:
	if n % i == 0:
		c += 1 + (n // i > i)
	i += 1
print(c)


import math
b = int(input())
i = 2
result = 2
if b == 1 or b == 2:
	print(b)
else:
	while i < math.sqrt(b):
		flag = False
		if b % i == 0:
			result += 2
		i += 1
	if i == math.sqrt(b):
		result += 1
	print(result)


import math
b = int(input())
(i, count) = (1, 0)
while i <= math.sqrt(b):
	if b % i == 0:
		if i * i == b:
			count += 1
		else:
			count += 2
	i += 1
print(count)


import math as m
import copy

def factors(x):
	y = x
	s = []
	for i in range(2, int(m.sqrt(x)) + 1):
		if x % i == 0:
			count = 0
			while x % i == 0:
				x /= i
				count += 1
			s.append((i, count))
	if x != 1:
		s.append((x, 1))
	return s
x = int(input())
x = factors(x)
res = 1
for (i, j) in x:
	res *= j + 1
print(res)


import os
import sys
from io import BytesIO, IOBase
import math
import itertools
import bisect
import heapq

def main():
	pass
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

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 primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(i)
			n = n / i
	if n > 2:
		l.append(int(n))
	return l

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 maxPrimeFactors(n):
	maxPrime = -1
	while n % 2 == 0:
		maxPrime = 2
		n >>= 1
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			maxPrime = i
			n = n / i
	if n > 2:
		maxPrime = n
	return int(maxPrime)

def countcon(s, i):
	c = 0
	ch = s[i]
	for i in range(i, len(s)):
		if s[i] == ch:
			c += 1
		else:
			break
	return c

def lis(arr):
	n = len(arr)
	lis = [1] * n
	for i in range(1, n):
		for j in range(0, i):
			if arr[i] > arr[j] and lis[i] < lis[j] + 1:
				lis[i] = lis[j] + 1
	maximum = 0
	for i in range(n):
		maximum = max(maximum, lis[i])
	return maximum

def isSubSequence(str1, str2):
	m = len(str1)
	n = len(str2)
	j = 0
	i = 0
	while j < m and i < n:
		if str1[j] == str2[i]:
			j = j + 1
		i = i + 1
	return j == m

def maxfac(n):
	root = int(n ** 0.5)
	for i in range(2, root + 1):
		if n % i == 0:
			return n // i
	return n

def p2(n):
	c = 0
	while n % 2 == 0:
		n //= 2
		c += 1
	return c

def seive(n):
	primes = [True] * (n + 1)
	primes[1] = primes[0] = False
	for i in range(2, n + 1):
		if primes[i]:
			for j in range(i + i, n + 1, i):
				primes[j] = False
	p = []
	for i in range(0, n + 1):
		if primes[i]:
			p.append(i)
	return p

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def denofactinverse(n, m):
	fac = 1
	for i in range(1, n + 1):
		fac = fac * i % m
	return pow(fac, m - 2, m)

def numofact(n, m):
	fac = 1
	for i in range(1, n + 1):
		fac = fac * i % m
	return fac
n = int(input())
root = int(n ** 0.5)
f = 0
for i in range(1, root + 1):
	if i * i == n:
		f += 1
	elif n % i == 0:
		f += 2
print(f)


b = int(input())
i = 1
output = 0
while i * i <= b:
	if b % i == 0:
		output += 1
		if i * i != b:
			output += 1
	i += 1
print(output)


import math as ma
import sys
from sys import exit
from decimal import Decimal as dec
from itertools import permutations

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

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

def nu():
	return int(input())

def find_gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
n = nu()
z = 0
i = 1
while i <= ma.sqrt(n):
	if n % i == 0:
		if n / i == i:
			z += 1
		else:
			z += 2
	i = i + 1
print(z)


import math
count = 0
b = int(input())
for i in range(1, int(b ** 0.5 + 1)):
	if b % i == 0:
		count += 1
if int(b ** 0.5) ** 2 == b:
	exit(print(count * 2 - 1))
print(2 * count)


import math
b = int(input())
k = 1
c = 0
x = math.floor(b ** 0.5)
while k <= x:
	if b % k == 0:
		c += 2
	k += 1
if x * x == b:
	c -= 1
print(c)


from sys import stdin, stdout
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353

def inp():
	return stdin.readline().strip()

def iinp():
	return int(inp())

def out(var, end='\n'):
	stdout.write(str(var) + '\n')

def outa(*var, end='\n'):
	stdout.write(' '.join(map(str, var)) + end)

def lmp():
	return list(mp())

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

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(m, val) for j in range(n)]

def ceil(a, b):
	return (a + b - 1) // b
S1 = 'abcdefghijklmnopqrstuvwxyz'
S2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

def isprime(x):
	if x <= 1:
		return False
	if x in (2, 3):
		return True
	if x % 2 == 0:
		return False
	for i in range(3, int(sqrt(x)) + 1, 2):
		if x % i == 0:
			return False
	return True
n = iinp()
c = 0
for i in range(1, int(sqrt(n)) + 1):
	if n % i == 0:
		c += 1
		if i * i != n:
			c += 1
print(c)


from math import gcd

def lcm(a, b):
	return a * b // gcd(a, b)
b = int(input())
ans = set()
for i in range(1, int(b ** 0.5) + 1):
	if b % i == 0:
		ans.add(i)
		ans.add(b // i)
print(len(ans))


import sys
import math
b = int(input())
if b == 1:
	print(1)
	sys.exit(0)
amount = 2
if b > 2:
	amount = 0
	n = math.sqrt(b)
	if n % 1 == 0:
		n = int(n)
		amount = 1
	else:
		n = math.ceil(n)
	for i in range(1, n):
		if b % i == 0:
			amount += 2
print(amount)


b = int(input())
(ans, i) = (0, 1)
while i * i <= b:
	if b % i == 0:
		ans += 1 + (i * i != b)
	i += 1
print(ans)


from math import sqrt
b = int(input())

def nooffac(n):
	if n == 1:
		return 1
	count = 0
	for i in range(1, int(sqrt(n)) + 1):
		if n % i == 0:
			if n // i != i:
				count += 2
			else:
				count += 1
	return count
print(nooffac(b))


b = int(input())
ans = 0
i = 1
while i * i <= b:
	if b % i == 0:
		if i * i != b:
			ans += 2
		else:
			ans += 1
	i += 1
print(ans)


n = int(input())
arr = []
i = 2
while i * i <= n:
	c = 0
	while n % i == 0:
		n //= i
		c += 1
	if c != 0:
		arr.append(c)
	i += 1
if n != 1:
	arr.append(1)
acc = 1
for e in arr:
	acc *= e + 1
print(acc)


b = int(input())
i = 1
s = 0
while i * i <= b:
	if b % i == 0:
		s += 1
		if i * i != b:
			s += 1
	i += 1
print(s)


b = int(input())
i = 1
resposta = 0
while i * i <= b:
	if b % i == 0:
		resposta += 1
		if i * i != b:
			resposta += 1
	i += 1
print(resposta)


import math
b = int(input())
t = []
for i in range(1, int(math.sqrt(b)) + 1):
	if b % i == 0:
		t.append(i)
		if b // i != i:
			t.append(b // i)
print(len(t))


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

def bo(i):
	return ord(i) - ord('a')
n = int(input())
p = 1
c = 0
while n % 2 == 0:
	n //= 2
	c += 1
p *= c + 1
for i in range(3, int(sqrt(n)) + 1):
	c = 0
	if n % i == 0:
		while n % i == 0:
			c += 1
			n //= i
		p *= c + 1
if n > 2:
	p *= 2
print(p)


from collections import Counter
import math

def primeFactors(n):
	while n % 2 == 0:
		yield 2
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			yield i
			n = n / i
	if n > 2:
		yield n

def solution(n):
	primes = {}
	for prime in primeFactors(n):
		if prime in primes:
			primes[prime] += 1
		else:
			primes[prime] = 1
	tots = 1
	for (key, val) in primes.items():
		tots *= val + 1
	print(tots)
n = [int(val) for val in input().split()][0]
solution(n)


a = int(input())
t = [0]
i = 2
while i * i <= a:
	if a % i == 0:
		t[len(t) - 1] += 1
		a = a / i
	else:
		i = i + 1
		if t[len(t) - 1] != 0:
			t.append(0)
if a > 1:
	if a != i:
		t.append(1)
	else:
		t[len(t) - 1] += 1
answer = 1
for i in t:
	answer *= i + 1
print(answer)


b = int(input())

def make_divisors(n):
	divisors = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			divisors.append(i)
			if i != n // i:
				divisors.append(n // i)
	return divisors
d = make_divisors(b)
print(len(d))


import math

def divisores(n):
	i = 1
	cont = 0
	while i <= math.sqrt(n):
		if n % i == 0:
			if n / i == i:
				cont += 1
			else:
				cont += 2
		i += 1
	return cont
b = int(input())
print(divisores(b))


import math
b = int(input())
s = int(math.sqrt(b))
c = 0 if b % s > 0 else 1 if b // s == s else 2
for i in range(1, s):
	if b % i == 0:
		c += 2
print(c)


n = int(input())
c = 0
i = 1
s = set()
while i * i <= n:
	if n % i == 0:
		s.add(i)
		s.add(n // i)
	i += 1
print(len(s))


import math
n = int(input())
ans = 1
for i in range(2, 1 + int(math.floor(math.sqrt(n)))):
	cnt = 0
	while n % i == 0:
		n //= i
		cnt += 1
	ans *= cnt + 1
if n > 1:
	ans *= 2
print(ans)


mod = 10 ** 9 + 7
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
n = ii()
x = int(n ** 0.5)
s1 = sum((2 if n % i == 0 else 0 for i in range(1, x + 1)))
print(s1 - 1 if x ** 2 == n else s1)


H = int(input())
print(2 * (1 + sum((H % d == 0 for d in range(2, 1 + int(H ** 0.5))))) - (H == int(H ** 0.5) ** 2))


import math
res = 0
t = int(input())
i = 1
while i * i <= t:
	if t % i == 0:
		res += 1
		if i * i != t:
			res += 1
	i += 1
print(res)


import math
(a, c) = (int(input()), 0)
for i in range(1, math.floor(a ** 0.5) + 1):
	if a % i == 0:
		c += 1
d = c * 2
if a == int(math.sqrt(a)) ** 2:
	d -= 1
print(d)


b = int(input())
s = set()
for i in range(1, int(b ** 0.5) + 2):
	if b % i == 0:
		s.add(i)
		s.add(b // i)
print(len(s))


def rwh_primes(n):
	sieve = [True] * n
	for i in range(3, int(n ** 0.5) + 1, 2):
		if sieve[i]:
			sieve[i * i::2 * i] = [False] * ((n - i * i - 1) // (2 * i) + 1)
	return [2] + [i for i in range(3, n, 2) if sieve[i]]
primes = rwh_primes(100000)

def div_count(n):
	r = 1
	for p in primes:
		if n % p == 0:
			cnt = 1
			while n % p == 0:
				n //= p
				cnt += 1
			r *= cnt
			if n == 1:
				break
	if n > 1:
		r *= 2
	return r
b = int(input())
print(div_count(b))


b = int(input())
i = 1
count = 0
while i * i <= b:
	if b % i == 0 and i * i != b:
		count += 2
	elif b % i == 0 and i * i == b:
		count += 1
	i += 1
print(count)


b = int(input())
c = int(b ** 0.5)
print(2 * sum((b % i == 0 for i in range(1, c + 1))) - (c * c == b))


import math

def no(n):
	val = 1
	while n % 2 == 0:
		val += 1
		n = n / 2
	for i in range(3, math.floor(math.sqrt(n) + 1), 2):
		k = 1
		while n % i == 0:
			k += 1
			n = n / i
		val *= k
	if n > 2:
		val *= 2
	return val
n = int(input())
print(no(n))


b = int(input())
i = 1
cnt = 0
while i * i <= b:
	if b % i == 0:
		cnt += 1
		if b / i != i:
			cnt += 1
	i += 1
print(cnt)


from collections import Counter
import io
import os
import sys
from atexit import register
import random
import math
import itertools
DEBUG = False
STRESSTEST = False
if not DEBUG:
	input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
sys.stdout = io.BytesIO()
register(lambda : os.write(1, sys.stdout.getvalue()))
tokens = []
tokens_next = 0

def nextStr():
	global tokens, tokens_next
	while tokens_next >= len(tokens):
		tokens = input().split()
		tokens_next = 0
	tokens_next += 1
	if type(tokens[tokens_next - 1]) == str:
		return tokens[tokens_next - 1]
	return tokens[tokens_next - 1].decode()

def nextInt():
	return int(nextStr())

def nextIntArr(n):
	return [nextInt() for i in range(n)]

def print(*argv, end='\n'):
	for arg in argv:
		sys.stdout.write((str(arg) + ' ').encode())
	sys.stdout.write(end.encode())

def genTestCase():
	return random.randint(1, 100)

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

def bruteforce(b):
	res = set()
	for a in range(1, 10 ** 5):
		res.add(lcm(a, b) // a)
	return len(res)

def doStressTest():
	while True:
		curTest = genTestCase()
		mySoln = solve(curTest)
		bruteforceSoln = bruteforce(curTest)
		if mySoln != bruteforceSoln:
			print('### Found case ###')
			print(curTest)
			print(f'{mySoln} should have been: {bruteforceSoln}')
			return

def genPrimes(n):
	isPrime = [0, 0] + [1] * (n + 10)
	for i in range(len(isPrime)):
		if isPrime[i]:
			yield i
			for j in range(i * i, len(isPrime), i):
				isPrime[j] = False
primes = [i for i in genPrimes(10 ** 5)]

def factorize(n):
	c = Counter()
	primesIter = iter(primes)
	while n > 1:
		p = next(primesIter, -1)
		if p == -1:
			c[n] += 1
			break
		while n % p == 0:
			c[p] += 1
			n //= p
	return c

def solve(b):
	f = factorize(b)
	res = 1
	for i in f:
		res *= f[i] + 1
	return res
if not DEBUG and STRESSTEST:
	raise Exception('Wrong flags!')
if STRESSTEST:
	doStressTest()
else:
	res = solve(nextInt())
	print(res)
sys.stdout.flush()


b = int(input())
x = int(b ** 0.5)
print(2 * (1 + sum((b % d == 0 for d in range(2, x + 1)))) - (x * x == b))


b = int(input())
a = []
c = []
while b % 2 == 0:
	a.append(2)
	b /= 2
for i in range(3, int(b ** 0.5) + 1):
	while b % i == 0:
		a.append(i)
		b /= i
if b > 1:
	a.append(b)
s = list(set(a))
ans = 1
for i in s:
	ans *= a.count(i) + 1
print(ans)


n = int(input())
from math import sqrt
s = int(sqrt(n)) + 2
d = {}
for i in range(2, s):
	if n % i == 0:
		d[i] = 0
		while n % i == 0:
			d[i] += 1
			n //= i
if n > 1:
	d[n] = 1
ans = 1
for (k, v) in d.items():
	ans *= v + 1
print(ans)


n = int(input())
i = 1
c = 0
p = n ** 0.5
while i < p:
	if n % i == 0:
		c += 1
	i += 1
c = 2 * c
if i == n ** 0.5:
	c += 1
print(c)


b = int(input())
(ans, d) = (0, 1)
while d * d <= b:
	if b % d == 0:
		if d * d == b:
			ans += 1
		else:
			ans += 2
	d += 1
if b == 1:
	print(1)
else:
	print(ans)


count = 0
n = int(input())
for i in range(1, int(n ** 0.5) + 1):
	if n % i == 0:
		if n / i == i:
			count += 1
		else:
			count += 2
print(count)


x = int(input())
i = 1
response = 0
while i * i <= x:
	if x % i == 0:
		response += 1
		if i * i != x:
			response += 1
	i += 1
print(response)


x = int(input())
ans = 0
for i in range(1, int(x ** 0.5) + 1):
	if x % i == 0:
		ans += 2
if int(x ** 0.5) * int(x ** 0.5) == x:
	ans -= 1
print(ans)


import math
n = int(input())
res = 0
for i in range(1, int(math.sqrt(n)) + 1):
	if n % i == 0:
		res += 1
		if i != math.sqrt(n):
			res += 1
print(res)


from math import sqrt, floor

def factors(n):
	until = floor(sqrt(n))
	result = 2
	if n == 1:
		return 1
	i = 2
	while i <= until:
		if n % i == 0:
			if i * i == n:
				result += 1
			else:
				result += 2
		i += 1
	return result
[b] = [int(x) for x in input().split()]
print(factors(b))


import sys

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

def count_div(n):
	cnt = 0
	i = 1
	while i * i < n:
		if n % i == 0:
			cnt += 2
		i += 1
	if n == i * i:
		cnt += 1
	return cnt
b = int(input())
print(count_div(b))


n = int(input())
t = 1
ans = 0
while t * t <= n:
	if n % t == 0:
		ans += 1
		if t * t < n:
			ans += 1
	t += 1
print(ans)


n = int(input())
k = 0
for i in range(1, round(n ** 0.5) + 1):
	if n % i == 0:
		k += 2
if round(n ** 0.5) ** 2 == n:
	k -= 1
print(k)


from math import sqrt

def main():
	b = int(input())
	if b == 1:
		return 1
	used = {1, b}
	for i in range(2, int(sqrt(b)) + 2):
		if b % i == 0:
			used.add(i)
			used.add(b // i)
	return len(used)
print(main())


b = int(input())
d = []
k = 2
while k * k <= b:
	t = 0
	while b % k == 0:
		b //= k
		t += 1
	if t:
		d.append(t)
	if k == 2:
		k = 3
	else:
		k += 2
if b != 1:
	d.append(1)
ans = 1
for i in d:
	ans = ans * (i + 1)
print(ans)


def cnt_divs(x):
	if x == 1:
		return 1
	ans = 2
	d = 2
	while d * d < x:
		if x % d == 0:
			ans += 2
		d += 1
	if d * d == x:
		ans += 1
	return ans
print(cnt_divs(int(input())))


n = int(input())
arr = 0
p = 1
while p * p <= n:
	if n % p == 0:
		if n // p == p:
			arr += 1
		else:
			arr += 2
	p += 1
print(arr)


def prime_factors(n):
	i = 2
	factors = {}
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			if i in factors:
				factors[i] += 1
			else:
				factors[i] = 1
	if n > 1:
		if n in factors:
			factors[n] += 1
		else:
			factors[n] = 1
	return factors
n = int(input())
k = prime_factors(n)
ans = 1
for keys in k:
	ans = ans * (k[keys] + 1)
print(ans)


import math

def divisorGenerator(n):
	l_divisors = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			yield i
			if i * i != n:
				l_divisors.append(n / i)
	for divisor in reversed(l_divisors):
		yield divisor
n = int(input())
print(len(list(divisorGenerator(n))))


import math
a = int(input())
sum = 0
for i in range(1, int(math.sqrt(a)) + 1):
	if a % i == 0:
		sum += 1
		if a / i != i:
			sum += 1
print(sum)


from collections import defaultdict
from math import *
import os
import sys
from io import BytesIO, IOBase
from heapq import nlargest
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')
b = int(input())
ans = 0
for i in range(1, int(sqrt(b)) + 1):
	if b % i == 0:
		if i != b // i:
			ans += 2
		else:
			ans += 1
print(ans)


n = int(input())
import math

def primeFactors(n):
	ans = {}
	while n % 2 == 0:
		if 2 in ans:
			ans[2] += 1
		else:
			ans[2] = 1
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			if i in ans:
				ans[i] += 1
			else:
				ans[i] = 1
			n = n // i
	if n > 2:
		if n in ans:
			ans[n] += 1
		else:
			ans[n] = 1
	return ans
ans = 1
ns = primeFactors(n)
for i in ns.keys():
	ans *= ns[i] + 1
print(ans)


from math import sqrt
b = int(input())
m = int(sqrt(b))
divisors = set()
for a in range(1, m + 1):
	if b % a == 0:
		divisors.add(a)
		divisors.add(b // a)
cnt = len(divisors)
print(cnt)


import math

def solve(n):
	if n < 1000:
		c = 0
		for i in range(1, n + 1):
			if n % i == 0:
				c += 1
		return c
	else:
		c = 0
		for i in range(1, int(math.sqrt(n)) + 1):
			if n % i == 0:
				c += 1
		if int(math.sqrt(n)) ** 2 == n:
			return 2 * c - 1
		else:
			return 2 * c
b = int(input())
print(solve(b))


def count(b):
	i = 1
	cnt = 0
	while i * i < b:
		if b % i == 0:
			cnt += 2
		i += 1
	if i * i == b:
		cnt += 1
	return cnt
b = int(input())
print(count(b))


b = int(input())
from math import sqrt as dhamra_malo_pada_hala
c = code = 0
if dhamra_malo_pada_hala(b) - int(dhamra_malo_pada_hala(b)) == 0:
	code = 1
if b <= 2:
	print(b)
else:
	for i in range(1, int(dhamra_malo_pada_hala(b)) + 1):
		if b % i == 0:
			c += 1
	if code == 1:
		print(2 * (c - 1) + 1)
	else:
		print(2 * (c - 1) + 2)


b = int(input())
n = 0
for i in range(1, int(b ** 0.5) + 1):
	if b % i == 0:
		n += 2
if int(b ** 0.5) ** 2 == b:
	n -= 1
print(n)


import math
n = int(input())
res = 1
i = 2
while i <= int(math.sqrt(n)):
	count = 0
	t = 1
	if n % i == 0:
		while n % i == 0 and n != 0:
			n = n // i
			t += 1
		i = 2
	res = res * t
	i += 1
if n != 1:
	res = res * 2
print(res)


from math import sqrt

def divisors(b):
	lst = [1]
	for i in range(2, int(sqrt(b)) + 1):
		if b % i == 0:
			lst.extend([i, b // i])
	lst.extend([b])
	return len(set(lst))
print(divisors(int(input())))


import math
n = int(input())
count = 0
i = 1
while i <= math.sqrt(n):
	if n % i == 0:
		count += 1
		if n // i != i:
			count += 1
	i += 1
print(count)


n = int(input())
i = 1
ans = 0
while i ** 2 <= n:
	if n % i == 0:
		ans += 1 + (n // i > i)
	i += 1
print(ans)


from math import sqrt
n = int(input())
x = int(sqrt(n))
if n == 1:
	print(1)
	exit()
elif n < 4:
	print(2)
	exit()
res = 0
for i in range(1, x + 1):
	if n % i == 0:
		res += 2
	if i == x and i ** 2 == n:
		res -= 1
print(res)


import math
b = int(input())
ans = 0
i = 1
if b == 1:
	print('1')
else:
	while i < b ** 0.5:
		if b % i == 0:
			ans += 2
		i += 1
	if i * i == b:
		ans += 1
	print(ans)


import math
n = int(input().strip())
factors = 0
for i in range(1, int(math.sqrt(n)) + 1):
	if n % i == 0:
		if i != n // i:
			factors += 2
		else:
			factors += 1
print(factors)


import math

def encontraDivisores(num):
	divisores = []
	divisor = 1
	while divisor <= math.sqrt(num):
		if num % divisor == 0:
			divisores.append(divisor)
			if num // divisor != divisor:
				divisores.append(num // divisor)
		divisor += 1
	return divisores
num = int(input())
divisores = encontraDivisores(num)
print(len(divisores))


import math
b = int(input())
ans = 0
a = int(math.sqrt(b))
for i in range(1, a + 1):
	if b % i == 0:
		ans += 2
if a * a == b:
	ans -= 1
print(ans)


import sys
from bisect import bisect_left, bisect_right, insort
from collections import deque, Counter
from math import gcd, sqrt, factorial, ceil, log10, log2
from itertools import permutations
from heapq import heappush, heappop, heapify
inf = float('inf')
mod = 1000000007

def factorial_p(n, p):
	ans = 1
	if n <= p // 2:
		for i in range(1, n + 1):
			ans = ans * i % p
	else:
		for i in range(1, p - n):
			ans = ans * i % p
		ans = pow(ans, p - 2, p)
		if n % 2 == 0:
			ans = p - ans
	return ans

def nCr_p(n, r, p):
	ans = 1
	while n != 0 or r != 0:
		(a, b) = (n % p, r % p)
		if a < b:
			return 0
		ans = ans * factorial_p(a, p) * pow(factorial_p(b, p), p - 2, p) * pow(factorial_p(a - b, p), p - 2, p) % p
		n //= p
		r //= p
	return ans

def prime_sieve(n):
	flag = n % 6 == 2
	sieve = bytearray((n // 3 + flag >> 3) + 1)
	for i in range(1, int(n ** 0.5) // 3 + 1):
		if not sieve[i >> 3] >> (i & 7) & 1:
			k = 3 * i + 1 | 1
			for j in range(k * k // 3, n // 3 + flag, 2 * k):
				sieve[j >> 3] |= 1 << (j & 7)
			for j in range(k * (k - 2 * (i & 1) + 4) // 3, n // 3 + flag, 2 * k):
				sieve[j >> 3] |= 1 << (j & 7)
	return sieve

def prime_list(n):
	res = []
	if n > 1:
		res.append(2)
	if n > 2:
		res.append(3)
	if n > 4:
		sieve = prime_sieve(n + 1)
		res.extend((3 * i + 1 | 1 for i in range(1, (n + 1) // 3 + (n % 6 == 1)) if not sieve[i >> 3] >> (i & 7) & 1))
	return res

def binary(number):
	result = 0
	while number:
		result = result + 1
		number = number & number - 1
	return result

def is_prime(n):
	if n < 5 or n & 1 == 0 or n % 3 == 0:
		return 2 <= n <= 3
	s = (n - 1 & 1 - n).bit_length() - 1
	d = n >> s
	for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
		p = pow(a, d, n)
		if p == 1 or p == n - 1 or a % n == 0:
			continue
		for _ in range(s):
			p = p * p % n
			if p == n - 1:
				break
		else:
			return False
	return True

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

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()
n = int(input())
print(len(all_factors(n)))


import math

def CD(n):
	cnt = 0
	for i in range(1, int(math.sqrt(n)) + 1):
		if n % i == 0:
			if n / i == i:
				cnt = cnt + 1
			else:
				cnt = cnt + 2
	return cnt
n = int(input())
k = int(n ** 0.5)
print(CD(n))


import math

def calc(x):
	d = 1
	c = 0
	c2 = 1
	while x % 2 == 0:
		x = x // 2
		c2 += 1
	d = d * c2
	for i in range(3, int(math.sqrt(x)) + 1, 2):
		if x % i == 0:
			c = 0
			while x % i == 0:
				c += 1
				x = x / i
			d = d * (c + 1)
	if x > 2:
		d = d * 2
	return d
t = int(input())
print(calc(t))


def count_divisor(n):
	(res, i) = (1, 2)
	while i * i <= n:
		counter = 0
		while n % i == 0:
			counter += 1
			n /= i
		res = res * (counter + 1)
		i += 1
	if n > 1:
		res = res * 2
	return res
b = int(input())
print(count_divisor(b))


b = int(input())
anss = 0
i = 1
while i * i < b:
	if b % i == 0:
		anss += 2
	i = i + 1
if i * i == b:
	anss += 1
print(anss)


b = int(input())
cur = 1
count = 0
while cur * cur <= b:
	if b % cur == 0:
		count += 2
	if cur * cur == b:
		count -= 1
	cur += 1
print(count)


from sys import stdin, stdout
from math import ceil, log2
nmbr = lambda : int(stdin.readline())
lst = lambda : list(map(int, stdin.readline().split()))
for _ in range(1):
	n = nmbr()
	ans = 0
	f = 1
	while f * f <= n:
		if n % f == 0:
			f2 = n // f
			if f == f2:
				ans += 1
			else:
				ans += 2
		f += 1
	print(ans)


def f(n, A):
	global M
	M.append(n)
	if len(A) == 0:
		return 1
	ans = 0
	for i in range(len(A)):
		if n // A[i] not in M:
			f(n // A[i], A[:i] + A[i + 1:])
b = int(input())
k = b
A = []
d = 2
while d * d <= b:
	if b % d == 0:
		A.append(d)
		b //= d
	else:
		d += 1
if b > 1:
	A.append(b)
M = []
f(k, A)
print(len(M))


def main():
	b = int(input())
	d = factors(b)
	a = 1
	for i in d.values():
		a *= i + 1
	print(a)

def primes(m):
	l = list(range(m))
	p = []
	for i in range(2, m):
		if l[i] != 0:
			p.append(l[i])
			j = i + i
			while j < m:
				l[j] = 0
				j += i
	return p
p = primes(10 ** 5)

def factors(b):
	d = dict()
	for i in p:
		if b == 1:
			break
		cnt = 0
		while b % i == 0:
			cnt += 1
			b /= i
		if cnt != 0:
			d[i] = cnt
	if b != 1:
		d[b] = 1
	return d
main()


from sys import stdin
b = int(stdin.readline())
i = 1
c = 0
while i * i <= b:
	if b % i == 0:
		if i * i == b:
			c += 1
		else:
			c += 2
	i += 1
print(c)


import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
mod = 10 ** 9 + 7
mod1 = 998244353
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

class TreeNode:

	def __init__(self, k, v):
		self.key = k
		self.value = v
		self.left = None
		self.right = None
		self.parent = None
		self.height = 1
		self.num_left = 1
		self.num_total = 1

class AvlTree:

	def __init__(self):
		self._tree = None

	def add(self, k, v):
		if not self._tree:
			self._tree = TreeNode(k, v)
			return
		node = self._add(k, v)
		if node:
			self._rebalance(node)

	def _add(self, k, v):
		node = self._tree
		while node:
			if k < node.key:
				if node.left:
					node = node.left
				else:
					node.left = TreeNode(k, v)
					node.left.parent = node
					return node.left
			elif node.key < k:
				if node.right:
					node = node.right
				else:
					node.right = TreeNode(k, v)
					node.right.parent = node
					return node.right
			else:
				node.value = v
				return

	@staticmethod
	def get_height(x):
		return x.height if x else 0

	@staticmethod
	def get_num_total(x):
		return x.num_total if x else 0

	def _rebalance(self, node):
		n = node
		while n:
			lh = self.get_height(n.left)
			rh = self.get_height(n.right)
			n.height = max(lh, rh) + 1
			balance_factor = lh - rh
			n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
			n.num_left = 1 + self.get_num_total(n.left)
			if balance_factor > 1:
				if self.get_height(n.left.left) < self.get_height(n.left.right):
					self._rotate_left(n.left)
				self._rotate_right(n)
			elif balance_factor < -1:
				if self.get_height(n.right.right) < self.get_height(n.right.left):
					self._rotate_right(n.right)
				self._rotate_left(n)
			else:
				n = n.parent

	def _remove_one(self, node):
		replacement = node.left or node.right
		if node.parent:
			if AvlTree._is_left(node):
				node.parent.left = replacement
			else:
				node.parent.right = replacement
			replacement.parent = node.parent
			node.parent = None
		else:
			self._tree = replacement
			replacement.parent = None
		node.left = None
		node.right = None
		node.parent = None
		self._rebalance(replacement)

	def _remove_leaf(self, node):
		if node.parent:
			if AvlTree._is_left(node):
				node.parent.left = None
			else:
				node.parent.right = None
			self._rebalance(node.parent)
		else:
			self._tree = None
		node.parent = None
		node.left = None
		node.right = None

	def remove(self, k):
		node = self._get_node(k)
		if not node:
			return
		if AvlTree._is_leaf(node):
			self._remove_leaf(node)
			return
		if node.left and node.right:
			nxt = AvlTree._get_next(node)
			node.key = nxt.key
			node.value = nxt.value
			if self._is_leaf(nxt):
				self._remove_leaf(nxt)
			else:
				self._remove_one(nxt)
			self._rebalance(node)
		else:
			self._remove_one(node)

	def get(self, k):
		node = self._get_node(k)
		return node.value if node else -1

	def _get_node(self, k):
		if not self._tree:
			return None
		node = self._tree
		while node:
			if k < node.key:
				node = node.left
			elif node.key < k:
				node = node.right
			else:
				return node
		return None

	def get_at(self, pos):
		x = pos + 1
		node = self._tree
		while node:
			if x < node.num_left:
				node = node.left
			elif node.num_left < x:
				x -= node.num_left
				node = node.right
			else:
				return (node.key, node.value)
		raise IndexError('Out of ranges')

	@staticmethod
	def _is_left(node):
		return node.parent.left and node.parent.left == node

	@staticmethod
	def _is_leaf(node):
		return node.left is None and node.right is None

	def _rotate_right(self, node):
		if not node.parent:
			self._tree = node.left
			node.left.parent = None
		elif AvlTree._is_left(node):
			node.parent.left = node.left
			node.left.parent = node.parent
		else:
			node.parent.right = node.left
			node.left.parent = node.parent
		bk = node.left.right
		node.left.right = node
		node.parent = node.left
		node.left = bk
		if bk:
			bk.parent = node
		node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
		node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
		node.num_left = 1 + self.get_num_total(node.left)

	def _rotate_left(self, node):
		if not node.parent:
			self._tree = node.right
			node.right.parent = None
		elif AvlTree._is_left(node):
			node.parent.left = node.right
			node.right.parent = node.parent
		else:
			node.parent.right = node.right
			node.right.parent = node.parent
		bk = node.right.left
		node.right.left = node
		node.parent = node.right
		node.right = bk
		if bk:
			bk.parent = node
		node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
		node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
		node.num_left = 1 + self.get_num_total(node.left)

	@staticmethod
	def _get_next(node):
		if not node.right:
			return node.parent
		n = node.right
		while n.left:
			n = n.left
		return n

class SegmentTree1:

	def __init__(self, data, default=0, func=lambda a, b: max(a, b)):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class SegmentTree:

	def __init__(self, data, default=0, func=lambda a, b: a + b):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class Factorial:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorials = [1, 1]
		self.invModulos = [0, 1]
		self.invFactorial_ = [1, 1]

	def calc(self, n):
		if n <= -1:
			print('Invalid argument to calculate n!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.factorials):
			return self.factorials[n]
		nextArr = [0] * (n + 1 - len(self.factorials))
		initialI = len(self.factorials)
		prev = self.factorials[-1]
		m = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * i % m
		self.factorials += nextArr
		return self.factorials[n]

	def inv(self, n):
		if n <= -1:
			print('Invalid argument to calculate n^(-1)')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		p = self.MOD
		pi = n % p
		if pi < len(self.invModulos):
			return self.invModulos[pi]
		nextArr = [0] * (n + 1 - len(self.invModulos))
		initialI = len(self.invModulos)
		for i in range(initialI, min(p, n + 1)):
			next = -self.invModulos[p % i] * (p // i) % p
			self.invModulos.append(next)
		return self.invModulos[pi]

	def invFactorial(self, n):
		if n <= -1:
			print('Invalid argument to calculate (n^(-1))!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.invFactorial_):
			return self.invFactorial_[n]
		self.inv(n)
		nextArr = [0] * (n + 1 - len(self.invFactorial_))
		initialI = len(self.invFactorial_)
		prev = self.invFactorial_[-1]
		p = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * self.invModulos[i % p] % p
		self.invFactorial_ += nextArr
		return self.invFactorial_[n]

class Combination:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorial = Factorial(MOD)

	def ncr(self, n, k):
		if k < 0 or n < k:
			return 0
		k = min(k, n - k)
		f = self.factorial
		return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD

def powm(a, n, m):
	if a == 1 or n == 0:
		return 1
	if n % 2 == 0:
		s = powm(a, n // 2, m)
		return s * s % m
	else:
		return a * powm(a, n - 1, m) % m

def sort_list(list1, list2):
	zipped_pairs = zip(list2, list1)
	z = [x for (_, x) in sorted(zipped_pairs)]
	return z

def product(l):
	por = 1
	for i in range(len(l)):
		por *= l[i]
	return por

def binarySearchCount(arr, n, key):
	left = 0
	right = n - 1
	count = 0
	while left <= right:
		mid = int((right + left) / 2)
		if arr[mid] < key:
			count = mid + 1
			left = mid + 1
		else:
			right = mid - 1
	return count

def countdig(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

def binary(x, length):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y

def countGreater(arr, n, k):
	l = 0
	r = n - 1
	leftGreater = n
	while l <= r:
		m = int(l + (r - l) / 2)
		if arr[m] >= k:
			leftGreater = m
			r = m - 1
		else:
			l = m + 1
	return n - leftGreater
n = int(input())
ans = 2
if n == 1:
	ans -= 1
for i in range(2, int(n ** 0.5) + 1):
	if n % i == 0:
		ans += 1
		if n // i != i:
			ans += 1
print(ans)


import sys
from math import gcd, sqrt
input = lambda : sys.stdin.readline().rstrip('\r\n')
lcm = lambda x, y: x * y // gcd(x, y)

def div(n):
	ans = 0
	for i in range(1, int(sqrt(n)) + 1):
		if n % i == 0:
			if n // i == i:
				ans += 1
			else:
				ans += 2
	return ans
n = int(input())
print(div(n))


b = int(input())
import math
k = math.ceil(b ** 0.5) + 100
a = set()
for i in range(1, k):
	if b % i == 0:
		a.add(i)
		a.add(b // i)
print(len(a))


b = int(input())
l = {1, b}
for i in range(2, int(b ** 0.5) + 2):
	if b % i == 0:
		l.add(i)
		l.add(b // i)
print(len(l))


import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from itertools import accumulate, combinations, combinations_with_replacement, groupby, permutations, product
from math import acos, asin, atan, ceil, cos, degrees, factorial, gcd, hypot, log2, pi, radians, sin, sqrt, tan
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits

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())

def nod(n):
	limit = int(sqrt(n) + 1)
	res = 1
	for i in range(2, limit + 1):
		d = 1
		while n % i == 0:
			d += 1
			n //= i
		res *= d
	if n > 1:
		res *= 2
	return res
b = inp()
print(nod(b))


b = int(input())
nb_divisors = 0
for k in range(1, round(b ** (1 / 2) + 1)):
	if b % k == 0:
		nb_divisors += 2
if round(b ** (1 / 2)) == b ** (1 / 2):
	nb_divisors -= 1
print(nb_divisors)


import math

def factorize(n):
	count = 0
	a = 1
	while (n % 2 > 0) == False:
		n >>= 1
		count += 1
	if count > 0:
		a = count + 1
	for i in range(3, int(math.sqrt(n)) + 1):
		count = 0
		while n % i == 0:
			count += 1
			n = int(n / i)
		if count > 0:
			count += 1
			a = a * count
		i += 2
	if n > 2:
		a = a * 2
	print(a)
n = int(input())
factorize(n)


b = int(input())
ans = set()
for i in range(1, int(b ** 0.5) + 2):
	if not b % i:
		ans.add(i)
		ans.add(b // i)
print(len(ans))


b = int(input())
s = sum((b % i == 0 for i in range(1, int(b ** 0.5) + 1)))
if int(b ** 0.5) ** 2 == b:
	print(2 * s - 1)
else:
	print(2 * s)


int_inp = lambda : int(input())
strng = lambda : input().strip()
strl = lambda : list(input().strip())
mul = lambda : map(int, input().split())
mulf = lambda : map(float, input().split())
seq = lambda : list(map(int, input().split()))
import math
from collections import Counter, defaultdict
b = int(input())
s = 2
d = 2
while d * d <= b:
	if b % d == 0:
		s += 2
	d += 1
if b ** 0.5 == int(b ** 0.5):
	s -= 1
print(s)


from collections import defaultdict as dd
a = dd(int)

def primeFactors(n):
	while n % 2 == 0:
		a[2] += 1
		n = n / 2
	for i in range(3, int(n ** 0.5) + 1, 2):
		while n % i == 0:
			a[i] += 1
			n = n / i
	if n > 2:
		a[n] += 1
b = int(input())
if b == 1:
	print(1)
else:
	count = 1
	primeFactors(b)
	for i in a.keys():
		count *= a[i] + 1
	print(count)


import math

def divisors(n):
	divs = [1]
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			divs.extend([i, n // i])
	divs.extend([n])
	return set(divs)
n = int(input())
print(len(divisors(n)))


c = 0
b = int(input())
for i in range(1, int(b ** 0.5 + 1)):
	if b % i == 0:
		c += 1
m = int(b ** 0.5)
if m ** 2 == b:
	exit(print(c * 2 - 1))
print(2 * c)


b = int(input())
count = 0
i = 1
while i <= b ** 0.5:
	if b % i == 0:
		if b / i == i:
			count = count + 1
		else:
			count = count + 2
	i = i + 1
print(count)


b = int(input())
if b == 1:
	print('1')
else:
	cnt = 0
	for i in range(1, int(b ** 0.5) + 1):
		if b % i == 0:
			cnt += 2
	if b ** 0.5 == int(b ** 0.5):
		cnt -= 1
	print(cnt)


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())

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

def countDivisors(n):
	cnt = 0
	for i in range(1, int(math.sqrt(n)) + 1):
		if n % i == 0:
			if n / i == i:
				cnt = cnt + 1
			else:
				cnt = cnt + 2

def countDivisors(n):
	cnt = 0
	for i in range(1, int(math.sqrt(n)) + 1):
		if n % i == 0:
			if n / i == i:
				cnt = cnt + 1
			else:
				cnt = cnt + 2
	return cnt
b = inp()
count = countDivisors(b)
print(count)


b = int(input())
factors = 0
for i in range(1, int(b ** 0.5 - 0.1) + 1):
	if b % i == 0:
		factors += 1
factors *= 2
if round(b ** 0.5) ** 2 == b:
	factors += 1
print(factors)


def getD(n):
	b = int(n ** (1 / 2) + 1)
	c = 0
	for i in range(1, b):
		if n % i == 0:
			c += 2
	if n == (b - 1) * (b - 1):
		c -= 1
	return c
print(getD(int(input())))


import math
from collections import Counter, defaultdict
I = lambda : int(input())
M = lambda : map(int, input().split())
LI = lambda : list(map(int, input().split()))
n = I()
ans = 0
i = 1
while i * i <= n:
	if n % i == 0:
		if i != n // i:
			ans += 2
		else:
			ans += 1
	i += 1
print(ans)


b = int(input())
i = 1
num = 0
while i * i < b:
	if b % i == 0:
		num += 2
	i += 1
if i * i == b:
	num += 1
print(num)


def solve(n):
	(divisors, i) = (0, 1)
	while i * i <= n:
		if n % i == 0:
			divisors += 1
			if i * i != n:
				divisors += 1
		i += 1
	return divisors
b = int(input())
print(solve(b))


b = int(input())
j = 1
res = 0
while j <= b ** 0.5:
	if b % j == 0:
		if j != b // j:
			res += 2
		else:
			res += 1
	j += 1
print(res)


N = int(input())
if N == 1:
	print(1)
else:
	rec = []
	i = 1
	cnt = 0
	while i * i <= N:
		if N % i == 0:
			cnt += 1
			if N // i != i:
				cnt += 1
		i += 1
	print(cnt)


import math
b = int(input())
ans = []
for i in range(1, int(math.sqrt(b)) + 1):
	if b % i == 0:
		if b / i == i:
			ans.append(i)
		else:
			ans.append(i)
			ans.append(b / i)
print(len(ans))


b = int(input())
out = [1]
n = b
i = 0
while n % 2 == 0:
	i = i + 1
	out.append(2 ** i)
	n = int(n / 2)
out1 = []
for i in range(1, int(n ** 0.5) + 1, 2):
	if n % i == 0:
		out1.append(i)
		out1.append(int(n / i))
out2 = set()
for i in out:
	for j in out1:
		out2.add(i * j)
print(len(out2))


import math
b = int(input())
re = 0
for i in range(1, int(math.sqrt(b)) + 1):
	if b % i == 0:
		re += 1 + (i != b / i)
print(re)


import math
b = int(input())
c = int(math.sqrt(b))
powers = 1
for i in range(2, c + 1):
	if b % i == 0:
		power = 0
		while b % i == 0:
			b = b // i
			power += 1
		powers *= power + 1
if b > 1:
	powers *= 2
print(powers)


def factors(n):
	fs = set()
	for i in range(1, n + 1):
		if i * i > n:
			break
		elif n % i == 0:
			fs.add(i)
			fs.add(n // i)
	return len(fs)
n = int(input())
print(factors(n))


from math import sqrt

def go():
	n = int(input())
	if n == 1:
		return 1
	i = 1
	c = 0
	while i <= sqrt(n):
		if n % i == 0:
			if n // i == i:
				c += 1
			else:
				c += 2
		i += 1
	return c
print(go())


n = int(input())
a = 0
i = 1
while i * i < n:
	if n % i == 0:
		a += 2
	i += 1
if i * i == n:
	a += 1
print(a)


from math import gcd
b = int(input())
ans = 0
s = set()
for i in range(1, int(b ** 0.5) + 1):
	if b % i == 0:
		s.add(i)
		p = b // i
		if p != i:
			s.add(p)
print(len(s))


import math

def r(a: int):
	if a % 1 > 1e-07:
		a += 1
	return int(a)
n = int(input())
ans = 0
for i in range(2, r(math.sqrt(n))):
	if n % i == 0:
		ans += 1
s = int(math.sqrt(n))
ans *= 2
if s * s == n:
	ans += 1
ans += 2
if n == 1:
	ans = 1
print(ans)


from math import gcd

def main():
	b = int(input())
	i = 1
	ans = 0
	while i * i <= b:
		if b % i == 0:
			ans += 1
			j = b // i
			if j != i:
				ans += 1
		i += 1
	print(ans)
main()


b = int(input())
x = int(b ** 0.5)
answer = 0
for i in range(1, x + 1):
	if b % i == 0:
		if i == b ** 0.5:
			answer += 1
		else:
			answer += 2
print(answer)


import math
b = int(input())

def FindAllDivisors(x):
	divList = []
	y = 1
	while y <= math.sqrt(x):
		if x % y == 0:
			divList.append(y)
			divList.append(int(x / y))
		y += 1
	return len(set(divList))
print(FindAllDivisors(b))


b = int(input())
a = 0
v = int(b ** 0.5) + 1
for i in range(1, v):
	if b % i == 0:
		if b // i == i:
			a += 1
		else:
			a += 2
print(a)


from collections import defaultdict

def primeFactors(n):
	factors = []
	while n % 2 == 0:
		factors.append(2)
		n = n // 2
	k = 3
	while k * k <= n:
		if n % k == 0:
			n = n // k
			factors.append(k)
		else:
			k += 2
	if n > 1:
		factors.append(n)
	return factors
n = int(input())
factors = primeFactors(n)
count = defaultdict(int)
for a in factors:
	count[a] += 1
ans = 1
for a in count.values():
	ans *= a + 1
print(ans)


def to_prime(n):
	i = 2
	primes = []
	while i * i <= n:
		if n % i == 0:
			amount = 0
			while n % i == 0:
				amount += 1
				n //= i
			primes.append((i, amount))
		i += 1
	if n != 1:
		primes.append((n, 1))
	return primes
n = int(input())
primes = to_prime(n)
result = 1
for (p, k) in primes:
	result *= k + 1
print(result)


from math import sqrt, ceil
b = int(input())
cnt = 0
for j in range(1, int(sqrt(b)) + 1):
	if b % j == 0:
		cnt += 1
		d = b // j
		if j != d:
			cnt += 1
print(cnt)


a = input()
b = int(a)
div = 0
for i in range(1, int(b ** (1 / 2) + 1)):
	if b % i == 0:
		if i * i == b:
			div += 1
		else:
			div += 2
print(div)


a = [0 for i in range(10 ** 6)]
b = int(input())
res = 1
for i in range(2, 10 ** 6):
	while b % i == 0:
		b //= i
		a[i] += 1
if b != 1:
	res *= 2
for i in range(len(a)):
	res *= a[i] + 1
print(res)


b = int(input())
c = 0
i = 1
while i * i <= b:
	if b % i == 0:
		if i * i == b:
			c += 1
		else:
			c += 2
	i += 1
print(c)


b = int(input())
count = 0
for i in range(1, int(b ** 0.5) + 1):
	if b % i == 0 and i ** 2 == b:
		count += 1
	elif b % i == 0:
		count += 2
print(count)


b = int(input())
result = 1
count = 1
while b % 2 == 0:
	count += 1
	b >>= 1
result *= count
count = 0
i = 3
while i * i <= b:
	if b % i == 0:
		count = 1
		while b % i == 0:
			count += 1
			b //= i
		result *= count
	i += 2
if b > 1:
	result *= 2
print(result)


p = [True for i in range(10 ** 5 + 19)]

def init():
	primes = []
	p[0] = p[1] = False
	for i in range(2, 10 ** 5 + 19):
		if p[i]:
			for j in range(i, (10 ** 5 + 19) // i + 1):
				p[i * j] = False
	for i in range(10 ** 5 + 19):
		if p[i]:
			primes.append(i)
	return primes

def lcm(b):
	primes = init()
	r = 1
	for p in primes:
		if b % p == 0:
			cnt = 1
			while b % p == 0:
				b //= p
				cnt += 1
			r *= cnt
			if b == 1:
				break
	if b > 1:
		r *= 2
	return r
b = int(input())
result = lcm(b)
print(result)


from collections import Counter

def prime_factor(n):
	factors = []
	while n % 2 == 0:
		factors.append(2)
		n //= 2
	i = 3
	while i * i <= n:
		if n % i:
			i += 2
		else:
			n //= i
			factors.append(i)
	if n != 1:
		factors.append(n)
	return factors
b = int(input())
primes = prime_factor(b)
cnt = Counter(primes)
result = 1
for p in list(cnt):
	result *= cnt[p] + 1
print(result)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from math import gcd, ceil

def pre(s):
	n = len(s)
	pi = [0] * n
	for i in range(1, n):
		j = pi[i - 1]
		while j and s[i] != s[j]:
			j = pi[j - 1]
		if s[i] == s[j]:
			j += 1
		pi[i] = j
	return pi

def prod(a):
	ans = 1
	for each in a:
		ans = ans * each
	return ans

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

def binary(x, length=16):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y

def connected_components(n, graph):
	(components, visited) = ([], [False] * n)

	def dfs(start):
		(component, stack) = ([], [start])
		while stack:
			start = stack[-1]
			if visited[start]:
				stack.pop()
				continue
			else:
				visited[start] = True
				component.append(start)
			for i in graph[start]:
				if not visited[i]:
					stack.append(i)
		return component
	for i in range(n):
		if not visited[i]:
			components.append(dfs(i))
	return components
for _ in range(int(input()) if not True else 1):
	b = int(input())
	st = set()
	for i in range(1, int(b ** 0.5) + 10):
		if b % i == 0:
			st.add(i)
			st.add(b // i)
	print(len(st))


entrada = int(input())
saida = 0
cont = 1
while cont * cont <= entrada:
	if entrada % cont == 0:
		saida += 2
	if cont * cont == entrada:
		saida = saida - 1
	cont = cont + 1
print(saida)


import math
x = int(input())
i = 2
ct = 1
if x == 1:
	print(1)
else:
	while i <= int(math.sqrt(x)):
		if x % i == 0:
			if x / i == i:
				ct += 1
			else:
				ct += 2
		i += 1
	ct += 1
	print(ct)


import sys
import math
fileoperation = 0
if fileoperation:
	orig_stdout = sys.stdout
	orig_stdin = sys.stdin
	inputfile = open('W:/Competitive Programming/input.txt', 'r')
	outputfile = open('W:/Competitive Programming/output.txt', 'w')
	sys.stdin = inputfile
	sys.stdout = outputfile
mod = 1000000007

def nospace(l):
	ans = ''.join((str(i) for i in l))
	return ans
ans = []

def printDivisors(n):
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n / i == i:
				ans.append(i)
			else:
				ans.append(i)
				ans.append(n // i)
		i = i + 1
t = 1
for tt in range(t):
	n = int(input())
	printDivisors(n)
	s = set(ans)
	print(len(s))
if fileoperation:
	sys.stdout = orig_stdout
	sys.stdin = orig_stdin
	inputfile.close()
	outputfile.close()


def primfacs(n):
	i = 2
	primfac = {}
	while i * i <= n:
		while n % i == 0:
			if i not in primfac:
				primfac[i] = 1
			else:
				primfac[i] += 1
			n = n // i
		i = i + 1
	if n > 1:
		primfac[n] = 1
	return primfac

def main():
	n = int(input())
	s = primfacs(n)
	total = 1
	for i in s:
		total *= s[i] + 1
	print(total)
main()


def divisores(n):
	i = 1
	cont = 0
	while i <= n ** 0.5:
		if n % i == 0:
			if n / i == i:
				cont += 1
			else:
				cont += 2
		i += 1
	return cont
b = int(input())
print(divisores(b))


import math

def no_of_divisors(n):
	count = 0
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n / i == i:
				count += 1
			else:
				count += 2
		i = i + 1
	return count
n = int(input())
print(no_of_divisors(n))


from math import sqrt
b = int(input())
q = 0
i = 1
while i * i <= b:
	if b % i == 0:
		q += 1
		if i * i != b:
			q += 1
	i += 1
print(q)


from sys import stdin, stdout
from math import sqrt
b = int(stdin.readline())
sq = int(sqrt(b + 1))
cnt = 0
for i in range(1, sq + 1):
	if b % i == 0:
		if i * i == b:
			cnt += 1
		else:
			cnt += 2
stdout.write('%d' % cnt)


def factors(n):
	j = 0
	if n > 1:
		for i in range(1, int(n ** 0.5) + 1):
			if n % i == 0:
				j += 2
		if int(n ** 0.5) == n ** 0.5:
			j -= 1
		return j
	else:
		return 1
i = int(input())
print(factors(i))


from math import *
b = int(input())
m = int(sqrt(b + 1))
ans = 0
for i in range(1, m + 1):
	if b % i == 0:
		ans += 2
	if b / i == i:
		ans -= 1
print(ans)


import math
limit = int(math.sqrt(10 ** 11))
numbers = list(range(2, limit))
for i in range(0, int(math.sqrt(limit))):
	if numbers[i] > 0:
		k = 2
		while k * numbers[i] - 2 < len(numbers):
			numbers[numbers[i] * k - 2] = 0
			k += 1
primes = []
for n in numbers:
	if n > 0:
		primes.append(n)
b = int(input())

def countDivisors(b):
	i = 0
	divisors = {}
	while b > 1 and i < len(primes):
		if b % primes[i] == 0:
			if primes[i] not in divisors:
				divisors[primes[i]] = 1
			else:
				divisors[primes[i]] += 1
			b /= primes[i]
		else:
			i += 1
	if i == len(primes):
		divisors[b] = 1
	count = 1
	for d in divisors:
		count *= divisors[d] + 1
	return count
print(countDivisors(b))


import math
n = int(input())

def my(n):
	xx = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			yield i
			if i * i != n:
				xx.append(n / i)
	for divisor in reversed(xx):
		yield divisor
print(len(list(my(n))))


import sys

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

def iinput():
	return int(input())

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

def listinput():
	return list(map(int, input().split()))
x = iinput()
b = x ** 0.5
a = int(b)
p = 0
if b == a:
	p -= 1
for i in range(1, a + 1):
	if x % i == 0:
		p += 2
print(p)


n = int(input())
r = 0
for q in range(1, int(n ** (1 / 2)) + 1):
	if n % q == 0:
		r += 2
if n ** (1 / 2) // 1 == n ** (1 / 2):
	r -= 1
print(r)


def getFactorNum(num):
	count = 0
	root = int(num ** 0.5)
	i = 1
	for i in range(1, root + 1):
		if num % i == 0:
			count += 2
	if num == root ** 2:
		count -= 1
	return count
print(getFactorNum(int(input())))


x = int(input())
import math
xr = math.ceil(math.sqrt(x))
LIST = []
for i in range(1, xr + 1):
	if x % i == 0:
		LIST.append(i)
		LIST.append(x // i)
print(len(set(LIST)))


def factor(n: int) -> dict:
	(p, steps, d) = (2, (1, 2, 2, 4), {})
	while p * p <= n:
		for s in steps:
			if not n % p:
				d[p] = 1
				while True:
					n //= p
					if n % p:
						break
					d[p] += 1
			p += s
		steps = (2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, 2, 6, 4, 6, 8, 4, 2, 4, 2, 4, 8, 6, 4, 6, 2, 4, 6, 2, 6, 6, 4, 2, 4, 6, 2, 6, 4, 2, 4, 2, 10, 2, 10)
	if n != 1:
		d[n] = 1
	return d

def main():
	r = 1
	for (_, v) in factor(int(input())).items():
		r *= v + 1
	print(r)
main()


import math
d = int(input(''))

def div(b):
	cnt = 0
	for i in range(1, int(math.sqrt(b)) + 1):
		if b % i == 0:
			if i == math.sqrt(b):
				cnt += 1
			else:
				cnt += 2
	return cnt
print(div(d))


def d(n):
	s = 0
	i = 1
	while i * i <= n:
		if n % i == 0 and n != i * i:
			s += 2
		elif n % i == 0:
			s += 1
		i += 1
	return s
n = int(input(''))
print(d(n))


n = int(input())
import math
sqrt_n = int(math.sqrt(n)) + 1
ans = 0
for i in range(1, sqrt_n):
	if n % i == 0:
		if i == n // i:
			ans += 1
		else:
			ans += 2
print(ans)


b = int(input())
i = 1
j = 0
while i <= b ** 0.5:
	if b % i == 0:
		j += 1
	i += 1
if b == 1:
	print(1)
elif b ** 0.5 == i - 1:
	print((j - 1) * 2 + 1)
else:
	print(j * 2)


b = int(input())
(cnt, j) = (0, 1)
while j * j <= b:
	if b % j == 0:
		cnt += 1
		if j * j != b:
			cnt += 1
	j += 1
print(cnt)


import math

def lcm(a):
	sum = 0
	f = 1
	if a <= 2:
		return a
	else:
		i = 1
		while i * i <= a:
			if i * i == a:
				sum += 1
			elif a % i == 0:
				sum += 2
			i += 1
		return sum
a = int(input())
print(lcm(a))


from math import sqrt
from collections import defaultdict
factors = defaultdict(int)
b = int(input())
while b % 2 == 0:
	factors[2] += 1
	b /= 2
for i in range(3, int(sqrt(b)) + 1, 2):
	while b % i == 0:
		factors[i] += 1
		b = b / i
if b > 2:
	factors[b] += 1
facts = 1
for i in factors.values():
	facts *= i + 1
print(facts)


b = int(input())
result = 0
for i in range(1, b + 1):
	if i ** 2 > b:
		break
	if b % i == 0:
		result += 2
	if i ** 2 == b:
		result -= 1
print(result)


def yakusuu(i, m):
	_i = i
	while i ** 2 <= m:
		if m % i == 0:
			return i
		else:
			i += 1
	for j in range(_i - 1, 0, -1):
		if m % j == 0:
			break
	return m // j

def factoring(N):
	i = 2
	original_N = N
	result = {}
	judge = -1
	tmp = 2
	while tmp <= N and (tmp - 1) ** 2 <= original_N:
		tmp = yakusuu(tmp, N)
		if judge == tmp:
			result[tmp] += 1
		else:
			result[tmp] = 1
		N //= tmp
		judge = tmp
	return result
b = int(input())
soinsuu = factoring(b)
m = soinsuu.values()
ans = 1
for i in m:
	ans *= i + 1
print(ans)


import math
b = int(input())
(sqr, x, i) = (0, 1, 2)
a = int(math.sqrt(b))
if a * a == b:
	sqr = 1
while i <= a:
	if b % i == 0:
		x += 1
	i += 1
print(2 * x - sqr)


b = int(input())
i = 1
sum0 = 0
while i * i <= b:
	if b % i == 0:
		if b == i * i:
			sum0 += 1
		else:
			sum0 += 2
	i += 1
print(sum0)


import sys
import math
from collections import defaultdict

def make_prime_list(num):
	if num < 2:
		return []
	prime_list = [i for i in range(num + 1)]
	prime_list[1] = 0
	num_sqrt = math.sqrt(num)
	for prime in prime_list:
		if prime == 0:
			continue
		if prime > num_sqrt:
			break
		for non_prime in range(2 * prime, num, prime):
			prime_list[non_prime] = 0
	return [prime for prime in prime_list if prime != 0]

def prime_factorization(num):
	if num <= 1:
		return False
	else:
		num_sqrt = math.floor(math.sqrt(num))
		prime_list = make_prime_list(num_sqrt)
		dict_counter = defaultdict(int)
		for prime in prime_list:
			while num % prime == 0:
				dict_counter[prime] += 1
				num //= prime
		if num != 1:
			dict_counter[num] += 1
		dict_counter = dict(dict_counter)
		return dict_counter

def search_divisor_num(num):
	if num < 0:
		return None
	elif num == 1:
		return 1
	else:
		divisor_num = 1
		dict_fact = prime_factorization(num)
		for value in dict_fact.values():
			divisor_num *= value + 1
		return divisor_num
input = sys.stdin.readline
b = int(input())
ans = search_divisor_num(b)
print(ans)


from math import ceil
b = int(input())
k = 0
i = 1
while i ** 2 < b:
	if b % i == 0:
		k += 2
	i += 1
if i ** 2 == b:
	k += 1
print(k)


from math import ceil
b = int(input())
result = 1
for i in range(2, ceil(b ** (1 / 2))):
	if b % i == 0:
		result += 2
if b != 1:
	result += 1
	if int(b ** (1 / 2)) ** 2 == b:
		result += 1
print(result)


import sys
import string
from collections import Counter, defaultdict
from math import fsum, sqrt, gcd, ceil, factorial
from operator import add
inf = float('inf')
flush = lambda : sys.stdout.flush
comb = lambda x, y: factorial(x) // factorial(y) // factorial(x - y)
ip = lambda : input()
ii = lambda : int(input())
r = lambda : map(int, input().split())
rr = lambda : list(r())
n = ii()
c = 0
i = 1
while i ** 2 < n:
	if n % i == 0:
		c += 2
	i += 1
print(c + int(int(sqrt(n)) ** 2 == n))


b = int(input())
count = 0
i = 1
while i * i <= b:
	if b % i == 0:
		count += 2
		if i * i == b:
			count -= 1
	i += 1
print(count)


def function():
	n = int(input())
	count = 0
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0 and i * i != n:
			count += 2
		elif n % i == 0 and i * i == n:
			count += 1
	print(count)
function()


b = int(input())

def factorize(n):
	fct = []
	(b, e) = (2, 0)
	while b * b <= n:
		while n % b == 0:
			n = n // b
			e = e + 1
		if e > 0:
			fct.append((b, e))
		(b, e) = (b + 1, 0)
	if n > 1:
		fct.append((n, 1))
	return fct

def divisorize(fct):
	try:
		(b, e) = fct.pop()
	except:
		return []
	pre_div = divisorize(fct) if fct else [[]]
	suf_div = [[(b, k)] for k in range(e + 1)]
	return [pre + suf for pre in pre_div for suf in suf_div]

def num(fct):
	a = 1
	for (base, exponent) in fct:
		a = a * base ** exponent
	return a
primes = factorize(b)
num_divisors = 1
for (prime, num) in primes:
	num_divisors *= num + 1
print(num_divisors)


import math
numero = int(input())
raiz = math.sqrt(numero)
resposta = 0
for i in range(1, int(raiz) + 1):
	if numero % i == 0:
		if i == raiz:
			resposta += 1
		else:
			resposta += 2
print(resposta)


import math

def solve(n):
	if n == 1:
		print(1)
		return
	elif n == 2:
		print(2)
		return
	d = 2
	j = 2
	while j * j < n:
		if n % j == 0:
			d += 2
		j += 1
	if j * j == n:
		d += 1
	print(d)

def main():
	n = int(input())
	solve(n)
main()


import math
n = int(input())
b = math.sqrt(n)
a = int(b)
c = 0
for i in range(1, a + 1):
	if n % i == 0:
		c = c + 1
if b - a > 0:
	print(2 * c)
elif b - a == 0:
	print(2 * c - 1)


a = int(input())
if a == 1:
	print(1)
	exit()
cnt = 1
for i in range(2, int(a ** 0.5) + 1):
	if a % i == 0:
		cnt += 1
cnt *= 2
if int(a ** 0.5) ** 2 == a:
	cnt -= 1
print(cnt)


import math
b = int(input())

def divisorGenerator(n):
	temp = []
	for i in range(1, int(math.sqrt(n)) + 1):
		if n % i == 0:
			yield i
			if i * i != n:
				temp.append(n / i)
	for t in temp:
		yield t
print(len(list(divisorGenerator(b))))


b = int(input())
div = []
for i in range(1, int(b ** 0.5) + 2):
	if b % i == 0:
		div.append(i)
		div.append(b // i)
div = sorted(set(div))
print(len(div))


b = int(input())
divisors = 0
for i in range(1, int(b ** 0.5) + 1):
	if b % i == 0:
		divisors += 1
if int(b ** 0.5) ** 2 == b:
	total = 2 * divisors - 1
else:
	total = 2 * divisors
print(total)


b = int(input())
n = 0
from math import sqrt
r = int(sqrt(b))
for i in range(1, r + 1):
	if b % i == 0:
		n += 1
n *= 2
if r * r == b:
	n -= 1
print(n)


import math as mt
n = int(input())
c = 0
list = []
while n % 2 == 0:
	list.append(2)
	n //= 2
for i in range(3, int(mt.sqrt(n)) + 1, 2):
	while n % i == 0:
		list.append(i)
		n //= i
if n > 2:
	list.append(n)
p = 1
temp = []
for i in list:
	if i not in temp:
		temp.append(i)
for i in temp:
	p *= list.count(i) + 1
print(p)


n = int(input())
if n == 1:
	print(1)
	exit(0)
if n == 2:
	print(2)
	exit(0)
cnt = 0
for i in range(1, int(n ** 0.5) + 1):
	if n % i == 0 and i != n // i:
		cnt += 2
	elif n % i == 0:
		cnt += 1
print(cnt)


import math
b = int(input().strip())

def computeGCD(x, y):
	if x > y:
		small = y
	else:
		small = x
	for i in range(1, small + 1):
		if x % i == 0 and y % i == 0:
			gcd = i
	return gcd

def divisors(n):
	res = []
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n / i == i:
				res.append(i)
			else:
				res.append(i)
				res.append(n // i)
		i = i + 1
	return res

def fracs(b):
	frac = set()
	for i in divisors(b):
		tmp = b // i
		if tmp not in frac:
			frac.add(tmp)
	return len(frac)
print(fracs(b))


from sys import stdin, stdout
import cProfile, math
from collections import Counter
from bisect import bisect_left
import itertools
printHeap = str()
test = False
memory_constrained = False
N = 10 ** 9 + 7
import sys
sys.setrecursionlimit(10000000)

def display(string_to_print):
	stdout.write(str(string_to_print) + '\n')

def primeFactors(n):
	factors = dict()
	for i in range(2, math.ceil(math.sqrt(n)) + 1):
		while n % i == 0:
			if i in factors:
				factors[i] += 1
			else:
				factors[i] = 1
			n = n // i
	if n > 2:
		factors[n] = 1
	return factors

def isprime(n):
	if n < 4:
		return True
	if n % 2 == 0:
		return False
	if n % 3 == 0:
		return False
	i = 5
	w = 2
	while i * i <= n:
		if n % i == 0:
			return False
		i += w
		w = 6 - w
	return True

def test_print(*args):
	if test:
		print(args)

def display_list(list1, sep=' '):
	stdout.write(sep.join(map(str, list1)) + '\n')

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

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

def get_list():
	return list(map(int, stdin.readline().split()))
memory = dict()

def clear_cache():
	global memory
	memory = dict()

def cached_fn(fn, *args):
	global memory
	if args in memory:
		return memory[args]
	else:
		result = fn(*args)
		memory[args] = result
		return result
TestCases = False

def main():
	b = get_int()
	if b == 1:
		print(1)
	else:
		if isprime(b):
			print(2)
			return
		res = 1
		factors = primeFactors(b)
		for i in factors.keys():
			res = (factors[i] + 1) * res
		print(res)
if TestCases:
	for _ in range(get_int()):
		cProfile.run('main()') if test else main()
else:
	cProfile.run('main()') if test else main()


n = int(input())
ans = 0
for x in range(1, int(n ** (1 / 2)) + 1):
	if n % x == 0:
		ans += 2
if pow(int(n ** (1 / 2)), 2) == n:
	ans -= 1
print(ans)


from collections import Counter
from math import sqrt

def divs_fast(b):
	counts = Counter()
	while b > 1 and b % 2 == 0:
		counts[2] += 1
		b //= 2
	for i in range(3, int(sqrt(b)) + 1, 2):
		while True:
			(x, t) = divmod(b, i)
			if t == 0:
				b = x
				counts[i] += 1
			else:
				break
	if b > 1:
		counts[b] += 1
	c = 1
	for v in counts.values():
		c *= v + 1
	return c
print(divs_fast(int(input())))


def fun():
	n = int(input())
	s = set()
	limit = int(n ** 0.5) + 1
	for i in range(1, limit):
		if n % i == 0:
			s.add(i)
			s.add(n // i)
	print(len(s))
fun()


n = int(input())
ans = 0
for i in range(1, n + 1):
	if i * i > n:
		break
	if n % i == 0:
		ans += 2
	if i * i == n:
		ans -= 1
print(ans)


def factors(x):
	k = 0
	i = 1
	while i * i <= x:
		if x % i == 0:
			k += 1
			if x // i != i:
				k += 1
		i += 1
	return k
b = int(input())
s = factors(b)
print(s)


from math import sqrt
n = int(input())
m = int(sqrt(n))
i = 1
cnt = 0
while i <= m:
	if n % i == 0:
		cnt += 2
	i += 1
if m * m == n:
	cnt -= 1
print(cnt)


def divisors(n):
	i = 2
	k = 1
	while i * i <= n:
		q = 1
		while n % i == 0:
			n //= i
			q += 1
		k *= q
		i += 1
	if n != 1:
		k *= 2
	return k

def bruh():
	n = int(input())
	if n == 1:
		print(1)
	else:
		print(divisors(n))
bruh()


import math
b = int(input())
n = 0
i = 1
while i * i < b:
	if b % i == 0:
		n += 1
	i += 1
print(n * 2 + (i * i == b))


from math import sqrt

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

def check(b):
	d = {}
	for i in range(1, b + 1):
		temp = gcd(i, b)
		d[b // temp] = 1
	d[1] = 1
	d[b] = 1
	return len(d)
n = int(input())
ans = 1
if n == 1:
	print(1)
else:
	ans = 2
	i = 2
	while i ** 2 < n:
		if n % i == 0:
			ans += 2
		i += 1
	if i ** 2 == n:
		ans += 1
	print(ans)


import sys, math
b = int(input())
x = 0
for i in range(1, int(b ** 0.5) + 1):
	if b % i == 0:
		if b / i == i:
			x += 1
		else:
			x += 2
print(x)


import math

def primeFactors(n):
	ans = []
	while n % 2 == 0:
		(ans.append(2),)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			(ans.append(i),)
			n = n / i
	if n > 2:
		ans.append(n)
	return ans
b = int(input())
pd = primeFactors(b)
if not pd:
	print(1)
else:
	from collections import Counter
	ct = Counter(pd)
	n = 1
	for v in ct.values():
		n *= v + 1
	print(n)


b = int(input())
counter = 0
if b ** 0.5 % 1 == 0:
	counter += 1
for i in range(1, int(b ** 0.5 - 0.001) + 1):
	if b / i % 1 == 0:
		counter += 2
print(counter)


import math
b = int(input())
c = 0
for i in range(1, math.floor(math.sqrt(b)) + 1):
	if b % i == 0:
		c += 2
	if i * i == b:
		c -= 1
print(c)


from math import sqrt
b = int(input())

def factors(n):
	c = 0
	if n > 1:
		for i in range(1, int(n ** 0.5) + 1):
			if n % i == 0:
				c += 2
		if n ** 0.5 == int(n ** 0.5):
			c = c - 1
		return c
	else:
		return 1
print(factors(b))


n = int(input())

def checkPower(t, i):
	if i == 1:
		return 1
	j = 0
	while True:
		if t % i == 0:
			t = t // i
		else:
			break
		j = j + 1
	return j
from math import sqrt
d = set({})
for i in range(1, int(sqrt(n)) + 1):
	if n % i == 0:
		d.add(i)
		if n // i != i:
			d.add(n // i)
print(len(d))


from math import sqrt
n = int(input())
i = 1
count = 0
if n == 1:
	print(1)
else:
	while i <= sqrt(n):
		if n % i == 0:
			if n / i == i:
				count += 1
			else:
				count += 2
		i += 1
	print(count)


n = int(input())
seen = {1, n}
for i in range(1, int(n ** 0.5) + 2):
	if n % i == 0:
		seen.add(i)
		seen.add(n // i)
print(len(seen))


def rasl_d(a):
	r = 2
	x = []
	while r * r <= a:
		if a % r == 0:
			x.append(r)
			s = r
			r = 2
			a /= s
		else:
			r += 1
	if r * r > a:
		x.append(a)
	return x

def delnumber(n):
	if n == 1:
		return 1
	b = 1
	x = rasl_d(n)
	u = x[0:len(x):1]
	for i in set(x):
		a = u.count(i)
		b *= a + 1
	return b
print(delnumber(int(input())))


b = int(input())
num = 1
cont = 0
while True:
	if num * num > b:
		break
	if b % num == 0:
		cont += 1
		if num * num != b:
			cont += 1
	num += 1
print(cont)


import math

def div(b):
	arr = []
	if b % 2 == 0:
		count = 1
		while b % 2 == 0:
			b = b // 2
			count += 1
		arr += [count]
	for i in range(3, int(math.sqrt(b)) + 1, 2):
		if b % i == 0:
			count1 = 1
			while b % i == 0:
				b = b // i
				count1 += 1
			arr += [count1]
		if b == 1:
			break
	if b != 1:
		arr += [2]
	return arr
b = int(input())
arr = div(b)
ans = 1
for ii in range(len(arr)):
	ans *= arr[ii]
print(ans)


from math import sqrt
n = int(input())
l = int(sqrt(n)) + 1
print(len({y for x in range(1, l) if n % x == 0 for y in [x, n // x]}))


n = int(input())
wyn = 0
x = 1
while True:
	if x * x > n:
		break
	if n % x == 0:
		if x * x != n:
			wyn += 2
		else:
			wyn += 1
	x += 1
print(wyn)


n = int(input())
answer = 0
for i in range(1, int(n ** 0.5 + 1)):
	if i ** 2 == n:
		answer += 1
	elif n % i == 0:
		answer += 2
print(answer)


n = int(input())
r = 0
for i in range(1, int(n ** 0.5) + 1, 1):
	if n % i == 0:
		r += len(set([i, n / i]))
print(r)


from math import sqrt
b = int(input())
count = 0
for i in range(1, int(sqrt(b)) + 1):
	if b % i == 0:
		if b // i == i:
			count += 1
		else:
			count += 2
print(count)