Fafa owns a company that works on huge projects. There are n employees in Fafa's company. Whenever the company has a new project to start working on, Fafa has to divide the tasks of this project among all the employees.

Fafa finds doing this every time is very tiring for him. So, he decided to choose the best l employees in his company as team leaders. Whenever there is a new project, Fafa will divide the tasks among only the team leaders and each team leader will be responsible of some positive number of employees to give them the tasks. To make this process fair for the team leaders, each one of them should be responsible for the same number of employees. Moreover, every employee, who is not a team leader, has to be under the responsibility of exactly one team leader, and no team leader is responsible for another team leader.

Given the number of employees n, find in how many ways Fafa could choose the number of team leaders l in such a way that it is possible to divide employees between them evenly.


-----Input-----

The input consists of a single line containing a positive integer n (2 ≤ n ≤ 10^5) — the number of employees in Fafa's company.


-----Output-----

Print a single integer representing the answer to the problem.


-----Examples-----
Input
2

Output
1

Input
10

Output
3



-----Note-----

In the second sample Fafa has 3 ways:  choose only 1 employee as a team leader with 9 employees under his responsibility.  choose 2 employees as team leaders with 4 employees under the responsibility of each of them.  choose 5 employees as team leaders with 1 employee under the responsibility of each of them.

Source: codeforces | Difficulty: EASY
Tags: Implementation

Complete search


Solutions:
import math
n = int(input())
count = 0
for i in range(1, math.ceil(n / 2 + 1)):
	if (n - i) % i == 0:
		count += 1
print(count)


n = int(input())
print(sum([n % i == 0 for i in range(1, n)]))


n = int(input())
cnt = 1
for i in range(2, n // 2 + 1):
	if n % i == 0 and (n - i) % i == 0:
		cnt += 1
print(cnt)


n = int(input())
count = 0
for i in range(1, n):
	a = n - i
	if a % i == 0:
		count += 1
print(count)


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


number_of_empl = int(input())
count = 0
check = 1
while True:
	t = number_of_empl
	t -= check
	if t % check == 0:
		count += 1
	check += 1
	if check == number_of_empl:
		break
print(count)


n = int(input(''))
n_splits = 0
for n_leaders in range(1, n // 2 + 1):
	if (n - n_leaders) % n_leaders == 0:
		n_splits += 1
print(n_splits)


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


n = input()
n = int(n)
flag = 0
for i in range(1, n):
	a = n - i
	b = a / i
	c = a // i
	if b == c:
		flag += 1
print(flag)


class Main:
	n = int(input())
	ways = 0
	for leaders in range(1, int(n / 2) + 1):
		employees = n - leaders
		if employees / leaders == int(employees / leaders):
			ways += 1
	print(ways)
Main()


n = int(input())
c = 0
for q in range(1, n // 2 + 1):
	m = (n - q) / q
	if m >= 1 and m % 1 == 0:
		c += 1
print(c)


x = int(input())
a = 0
for i in range(1, x):
	if x % i == 0:
		a = a + 1
print(a)


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


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


n = int(input())
count = 1
for i in range(2, n // 2 + 1):
	a = n - i
	a1 = n - a
	if a % a1 == 0:
		count += 1
	else:
		pass
print(count)


n = int(input())
l = [x for x in range(1, n) if n % x == 0]
print(len(l))


import sys, math
input = sys.stdin.readline
L = lambda : list(map(int, input().split()))
M = lambda : map(int, input().split())
n = int(input())
i = 2
c = 0
while i < math.sqrt(n):
	if n % i == 0:
		c += 1
	i += 1
c *= 2
if i ** 2 == n:
	c += 1
print(c + 1)


a = int(input())
b = 0
for i in range(1, a):
	if a % i == 0:
		b += 1
print(b)


import sys
total = int(sys.stdin.readline())
t = 0
for tl in range(1, int(total / 2) + 1):
	m = total - tl
	if m % tl == 0:
		t += 1
print(t)


n = int(input())
t = 0
for i in range(1, n):
	if (n - i) % i == 0:
		t += 1
print(t)


employees = int(input())
count = 1
for i in range(2, employees // 2 + 1):
	if (employees - i) % i == 0:
		count += 1
print(count)


n = int(input())
c = 0
for i in range(1, n):
	if n % i == 0:
		c += 1
print(c)


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


inp = int(input())
k = 0
for i in range(1, inp):
	if (inp - i) % i == 0:
		k = k + 1
print(k)


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


(N, A) = (int(input()), 0)
for i in range(1, N // 2 + 1):
	if (N - i) % i == 0:
		A += 1
print(A)


n = int(input())
res = 0
l = 1
while l <= n / 2:
	if (n - l) % l == 0:
		res += 1
	l += 1
print(res)


n = int(input())
choices = 0
i = 1
while i < n:
	temp = int(n / i)
	if temp * i == n:
		choices += 1
	i += 1
print(choices)


n = int(input())
c = 0
l = 0
emp = 0
for i in range(1, n // 2 + 1):
	if (n - i) % i == 0:
		c += 1
print(c)


n = int(input())
divisores = []
for div in range(1, n + 1):
	if n % div == 0 and div <= n // 2:
		divisores.append(div)
print(len(divisores))


teams = int(input())
l = 0
for i in range(1, int(teams / 2 + 1)):
	if teams % i == 0:
		l = l + 1
print(l)


from math import sqrt, floor
n = int(input())
div = []
r = floor(sqrt(n))
for x in range(1, n):
	if n % x == 0:
		div.append(x)
div = set(div)
print(len(div))


n = int(input())
output = 0
for i in range(1, n):
	if (n - i) % i == 0:
		output += 1
print(output)


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


n = int(input())
x = 0
for i in range(1, n):
	if n % i == 0:
		x += 1
print(x)


n = int(input())
s = 0
for i in range(1, n):
	if n % i == 0:
		s += 1
print(s)


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


n = int(input())
count = 0
for i in range(n // 2 + 1):
	j = n - i
	if i != 0 and j != 0 and (max(i, j) % min(i, j) == 0):
		count += 1
print(count)


N = input()
j = 0
chance = 0
if int(N) == 2:
	print('1')
else:
	for i in range(0, int(N)):
		j = i + 1
		if j != int(N):
			if int(N) % j == 0:
				chance += 1
	print(chance)


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


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


emp = int(input())
ways = 0
for i in range(emp):
	if (emp - (i + 1)) % (i + 1) == 0 and emp - (i + 1):
		ways += 1
print(ways)


try:
	n = int(input())
	count = 0
	for i in range(1, n // 2 + 1):
		if (n - i) % i == 0:
			count += 1
	print(count)
except Exception:
	pass


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


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
print(countDivisors(int(input())) - 1)


from math import sqrt, ceil
n = int(input())
s = 0
for i in range(1, n):
	if not n % i:
		s += 1
print(s)


from sys import stdin as si
from collections import Counter as c

class Solution:

	def bazinga(self, b):
		a = 1
		for i in range(2, int(b / 2) + 1):
			if (b - i) % i == 0:
				a += 1
		return a
n = int(si.readline().strip())
S = Solution()
print(S.bazinga(n))


emp = int(input())
count = 0
for i in range(1, emp):
	employees = emp - i
	check = employees % i
	if not check:
		count += 1
	else:
		continue
print(count)


n = int(input())
l = 0
for i in range(1, n):
	if (n - i) % i == 0:
		l += 1
print(l)


import sys
import math
t = int(input())
count = 0
for h in range(1, t // 2 + 1):
	if t % h == 0:
		count += 1
print(count)


from copy import deepcopy
n = int(input())
a = deepcopy(n)
count = 0
while a != 0:
	a -= 1
	if a == n - 1:
		count += 1
	elif n - a <= a and a % (n - a) == 0:
		count += 1
print(count)


def empdiv(n):
	count = 0
	l = 0
	i = 1
	while i <= n / 2:
		if (n - i) % i == 0:
			count += 1
		i += 1
	return count
n = input()
n = int(n)
print(empdiv(n))


while 1:
	try:
		n = int(input())
	except:
		break
	su = 0
	for i in range(1, n):
		if n % i == 0:
			su += 1
	print(su)


import sys
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 function(n):
	l = 0
	for i in range(1, n):
		if (n - i) % i == 0:
			l += 1
	print(l)
n = inp()
function(n)


import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
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')
n = int(input())
mx = 1
for i in range(2, int(math.sqrt(n)) + 1):
	if n % i == 0:
		if i * i != n:
			mx += 1
		mx += 1
print(mx)


n = int(input())
tot = 0
for i in range(1, n):
	if n - i < i:
		break
	if (n - i) % i == 0:
		tot += 1
print(tot)


n = int(input())
count = 0
t = int(n / 2 + 1)
for i in range(1, t):
	if i == 1:
		count += 1
	else:
		j = n - i
		if j % i == 0:
			count += 1
		else:
			continue
print(count)


def getDivList(n):
	a = list()
	for i in range(1, n):
		if n % i == 0:
			a.append(i)
	return a

def start():
	n = int(input())
	print(len(getDivList(n)))
start()


import sys
n = int(sys.stdin.readline())

def fafa(n):
	out = 0
	for i in range(1, n // 2 + 1):
		num_lead = i
		if (n - i) % num_lead == 0:
			out += 1
		else:
			continue
	print(out)
fafa(n)


n = int(input())
j = 0
for i in range(1, n):
	if n % i == 0:
		j = j + 1
print(j)


n = int(input())
x = int(n)
i = 0
while x > 1:
	x = x - 1
	if n % x == 0:
		i = i + 1
	else:
		continue
print(i)


def main(n):
	sol = []
	for i in range(1, n):
		if n % i == 0:
			sol.append((n / i - 1, i))
	return len(sol)
n = int(input())
print(main(n))


getInput = int(input())
ways = 0
for i in range(1, getInput):
	remaining = getInput - i
	if remaining % i == 0:
		ways += 1
print(ways)


def dkwpwn(num):
	count = 0
	for i in range(1, num):
		if num % i == 0:
			count += 1
	return count
num = int(input())
print(dkwpwn(num))


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


import math
l = int(input())
num = 0
for i in range(math.ceil(l / 2)):
	if (l - i - 1) / (i + 1) == math.floor((l - i - 1) / (i + 1)):
		num = num + 1
print(num)


import sys
n = int(sys.stdin.readline().rstrip())
count = 0
for l in range(1, n):
	if (n - l) % l == 0:
		count += 1
print(str(count) + '\n')


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


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


x = int(input())
y = 0
for i in range(1, x):
	z = x - i
	if z % i == 0:
		y += 1
print(y)


n = int(input())
con = 0
for l in range(1, n):
	if (n - l) % l == 0:
		con += 1
print(con)


a = int(input())
ans = 0
for i in range(a - 1):
	if (a - (i + 1)) % (i + 1) == 0:
		ans += 1
print(ans)


n = int(input())
ans = 0
for x in range(1, n):
	if n % x == 0:
		ans += 1
print(ans)


amount = int(input())
leaders = 0
for i in range(1, 1 + amount // 2):
	if amount % i == 0:
		leaders += 1
print(leaders)


import math
n = int(input())
count = 0

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


def factors(n):
	result = set()
	for i in range(1, int(n ** 0.5) + 1):
		(div, mod) = divmod(n, i)
		if mod == 0:
			result |= {i, div}
	return result
n = int(input())
print(len(factors(n)) - 1)


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


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


n = int(input())
methods = 0
for l in range(1, n):
	if (n - l) % l == 0:
		methods += 1
print(methods)


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


people = int(input())
i = 1
boss = 0
while people - i > 0:
	if (people - i) % i == 0:
		boss += 1
	i += 1
print(boss)


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


s = int(input())
n = 0
if s >= 2 and s <= 100000:
	for i in range(1, s, 1):
		if s % i == 0:
			n += 1
print(n)


n = int(input())
leader = 1
c = 0
while leader <= n // 2:
	if (n - leader) % leader == 0:
		c += 1
	leader += 1
print(c)


n = int(input())
cnt = 0
for l in range(1, n):
	if (n - l) % l == 0:
		cnt += 1
print(cnt)


n = int(input())
print(len([i for i in range(1, n) if (n - i) % i == 0]))


x = int(input())
cnt = 0
for i in range(1, x, 1):
	if x % i == 0:
		cnt = cnt + 1
print(cnt)


n = int(input())
w = 0
for i in range(1, n + 1):
	if (n - i) % i == 0:
		w += 1
print(w - 1)


s = int(input())
count = 0
for i in range(s):
	temp = s - (i + 1)
	if temp % (i + 1) == 0:
		count += 1
print(count - 1)


n = int(input())
r = 0
for x in range(1, n // 2 + 1):
	r += n % x == 0
print(r)


def fafa_and_his_company(string):
	employees = int(string)
	combos = 0
	for i in range(1, employees):
		if (employees - i) % i == 0:
			combos += 1
	return combos
print(fafa_and_his_company(input()))


input_ = int(input())
j = 0
for i in range(1, input_):
	workers = input_ - i
	if workers % i == 0:
		j += 1
print(j)


t = int(input())
cnt = 0
for i in range(1, t + 1):
	if i + (t - i) // i * i == t:
		cnt += 1
print(cnt - 1)


(n, i, s) = (int(input()), 1, 0)
while i <= (n + 1) // 2:
	(s, i) = (s + int(float((n - i) // i) == (n - i) / i), i + 1)
print(s)


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


x = int(input())
l = []
c = 0
for i in range(1, x):
	if x % i == 0:
		l = l + [i]
print(len(l))


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


n = int(input())
cont = 0
for i in range(1, n):
	if n % i == 0:
		cont += 1
print(cont)


n = int(input())
count = 0
for m in range(1, n):
	if (n - m) % m == 0:
		count += 1
print(count)


n = int(input())
qwe = 0
i = 1
while i < n:
	r = n - i
	if r % i == 0:
		qwe = qwe + 1
		i = i + 1
	else:
		i = i + 1
print(qwe)


variants = 0
n = int(input())
for i in range(n, 1, -1):
	if n % i == 0:
		variants += 1
print(variants)


n = int(input())
i = 1
count = 0
while i != n:
	x = n - i
	if x % i == 0:
		count += 1
	i += 1
print(count)


a = int(input())
ways = 0
for leader_count in range(1, a):
	employee_left = a - leader_count
	if employee_left % leader_count == 0:
		ways += 1
print(ways)


import math

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


import math
n = int(input())
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)
s = list(set(l))
t = 1
for i in s:
	t *= l.count(i) + 1
print(t - 1)


n = int(input())
curL = 1
rem = n - curL
ans = 0
while rem > 0:
	if curL % rem == 0:
		ans += 1
	curL += 1
	rem -= 1
print(ans)


n = int(input())
i = 1
c = 0
while i < int(n / 2) + 1:
	if (n - i) % i == 0:
		c += 1
	i += 1
print(c)


import math

def cumulative_sum(n):
	return (n - 1) ** 2 / n
n = int(input())
i = 1
k = 0
while i < n:
	if n % i == 0:
		k += 1
	i += 1
print(k)


n = int(input())
mogucnosti = 1
leader = 2
while leader <= n // 2:
	if (n - leader) % leader == 0:
		mogucnosti += 1
	leader += 1
print(mogucnosti)


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


import sys

class Fafa:

	def __init__(self, e):
		self.emp = e

	def printing(self):
		ways = 0
		for i in range(1, self.emp):
			if (self.emp - i) % i == 0:
				ways += 1
		return ways

def main():
	input = int(sys.stdin.readline())
	X = Fafa(input)
	print(X.printing())
main()


from collections import deque, Counter
import array
from itertools import combinations, permutations
from math import sqrt
import unittest

def read_int():
	return int(input().strip())

def read_int_array():
	return [int(i) for i in input().strip().split(' ')]
n = read_int()
count = 0
for i in range(1, n // 2 + 1):
	if (n - i) % i == 0:
		count += 1
print(count)


eT = int(input())
l = 1
c = 0
while eT >= l:
	e = eT - l
	l += 1
	if eT % l == 0:
		c += 1
print(c)


cnt = 0
n = int(input())
for i in range(1, n):
	cnt = cnt + (n % i == 0)
print(cnt)


n = int(input())
ways = 0
for leaders in range(1, n):
	employee = n - leaders
	if employee % leaders == 0:
		ways += 1
print(ways)


emp = int(input())
count = 0
for x in range(1, int(emp / 2) + 1):
	if emp % x == 0:
		count += 1
print(count)


import math

def find_prime_factors(n):
	factors = dict()
	while n % 2 == 0:
		if 2 not in factors:
			factors[2] = 1
		else:
			factors[2] += 1
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			if i not in factors:
				factors[i] = 1
			else:
				factors[i] += 1
			n = n / i
	if n > 2:
		factors[n] = 1
	return factors
n = int(input())
prime_factors = find_prime_factors(n)
ans = 1
for key in prime_factors.keys():
	ans *= prime_factors[key] + 1
ans -= 1
print(ans)


tasks = int(input())
options = 0
for leaders in range(1, tasks // 2 + 1):
	if tasks % leaders == 0:
		employees = tasks - leaders / leaders
		if employees == int(employees):
			options += 1
print(options)


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


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


k = int(input())
count = 0
flag = 0
for i in range(1, k):
	j = k - i
	if j == 0:
		print(count)
		flag = 1
	elif j % i == 0:
		count = count + 1
if flag == 0:
	print(count)


n = int(input())
lst = list()
for i in range(n):
	if i != 0:
		if n % i == 0:
			lst.append(i)
print(len(lst))


n = int(input())
z = 0
for i in range(1, n):
	if (n - i) % i == 0:
		z += 1
print(z)


import math
import sys
from sys import *
from bisect import insort
import heapq
import collections
from collections import deque, defaultdict
from itertools import permutations, combinations, combinations_with_replacement
import random
import os
mod = 10 ** 9 + 7
MAX = sys.maxsize
MIN = -sys.maxsize - 1

def isPrime(n):
	if n > 1:
		for i in range(2, n):
			if n % i == 0:
				return False
		else:
			return True
	else:
		return False

def isPanagram(s):
	alphabet = 'abcdefghijklmnopqrstuvwxyz'
	for char in alphabet:
		if char not in s.lower():
			return False
	return True

def isEqual(list1):
	if len(list1) < 0:
		res = True
	res = all((ele == list1[0] for ele in list1))
	if res:
		return True
	else:
		return False

def remove_duplicate(list1):
	final_list = []
	for i in list1:
		if i not in final_list:
			final_list.append(i)
	return final_list

def solve():
	count = 0
	n = int(input())
	if isPrime(n):
		return 1
	else:
		for i in range(1, n // 2 + 1):
			if n % i == 0:
				count += 1
		return count
result = solve()
stdout.write(str(result) + '\n')


def main():
	n = int(sys.stdin.readline())
	count = 0
	for i in range(1, n):
		if n % i == 0:
			count += 1
	print(count)
import sys
from math import gcd
main()


t = int(input())
print(sum((t % i < 1 for i in range(1, t))))


from math import *

def printDivisors(n):
	i = 1
	while i * i < n:
		if n % i == 0:
			a.append(i)
		i += 1
	for i in range(sqr, 0, -1):
		if n % i == 0:
			a.append(n // i)
	print(len(a) - 1)
n = int(input())
sqr = int(sqrt(n))
a = []
printDivisors(n)


total_employees = int(input())
initial = 1
ways = 0
while initial < total_employees:
	leaders = total_employees - initial
	if (total_employees - leaders) % leaders == 0:
		ways += 1
		initial += 1
	else:
		initial += 1
print(ways)


n = int(input())
count = 0
for x in range(1, n + 1):
	if (n - x) % x == 0 and n - x > 0:
		count += 1
print(count)


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


a = int(input())
c = 0
for x in range(1, a + 1):
	t = x + 1
	p = a - t
	if p % t == 0:
		c = c + 1
print(c)


n = int(input())
m = 0
for i in range(1, n):
	E = n - i
	if E % i == 0:
		m = m + 1
print(m)


def teamleaders(n):
	ans = 0
	for t in range(1, n):
		if n / t - int(n / t) == 0:
			ans += 1
	return ans
n = int(input())
print(teamleaders(n))


num = int(input())
print(sum([1 if (num - i) % i == 0 else 0 for i in range(1, num)]))


def main():
	n = int(input())
	count = 0
	if n > 1:
		for i in range(1, n):
			if n % i == 0:
				count += 1
	print(count)
main()


import time

def divideTLeaders(nEmp):
	nways = 0
	for x in range(1, nEmp):
		if nEmp % x == 0:
			nways += 1
	return nways

def solve():
	nEmp = int(input())
	print(divideTLeaders(nEmp))
solve()


def solve():
	n = int(input())
	hh = [1] * (n + 1)
	p = 2
	while p * p < n:
		if hh[p] == 1:
			for i in range(p * 2, n, p):
				hh[i] = 0
		p += 1
	total = 1
	for p in range(2, n + 1):
		if hh[p] == 1:
			count = 0
			if n % p == 0:
				while n % p == 0:
					n = int(n / p)
					count += 1
				total *= count + 1
	print(total - 1)
solve()


n = int(input())
num = sum((n % i < 1 for i in range(1, n)))
print(num)


empl = int(input())
ways = 0
for i in range(1, empl):
	if (empl - int(i)) / int(i) % 1 == 0:
		ways += 1
print(ways)


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


n = int(input())
count = 0
for l in range(1, n):
	if (n - l) % l == 0:
		count += 1
print(count)


inp = input
li = list
iinp = lambda : int(inp())
ent = lambda : map(int, inp().split())
lient = lambda : li(ent())
n = iinp()
res = 1
for i in range(2, n // 2 + 1):
	if (n - i) % i == 0:
		res += 1
print(res)


n = input()
n = int(n)
d = 0
for i in range(1, n + 1):
	if n % i == 0:
		d += 1
print(d - 1)


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [input() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [int(input()) for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def divisor(n):
		res = []
		i = 1
		for i in range(1, int(n ** 0.5) + 1):
			if n % i == 0:
				res.append(i)
				if i != n // i:
					res.append(n // i)
		return res

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

	@staticmethod
	def is_prime(n):
		if n < 2:
			return False
		if n == 2:
			return True
		if n % 2 == 0:
			return False
		d = int(n ** 0.5) + 1
		for i in range(3, d + 1, 2):
			if n % i == 0:
				return False
		return True

class PriorityQueue:

	def __init__(self, l=[]):
		self.q = l
		heapq.heapify(self.q)
		return

	def push(self, n):
		heapq.heappush(self.q, n)
		return

	def pop(self):
		return heapq.heappop(self.q)
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def main():
	N = Scanner.int()
	print(len(Math.divisor(N)) - 1)
main()


def factors(n):
	count = 0
	for i in range(1, n // 2 + 1):
		if n % i == 0:
			count += 1
		else:
			continue
	print(count)
emps = int(input(''))
factors(emps)


q = int(input())
a = 0
for i in range(1, q + 1):
	if q % i == 0:
		a += 1
		s = a - 1
print(s)


import sys
n = int(input())
solutions = 0
leader = 1
n = n - 1
while n > 0:
	if n % leader == 0:
		solutions = solutions + 1
	n = n - 1
	leader = leader + 1
print(solutions)


N = int(input())
ways = 0
for i in range(1, N):
	if (N - i) % i == 0:
		ways += 1
print(ways)


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


n = int(input())
temp = n
w = int(n / 2) + 1
count = 0
for i in range(1, w):
	n = n - i
	w = int(n / i)
	if w == n / i:
		count += 1
	n = temp
print(count)


n = int(input())
res = 0
for i in range(1, n):
	res += 1 if n % i == 0 else 0
print(res)


n = int(input())
divs = []
i = 1
while i * i <= n:
	if n % i == 0:
		divs.append(i)
	i += 1
for i in range(len(divs)):
	if divs[i] * divs[i] != n:
		divs.append(n // divs[i])
result = 0
for i in range(len(divs)):
	if (n - divs[i]) % divs[i] == 0 and n - divs[i] > 0:
		result += 1
print(result)


n = int(input())

def x(sb):
	answer = 0
	for i in range(1, sb):
		if i % (sb - i) == 0:
			answer += 1
	return answer
print(x(n))


t = int(input())
q = 0
for i in range(1, t):
	if t % i == 0:
		q += 1
print(q)


n = int(input())

def output(n):
	count = 0
	for i in range(1, n):
		if n % i == 0:
			count += 1
	return count
print(output(n))


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


n = int(input())
value = 0
for io in range(n - 1):
	if n % (io + 1) == 0:
		value += 1
print(value)


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


def go():
	n = int(input())
	total = 0
	for i in range(1, n // 2 + 1):
		if (n - i) % i == 0:
			total += 1
	return total
print(go())


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


from sys import stdin
n = int(stdin.readline())
ways = 0
for i in range(1, n):
	if (n - i) % i == 0:
		ways += 1
print(ways)


n = int(input())
res = 1
i = 2
while i < n:
	if n % i == 0:
		res += 1
	i += 1
print(res, end='')


employees = int(input())
count = 0
for x in range(1, employees):
	if employees % x == 0:
		count += 1
print(count)


a = int(input())
p = 0
for i in range(1, a):
	if a % i == 0:
		p = p + 1
print(p)


def func(n):
	cnt = 0
	for l in range(1, n):
		if l * ((n - l) // l) + l == n:
			cnt += 1
	return cnt
n = int(input())
print(func(n))


n = int(input())
total = 0
for x in range(1, n):
	if (n - x) % x == 0:
		total += 1
print(total)


N = int(input())
cnt = 0
for i in range(1, N):
	if (N - i) % i == 0:
		cnt += 1
print(cnt)


import sys

def main():
	n = int(sys.stdin.readline())
	ans = 0
	for i in range(1, n // 2 + 1):
		if n % i == 0:
			ans += 1
	sys.stdout.write(f'{ans}')
main()


n = int(input())
nb_leader = 0
for x in range(1, n):
	if n % x == 0:
		nb_leader += 1
print(nb_leader)


flag = True
n = int(input())
ans = 0
for i in range(1, n):
	if (n - i) % i == 0:
		ans += 1
print(ans)


def prime_factors(n):
	i = 2
	factors = []
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.append(i)
	if n > 1:
		factors.append(n)
	return factors
n = int(input())
pf = prime_factors(n)
ans = 1
for i in set(pf):
	ans *= pf.count(i) + 1
print(ans - 1)


e = int(input())
most = e // 2
num = 0
for i in range(1, most + 1):
	emp = e - i
	if emp % i == 0:
		num += 1
print(num)


n = int(input())
ways = 0
for i in range(n - 1):
	LA = i + 1
	if (n - LA) % LA == 0:
		ways += 1
print(ways)


n2 = int(input())
counter = 0
n1 = n2
while n1 != 1:
	if (n2 / n1).is_integer():
		counter += 1
	n1 -= 1
print(counter)


n = int(input())
print(len([q for q in range(1, n) if n % q == 0]))


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

def test_1(n):
	count = 0
	for i in range(2, n + 1):
		if n % i == 0:
			count += 1
	return count
aa = test_1(n)
print(aa)


s = int(input())
y = 0
for x in range(1, s):
	if s % x == 0:
		y += 1
print(y)


t = int(input())
low = 1
high = t - 1
res = 0
while low <= high:
	if low % high == 0 or high % low == 0:
		res += 1
	low += 1
	high -= 1
print(res)


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


x = int(input())
j = 0
for i in range(1, x):
	if x % i == 0:
		j += 1
print(j)


n = int(input())
final_n = n
counter = 0
if not n % 2:
	final_n = n / 2
elif not n % 3:
	final_n = n / 3
elif not n % 5:
	final_n = n / 5
elif not n % 7:
	final_n = n / 7
else:
	final_n = n - 1
for x in range(1, int(final_n + 1)):
	if not n % x:
		counter += 1
print(counter)


n = int(input())
t = 0
for x in range(1, n):
	leader = x
	remaining = n - x
	if remaining % leader == 0:
		t += 1
	else:
		pass
print(t)


import sys
input = sys.stdin.readline
x = int(input())
k = 0
for y in range(1, x):
	if x % y == 0:
		k += 1
print(k)


n = int(input())
print(sum((n % x < 1 for x in range(1, n))))


n = int(input())
c = 0
for x in range(1, n):
	if n % x == 0:
		c += 1
print(c)


x = int(input())
count = 0
z = 1
while z < x:
	c = x - z
	if c % z == 0:
		count += 1
	z += 1
print(count)


n = int(input())
key = 1
val = n - key
c = 0
while key <= n // 2:
	if val % key == 0:
		c += 1
	key += 1
	val = n - key
print(c)


import math

def count_factors(n):
	c = 0
	for i in range(2, math.ceil(math.sqrt(n))):
		if n % i == 0:
			if i != n // i:
				c += 2
			else:
				c += 1
	if int(math.sqrt(n)) == math.sqrt(n):
		c += 1
	return c + 1
n = int(input())
if int(math.log(n, 2)) == math.log(n, 2):
	print(int(math.log(n, 2)))
else:
	print(count_factors(n))


a = int(input())
c = 0
for i in range(a):
	if i + 1 != a:
		if a % (i + 1) == 0:
			c += 1
print(c)


a = input()
n = int(a)
result = 0
for x in range(1, n):
	if n % x == 0:
		result = result + 1
print(result)


import sys
n = int(sys.stdin.readline())
result = 1
i = 2
while i * 2 <= n:
	if n % i == 0:
		result += 1
	i += 1
print(result)


import sys
input = sys.stdin.readline

def main():
	n = inp()
	ans = 0
	for i in range(2, n + 1):
		if (n - i) % i == 0:
			ans += 1
	print(ans)

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

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

def instr():
	return ''.join(insr())

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

def invr():
	return map(int, input().split())
main()


x = int(input())
ans = 0
for i in range(1, x // 2 + 1):
	if abs(x / i - x // i) < 1e-06:
		ans += 1
	else:
		pass
print(ans)


n = int(input())
i = 1
t = 0
while i <= n:
	p = n - i
	a = int(p / i)
	b = p / i
	if a == b and a != 0:
		t = t + 1
	elif a <= 0:
		break
	i = i + 1
print(t)


def employee(n):
	c = 0
	for i in range(1, n):
		if n % i == 0:
			c = c + 1
	return c
n = int(input())
print(employee(n))


import sys

def solve():
	n = int(input())
	ans = 2
	check = n
	for i in range(2, n + 1):
		if i >= check:
			break
		if n % i == 0:
			if i == n / i:
				ans += 1
			else:
				ans += 2
			check = int(n / i)
	ans -= 1
	return ans
ans = solve()
print(ans)


import logging
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
logger.addHandler(ch)

def solve(n):
	total = 0
	for i in range(1, n // 2 + 1):
		total += (n - i) % i == 0
	return total

def main():
	n = int(input().strip())
	result = solve(n)
	print(result)
main()


inp = int(input())
counter = 0
for x in range(1, int(inp / 2) + 1):
	if inp % x == 0:
		counter += 1
print(counter)


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


n = int(input())
nb = 0
for i in range(n - 1):
	if (n - i - 1) % (i + 1) == 0:
		nb = nb + 1
print(nb)


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


def trial():
	num = int(input())
	divise = []
	for i in range(1, num):
		if num % i == 0:
			divise.append(i)
	return print(len(divise))
trial()


n = int(input())
pocet = 0
for i in range(1, n):
	if (n - i) % i == 0:
		pocet += 1
print(pocet)


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


n_employee = int(input())
counter = 0
for index in range(n_employee):
	if n_employee - index != 0 and index != 0:
		if (n_employee - index) % index == 0:
			counter = counter + 1
print(int(counter))


n = int(input())
count = 0
l = 1
while l < n:
	if (n - l) % l == 0:
		count = count + 1
	l = l + 1
print(count)


import sys
from collections import Counter
fin = sys.stdin
fout = sys.stdout
lines = (line.strip() for line in fin)
n = int(next(lines))
divisors = 1
for d in range(2, n // 2 + 1):
	if n % d == 0:
		divisors += 1
print(divisors, file=fout)


employees = int(input())
comb = 0
if employees == 1 or employees == 2:
	comb = 1
else:
	for i in range(1, employees):
		if employees % i == 0:
			comb += 1
print(comb)


t = int(input())
w = 0
for i in range(1, t // 2 + 1):
	if (t - i) % i == 0:
		w += 1
print(w)


x = int(input())
couner = 0
for i in range(1, x, 1):
	if x % i == 0:
		couner += 1
print(couner)


num = int(input())
cnt = 0
for i in range(num):
	if i == 0:
		continue
	elif num - i < i:
		break
	elif (num - i) % i == 0:
		cnt += 1
print(cnt)


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


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


import sys

def solve(io):
	N = io.readInt()
	ways = 0
	for leaders in range(1, N):
		remain = N - leaders
		if remain % leaders == 0:
			ways += 1
	print(ways)

class IO:
	input = None
	output = None
	raw = ''
	buf = []
	pos = 0

	def __init__(self, inputStream, outputStream):
		self.input = inputStream
		self.output = outputStream

	def readToBuffer(self):
		self.raw = self.input.readline().rstrip('\n')
		self.buf = self.raw.split()
		self.pos = 0

	def readString(self):
		while self.pos == len(self.buf):
			self.readToBuffer()
		ans = self.buf[self.pos]
		self.pos += 1
		return ans

	def readInt(self):
		return int(self.readString())

	def readFloat(self):
		return float(self.readString())

	def print(self, s):
		self.output.write(str(s))

	def println(self, s):
		self.print(s)
		self.print('\n')

	def flushOutput(self):
		self.output.flush()
pythonIO = IO(sys.stdin, sys.stdout)
solve(pythonIO)
pythonIO.flushOutput()


k = int(input())
g = 0
x = 1
while k > x:
	if k % x == 0:
		g += 1
	x += 1
print(g)


from sys import stdin
from math import sqrt
n = int(stdin.readline())

def divisors(num):
	if num == 1:
		return [1]
	divs = [1]
	for i in range(2, int(sqrt(num)) + 1):
		if num % i == 0:
			while num % i == 0:
				divs.append(divs[-1] * i)
				num /= i
			break
	if divs == [1]:
		return [1, num]
	ans = []
	for i in divs:
		ans += [i * j for j in divisors(num)]
	return ans
print(len(divisors(n)) - 1)


def main():
	n_employees = int(input())
	n_ways = 1
	for i in range(2, n_employees - 1):
		if n_employees % i == 0:
			n_ways += 1
	print(n_ways)
main()


no_of_employee = int(input())
count = 0
for i in range(1, no_of_employee):
	if (no_of_employee - i) % i == 0:
		count += 1
print(count)


n = int(input())
d = 2
total = 1
while n != 1:
	p = 0
	while n % d == 0:
		p += 1
		n = n // d
	total = total * (p + 1)
	if d * d > n:
		d = n
	elif d == 2:
		d += 1
	else:
		d += 2
print(total - 1)


N = int(input())
A = list(range(1, N))
C = 0
for i in A:
	if (N - i) % i == 0:
		C += 1
print(C)


n = int(input())
vrnts = 0
for i in range(1, n):
	if ((n - i) / i).is_integer():
		vrnts = vrnts + 1
print(vrnts)


import math

def kdel(x):
	k = 0
	for i in range(1, math.sqrt(x) + 1):
		if x % i == 0:
			k += 1
	return k

def isdel(x, y):
	return x % y == 0
x = int(input())
k = 0
for i in range(1, x // 2 + 1):
	if isdel(x - i, i):
		k += 1
print(k)


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


n = int(input(''))
out = 0
for i in range(1, n):
	if (n - i) % i == 0:
		out += 1
print(out)


n = int(input())
sum = 0
for i in range(1, n):
	if not n % i:
		sum += 1
print(sum)


n = int(input())
ans = 0
for i in range(1, n):
	x = i
	l = i
	e = n - l
	if e % l == 0:
		ans += 1
print(ans)


n = int(input())
wc = 0
for i in range(1, n):
	remnant = n - i
	if remnant % i == 0:
		wc += 1
print(wc)


n = int(input())
t = n
z = n
c = 0
w = 0
r = 0
if n % 2 == 0:
	for i in range(1, n):
		w = t - i
		if w % i == 0:
			r += 1
	print(r)
else:
	for i in range(1, n):
		c = z - i
		if c % i == 0:
			r += 1
	print(r)


class Solution:

	def solve(self, n):
		ans = 0
		for i in range(1, n):
			if (n - i) % i == 0:
				ans += 1
		return ans
sol = Solution()
n = int(input().strip())
print(sol.solve(n))


n = int(input())
l = 0
i = 1
for i in range(n):
	j = i + 2
	if n % j == 0:
		l += 1
	else:
		continue
print(int(l))


n = int(input(''))
l = 1
ways = 0
vari = 0
for i in range(0, n // 2):
	vari = n - l
	if n % l == 0:
		ways += 1
	l += 1
print(ways)


n = int(input())
a = []
for l in range(1, n):
	if n % l == 0 and n / l > 1:
		a.append(l)
print(len(a))


x = int(input())
ans = 0
for div in range(1, x):
	if x % div == 0:
		ans = ans + 1
print(ans)


num = int(input())
count = 0
for p in range(1, num, +1):
	if (num - p) / p == (num - p) // p:
		count += 1
print(count)


n = int(input())
z = int(n / 2)
lst = list()
for i in range(1, z + 1):
	l = i
	e = n - l
	if e % l == 0:
		lst.append(l)
x = len(lst)
print(x)


num = int(input().strip())
count = 0
for i in range(1, num):
	if num % i == 0 and i != num:
		count += 1
print(count)


import sys
f = input()
n = int(f)
count = 0
for i in range(1, n):
	count += n % i == 0
print(count)


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


def main():
	N = int(input())
	n = N // 2
	leaders = 1
	for i in range(2, n + 1):
		if not (N - i) % i:
			leaders += 1
	print(leaders)
main()


k = int(input())
ds = 0
for i in range(1, k):
	if (k - i) % i == 0:
		ds += 1
print(ds)


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


from sys import stdin, stdout
n = int(stdin.readline())
count = 0
for i in range(1, (n >> 1) + 1):
	if (n - i) % i == 0:
		count += 1
stdout.write(str(count))


x = int(input())
s = 0
for i in range(1, x):
	if x % i == 0:
		s += 1
print(s)


from functools import reduce

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


n = int(input())
d = 0
for f in range(1, n // 2 + 1):
	x = n - f
	if x % f == 0 or f % x == 0:
		d = d + 1
print(d)


n = int(input())
x = 0
y = 1
while y <= n / 2:
	if n % y == 0:
		x = x + 1
	y = y + 1
print(x)


num = int(input())
count = 0
for i in range(num):
	normal = num - (i + 1)
	if normal % (i + 1) == 0:
		count += 1
print(count - 1)


import math
(n, res) = (int(input()), 0)
for i in range(1, math.ceil(n / 2) + 1):
	if not (n - i) % i:
		res += 1
print(res)


n = int(input())
f = 0
for x in range(1, n):
	if (n - x) % x == 0:
		f += 1
print(f)


def solve(employees):
	output = 0
	for e in range(1, employees, 1):
		if (employees - e) % e == 0:
			output += 1
	return output
n = int(input())
print(solve(n))


n = int(input())
leaders = 1
c = 0
while leaders != n:
	rem = n - leaders
	if rem % leaders == 0:
		c += 1
	leaders += 1
print(c)


n = int(input())
result = 0
for i in range(1, n):
	if (n - i) % i == 0:
		result += 1
print(result)


n = int(input(''))
i = 1
s = 0
while i <= n - 1:
	if n % i == 0:
		s += 1
	i += 1
print(s)


x = int(input())
d = 0
for i in range(1, x + 1):
	if x % i == 0:
		d += 1
print(d - 1)


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


def main():
	employees = int(input())
	number_of_team_leaders = 0
	half_employees = employees // 2 + 1
	for i in range(1, half_employees):
		if (employees - i) % i == 0:
			number_of_team_leaders += 1
	print(number_of_team_leaders)
main()


n = int(input())
print(sum((not n % i for i in range(1, n // 2 + 1))))


def main(kol):
	h = 0
	for i in range(kol + 1):
		ds = divmod(kol - i, 2)
		if ds[0] > 0:
			if ds[1] == 0 and (kol - ds[0]) % ds[0] == 0:
				h += 1
	print(h)
a = int(input())
main(a)


n = int(input(''))
output = 0
for l in range(1, n):
	if (n - l) / l % 1 == 0:
		output = output + 1
	else:
		ouptut = output
print(output)


ans = 0
k = int(input())
for i in range(1, k):
	if k % i == 0:
		ans += 1
print(ans)


n = int(input())
ways = 0
for l in range(1, n):
	e = n - l
	if e % l == 0:
		ways += 1
print(ways)


def driver(f):
	counter = 0
	for i in range(1, f):
		if f % i == 0:
			counter += 1
	print(counter)

def main():
	for i in range(1):
		driver(int(input()))
main()


def fafa(n):
	ans = 0
	for i in range(1, n):
		if n - i >= i:
			if (n - i) % i == 0:
				ans += 1
	return ans
n = int(input())
print(fafa(n))


from math import ceil
n = int(input())
res = 1
sqr = ceil(n ** 0.5)
if (sqr - 1) ** 2 == n:
	sqr -= 1
for m in range(1, sqr):
	if n % m == 0:
		res += 2
if sqr ** 2 == n:
	res += 1
print(res - 2)


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


from sys import stdin
number = int(stdin.readline())
worked = 0
for i in range(1, number):
	next = number - i
	if next % i == 0:
		worked += 1
print(worked)


e = int(input())
cnt = 0
for i in range(1, e // 2 + 1):
	if (e - i) % i == 0:
		cnt += 1
print(cnt)


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


def fafa(num_employees):
	return sum((int((num_employees - num_leaders) % num_leaders == 0) for num_leaders in range(1, num_employees)))

def main():
	num_employees = int(input())
	num_ways = fafa(num_employees)
	print(num_ways)
main()


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


n = int(input())
c = 0
for i in range(1, n + 1):
	l = i
	x = n - i
	if x % l == 0 and x != 0:
		c = c + 1
print(c)


n = int(input())
cnt = 0
m = 0
while m < n // 2:
	m += 1
	if n % m == 0:
		cnt += 1
print(cnt)


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


import sys
n = int(input())
count = 0
for i in range(n // 2 + 1):
	if i != 0 and (n - i) % i == 0:
		count += 1
print(count)


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


x = int(input())
sum = 0
for i in range(1, x):
	if x % i == 0:
		sum = sum + 1
print(sum)


import math
n = int(input().strip())
factors = 1
c = 2
while c < n:
	if n % c == 0:
		factors += 1
	c += 1
print(factors if factors > 1 else 1)


c = 0
t = 1
n = int(input())
while t < n:
	m = n - t
	if m % t == 0:
		c += 1
	t += 1
print(c)


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


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


n = int(input())
count = 0
for i in range(1, n // 2 + 2):
	d = n - i
	if d % i == 0 and d > 0:
		count = count + 1
print(count)


num_employees = int(input())
total_ways = 1
for i in range(2, num_employees // 2 + 1):
	if num_employees % i == 0:
		total_ways += 1
print(total_ways)


member = int(input())
h_team = member / 2
(count, result) = (1, 0)
while count <= h_team:
	if (member - count) % count == 0:
		result += 1
		count += 1
	else:
		count += 1
print(result)


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

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

def li():
	return list(mi())
n = ii()
c = sum((n % i == 0 for i in range(1, n)))
print(c)


import pdb
c = 0
a = int(input())
for i in range(2, a + 1):
	if a % i == 0:
		c += 1
print(c)


t = int(input())
x = 2
b = 1
while x < t:
	temp = t - x
	if temp % x == 0:
		b = b + 1
	x = x + 1
print(b)


n = int(input())
print(len(list(filter(lambda i: n % i == 0, range(1, n // 2 + 1)))))


def main():
	from sys import stdout
	n = int(input())
	res = 0
	for i in range(1, n):
		if (n - i) / i % 1 == 0:
			res += 1
	stdout.write(str(res))
main()


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


x = eval(input())
i = 1
l = x
s = 0
while l > 0:
	l = x - i
	if l % i == 0 and l != 0:
		s += 1
	i += 1
print(s)


N = int(input())
ans = 0
for i in range(1, N):
	if (N - i) % i == 0:
		ans += 1
print(ans)


n = int(input())
counter = 0
for i in range(1, n):
	e = n - i
	team = int(e / i)
	if team * i + i == n:
		counter += 1
print(counter)


a = int(input().strip())
count = 0
for i in range(1, int(a / 2) + 1):
	if a % i == 0:
		count += 1
print(count)


b = int(input())
count = 0
a = 1
while a < b:
	c = b - a
	if c % a == 0:
		count += 1
	a += 1
print(count)


n = int(input())
kol = 0
for i in range(1, n):
	if n % i == 0:
		kol += 1
print(kol)


import sys
import bisect
import math
from itertools import permutations
m = 1000000007

def find_lt(a, x):
	i = bisect.bisect_left(a, x)
	if i:
		return a[i - 1]
	else:
		return -1
n = int(input())
ans = 0
for i in range(1, n):
	if (n - i) % i == 0:
		ans += 1
print(ans)


def canFormLeader(num, leads):
	return (num - leads) % leads == 0
emp = int(input())
print(len([i for i in range(1, emp // 2 + 1) if canFormLeader(emp, i)]))


n = int(input())
count = 0
a = 1
while a < n:
	if (n - a) % a == 0:
		count = count + 1
	a = a + 1
print(count)


import math
li = []
n = int(input())
m = math.sqrt(n)
m = int(m)
for i in range(1, m + 1):
	if n % i == 0:
		li.append(i)
		if n / i != i:
			li.append(int(n / i))
li.sort(reverse=True)
li.remove(li[0])
print(len(li))


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


n = int(input())
i = 1
count = 0
if n <= 3:
	print(1)
else:
	while i <= n - 1:
		r = n - i
		if r % i == 0:
			count += 1
		i += 1
	print(count)


import math
n = int(input(''))
i = 1
amount = 0
while i < math.sqrt(n):
	if n % i == 0:
		amount += 2
	i += 1
if math.sqrt(n) == int(math.sqrt(n)):
	amount += 1
print(amount - 1)


n = int(input())
summation = 0
i = 1
while i <= n // 2:
	if (n - i) % i == 0:
		summation += 1
	i += 1
print(summation)


import math
n = int(input())

def divisors(x):
	divs = []
	for i in range(1, round(math.sqrt(x) + 1)):
		if n % i == 0:
			if n / i == i:
				divs.append(i)
			else:
				divs.append(i)
				divs.append(int(n / i))
	return divs
divsOfN = divisors(n)
print(len(divsOfN) - 1)


n = int(input())
ways = 0
x = 1
while x < n:
	if n % (x + 1) == 0:
		ways += 1
	x += 1
print(ways)


from math import floor
from typing import Set

def factors_of(n: int) -> Set[int]:
	factors = set()
	for factor in range(1, floor(n ** 0.5) + 1):
		if n % factor == 0:
			factors.add(factor)
			factors.add(n // factor)
	return factors

def solve(n: int) -> int:
	return len(factors_of(n)) - 1

def parse_input() -> int:
	return int(input())
print(solve(parse_input()))


x = int(input())
count = 0
for y in range(1, x + 1):
	if x % y == 0:
		count = count + 1
print(count - 1)


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


employees = int(input())
ways = 0
for x in range(1, employees):
	if employees % x == 0:
		ways += 1
print(ways)


employees = int(input())
team_leader = 0
cnt = 0
while team_leader < employees:
	team_leader += 1
	remaining = employees - team_leader
	if remaining == 0:
		break
	if remaining % team_leader == 0:
		cnt += 1
print(cnt)


m = int(input())
print(sum((1 for x in range(1, m) if m % x is 0)))


n = int(input())
index = 1
count = 0
while index < n:
	if n % index == 0:
		count += 1
	index += 1
print(count)


n = int(input())
ct = 0
for i in range(1, n):
	if n % i == 0:
		ct += 1
print(ct)


n = int(input())
answer = 1
d = 2
while d != n:
	if n % d == 0:
		if (n - n // d) % (n // d) == 0:
			answer += 1
	d += 1
print(answer)


n = int(input())
way = 1
i = 2
while 1:
	if (n - i) // i <= 0:
		break
	if (n - i) % i == 0:
		way += 1
	i += 1
print(way)


a = int(input())
b = []
for i in range(1, a):
	if a % i == 0:
		b.append(i)
		continue
	else:
		continue
h = []
for j in range(0, len(b)):
	p = a - b[j]
	k = p / b[j]
	h.append(k)
print(len(h))


n = int(input())
a = int(n / 2)
count = 0
d = 0
for i in range(1, a + 1):
	w = n - i
	if w % i == 0:
		count += 1
print(count)


n = input()
ways = 0
for u in range(1, int(int(n) / 2) + 1):
	employees = int(n) - u
	check = employees / u
	if check % int(check) == 0:
		ways += 1
print(ways)


def main(n):
	if n == 2:
		return 1
	sum = int(n / 2) + 1
	count = 0
	for i in range(sum):
		if i == 0:
			continue
		elif (n - i) % i == 0:
			count += 1
	return count
try:
	while True:
		n = int(input())
		print(main(n))
except:
	pass


n = int(input())
r = 0
for i in range(1, n):
	if n % i == 0:
		r += 1
print(r)


a = input()
b = int(a)
count = 0
for l in range(1, b):
	if (b - l) % l == 0:
		count = count + 1
print(count)


def factors(x):
	c = 0
	for i in range(1, x):
		if x % i == 0:
			c += 1
	return c
print(factors(int(input())))


x = eval(input())
c = 0
i = 1
r = 0
while i < x:
	r = x - i
	if r % i == 0:
		c += 1
	i += 1
print(c)


n = int(input())
h = 0
for i in range(1, n):
	if n % i == 0:
		h += 1
print(h)


x = int(input())
n = 1
for i in range(x // 2 + 1)[2:]:
	if not (x - i) % i:
		n += 1
print(n)


num = int(input(''))
factors = []
for i in range(1, num):
	if num % i == 0:
		factors.append(i)
print(factors.__len__())


n = int(input())
i = 2
nr = 1
while i <= n:
	p = 0
	while n % i == 0:
		n //= i
		p += 1
	nr = nr * (p + 1)
	i += 1
print(nr - 1)


from sys import stdin
n = int(stdin.readline())
total = 0
for loop in range(1, n // 2 + 1):
	b = n - loop
	if b % loop == 0:
		total += 1
print(total)


import math

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


def solve():
	n = int(input())
	prime = [True] * (n + 1)
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	total = 1
	for i in range(2, n + 1):
		if prime[i] == True:
			count = 0
			if n % i == 0:
				while n % i == 0:
					n = n // i
					count += 1
				total *= count + 1
	print(total - 1)
solve()


a = int(input())
b = int(1)
for x in range(2, int(a / 2) + 1):
	if (a - x) % x == 0:
		b = b + 1
print(b)


n = int(input())
i = 1
employees = 0
types = 0
while i <= n // 2:
	employees = n - i
	if employees % i == 0:
		types += 1
	i += 1
print(types)


import sys, math
f = sys.stdin
N = int(f.readline())
ans = 0
for i in range(1, N):
	if N % i == 0:
		ans += 1
print(ans)


n = int(input())
i = 1
coun = 0
while i < n:
	n_ost = n - i
	if n_ost % i == 0:
		coun += 1
	i += 1
print(coun)


import math
from collections import *
import sys
from functools import reduce

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

def get_list():
	return list(get_ints())

def get_string():
	return list(input().strip().split())

def printxsp(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')
UGLYMOD = int(1000000000.0) + 7
SEXYMOD = 998244353
MAXN = int(100000.0)
n = int(input())
ans = 0
for i in range(1, n // 2 + 1):
	if (n - i) % i == 0:
		ans += 1
print(ans)


import sys
import math
import bisect

def main():
	n = int(input())
	ans = 0
	for i in range(1, n):
		if (n - i) % i == 0:
			ans += 1
	print(ans)
main()


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


n = int(input())
solution = []
for i in range(1, n):
	if n % i == 0 and n != i:
		solution.append(i)
print(len(solution))


number = int(input())
total = 0
for i in range(1, number // 2 + 1 - 1 + 1):
	if number % i == 0:
		total = total + 1
print(total)


n = int(input())

def factorize(n):
	res = []
	if n % 2 == 0:
		power = 0
		while n % 2 == 0:
			power += 1
			n //= 2
		res.append((2, power))
	i = 3
	while i * i <= n:
		if n % i == 0:
			power = 0
			while n % i == 0:
				power += 1
				n //= i
			res.append((i, power))
		i += 2
	if n > 1:
		res.append((n, 1))
	return res
res = 1
for (p, power) in factorize(n):
	res *= power + 1
print(res - 1)


n = int(input())
cnt = 0
for i in range(1, n + 1):
	ruk = i
	ost = n - i
	if ost % ruk == 0:
		cnt += 1
print(cnt - 1)


n = int(input())
dec = 1
cnt = 0
while dec < n:
	cnt += 0 if (n - dec) % dec else 1
	dec += 1
print(cnt)


def factorize(n):
	L = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			L.append(i)
			if i * i != n:
				L.append(n // i)
	return L
n = int(input())
print(len(factorize(n)) - 1)


a = int(input())
z = []
for i in range(1, a):
	if a % i == 0:
		z.append(i)
print(len(z))


people = int(input())
count = 0
for i in range(people):
	l = i + 1
	e = people - l
	if e % l == 0 and e != 0:
		count += 1
print(count)


n = int(input())
k = 0
c = int(n / 2 + 1)
for i in range(1, c):
	if (n - i) % i == 0 and n > i:
		k = k + 1
print(k)


n = int(input())
suma = 0
for i in range(1, n):
	if n % i == 0:
		suma += 1
print(suma)


def program(n):
	ways = 0
	for i in range(1, n):
		if n % i == 0:
			ways += 1
	return ways
n = int(input())
print(program(n))


from itertools import takewhile
n = int(input())
count = 0
count = sum([1 for i in takewhile(lambda i: n // i > 1, range(1, n)) if n % i == 0])
print(count)


n = int(input())
l = []
for i in range(1, n):
	if n % i == 0:
		l.append(i)
	else:
		continue
print(len(l))


n = int(input())
count_of_dividers = 0
for i in range(n, 1, -1):
	if n % i == 0:
		count_of_dividers += 1
print(count_of_dividers)


num = int(input())
cnt = 0
for i in range(1, num):
	if (num - i) % i == 0:
		cnt += 1
print(cnt)


employees = int(input())
ways = 0
for leaders in range(1, employees):
	if (employees - leaders) % leaders == 0:
		ways += 1
print(ways)


n = int(input())
c = 0
for l in range(1, n):
	if (n - l) % l == 0:
		c += 1
print(c)


n = int(input())
if n <= 3:
	print(1)
elif n > 3:
	count = 0
	for i in range(2, n + 1):
		if n % i == 0:
			count += 1
	print(count)


n = int(input())
answer = 0
for i in range(1, int(n / 2) + 1):
	holder = n - i
	if holder % i == 0:
		answer += 1
print(answer)


e = int(input())
counter = 0
n = e
while n > 1:
	n = n - 1
	l = e - n
	if n % l == 0:
		counter = counter + 1
print(counter)


n = int(input())
leaders = 1
res = 0
while leaders < n:
	if (n - leaders) % leaders == 0:
		res += 1
	leaders += 1
print(res)


n = int(input())
l = 1
f = 0
while l < n:
	if (n - l) % l == 0:
		f = f + 1
	l = l + 1
print(f)


n = input()
n = int(n)
aux = 1
for i in range(2, n):
	if n % i == 0:
		aux = aux + 1
	else:
		continue
print(aux)


n = int(input())
k = 1
s = 2
while s != n:
	if n % s == 0:
		k += 1
		s += 1
	else:
		s += 1
print(k)


n = int(input())
i = 1
jlh = 0
while i < n:
	if n % i == 0:
		i += 1
		jlh += 1
	else:
		i += 1
print(jlh)


x = int(input())
kolvo = 0
for y in range(int(x / 2)):
	if x % (y + 1) == 0:
		kolvo += 1
print(kolvo)


a = int(input())
c = 2
d = 1
while c < a:
	if not a % c:
		d += 1
	c += 1
print(d)


from sys import stdin, stdout
from math import sqrt
n = int(stdin.readline())
c = 0
for i in range(1, n):
	if n % i == 0:
		c += 1
print(c)


x = int(input())
y = 1
count = 0
while y <= x // 2:
	d = x - y
	if d % y == 0:
		count += 1
	y += 1
print(count)


n = int(input())
sum = 0
for l in range(1, n):
	if (n - l) % l == 0:
		sum += 1
print(sum)


import sys
empl_count = int(input())
index = empl_count // 2
ans = 0
while index >= 1:
	if empl_count % index == 0:
		ans += 1
	index -= 1
print(ans)
sys.exit()


R = lambda : [*map(int, input().split())]
n = R()
ans = 0
for i in range(n[0] // 2 + 1):
	if i > 0:
		if (n[0] - i) % i == 0:
			ans += 1
print(ans)


from sys import exit as sys_return
(amount, i, max) = (1, 2, int(input()))
while i <= max // 2:
	if (max - i) % i == 0:
		amount += 1
	i += 1
print(amount)


n = int(input())
if n >= 2 and n <= 10 ** 6:
	count = 1
	for i in range(2, n // 2 + 1):
		t = n - i
		if t % i == 0:
			count += 1
print(count)


def isDivisible(n, i):
	return 1 if n % i == 0 else 0

def multipleAnswers(n):
	res = [isDivisible(n, i) for i in range(1, n)]
	return sum(res)
n = int(input())
print(multipleAnswers(n))


def main():
	n = int(input())
	res = 0
	for i in range(1, int(n / 2 + 1)):
		if (n - i) % i == 0:
			res += 1
	return res
print(main())


n = int(input())
ans = 0
i = 1
while n > i:
	if (n - i) % i == 0:
		ans += 1
	i += 1
print(ans)


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


n = int(input())
t = 0
x = []
y = 0
for i in range(1, n):
	x.append(i)
for i in range(0, len(x)):
	y = n - x[i]
	if y % x[i] == 0:
		t += 1
print(t)


n = int(input())
res = 1
for l in range(2, n + 1):
	x = n - l
	if x > 0 and x % l == 0:
		res += 1
print(res)


import itertools
import math
import sys
import heapq
from collections import Counter
from collections import deque
from fractions import gcd
from functools import reduce
sys.setrecursionlimit(4100000)
INF = 1 << 60
MOD = 10 ** 9 + 7
n = int(input())
ans = 1
cnt = 2
while cnt < n:
	if (n - cnt) % cnt == 0:
		ans += 1
	cnt += 1
print(ans)


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


num_of_employees = int(input())
num_of_ways = 0
for i in range(1, num_of_employees):
	if num_of_employees % i == 0:
		num_of_ways += 1
print(num_of_ways)


n = int(input())
k = n // 2
count = 0
for j in range(1, k + 1):
	if (n - j) % j == 0:
		count = count + 1
	else:
		count = count + 0
print(count)


n = int(input())
res = 0
for l in range(1, n):
	if (n - l) % l == 0:
		res += 1
print(res)


x = int(input())
a = []
for i in range(x):
	if x % (i + 2) == 0:
		a.append(i + 2)
print(len(a))


n = int(input())
sp = 0
for i in range(1, n):
	if (n - i) % i == 0:
		sp += 1
print(sp)


n = int(input())
a = 0
for e in range(1, n):
	if (n - e) % e == 0:
		a += 1
print(a)


import math
e = int(input())
ways = 0
for i in range(e):
	l = i + 1
	ee = e - l
	if ee % l == 0:
		ways += 1
print(ways - 1)


from typing import List

def solve(n: int) -> str:
	ret = 0
	for i in range(1, n):
		if n % i == 0:
			ret = ret + 1
	return ret

def compare(user_answer: int, jury_answer: int) -> bool:
	return user_answer == jury_answer
print(solve(*map(int, input().split())))


num_employees = int(input())
possible_ways = 0
for num_leaders in range(1, num_employees // 2 + 1):
	if num_employees % num_leaders == 0:
		possible_ways += 1
print(possible_ways)


a = int(input())
b = 0
for r in range(1, a):
	c = a - r
	if c % r == 0:
		b = b + 1
print(b)


import math as mt
n = int(input())
ans = 0
for i in range(1, n):
	if n % i == 0:
		ans += 1
print(int(ans))


n = int(input())
i = 0
c = 0
while i < n:
	if i != 0 and n % i == 0:
		c = c + 1
	i = i + 1
print(c)


employees = int(input())
executives = 2
ways = 1
while executives < employees:
	if employees % executives == 0:
		ways += 1
	executives += 1
print(ways)


n = int(input())
(c, x) = (0, 1)
while 1:
	if x > n - x:
		break
	m = n - x
	if m % x == 0:
		c += 1
	x += 1
print(c)


from math import sqrt
num = int(input())
n_divisors = 0
for x in range(1, int(sqrt(num)) + 1):
	(div, mod) = divmod(num, x)
	if mod == 0:
		if div != x:
			n_divisors += 2
		else:
			n_divisors += 1
print(n_divisors - 1)


n = int(input())
ans = 0
for k in range(1, n):
	if (n - k) % k == 0:
		ans += 1
print(ans)


n = int(input())
div = 2
counter = 1
while div < n:
	if n % div == 0:
		counter += 1
	div += 1
print(counter)


n = int(input())
l = 1
if n >= 4:
	for k in range(2, n // 2 + 1):
		if (n - k) % k == 0:
			l += 1
print(l)


x = int(input())
num = 1
res = 0
while num <= x:
	if x % num == 0:
		res += 1
	num = num + 1
print(res - 1)


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


num = int(input())
total = 0
for x in range(1, num):
	if num % x == 0:
		total += 1
print(total)


NumeroDeEmpleados = int(input())
Posibilidades = 0
for Contador in range(1, NumeroDeEmpleados):
	if NumeroDeEmpleados % Contador == 0:
		Posibilidades += 1
print(Posibilidades)


def prime(x):
	if x < 2:
		return False
	for i in range(2, x):
		if not x % i:
			return False
	return True

def hi(y):
	sum = 0
	i = 1
	while i * i <= y:
		if y % i == 0:
			if i * i == y:
				sum += 1
			else:
				sum += 2
		i += 1
	return sum
n = int(input())
if prime(n):
	print(1)
else:
	b = hi(n)
	print(b - 1)


n = int(input())
s = 0
for j in range(n // 2):
	if (n - j - 1) % (j + 1) == 0:
		s += 1
print(s)


import sys
import math
counter = -1
count = 0
for lin in sys.stdin:
	line = lin.rstrip()
	counter += 1
	if counter == 0:
		n = int(line)
		break
for i in range(n):
	if i == 0:
		continue
	elif n % i == 0:
		count += 1
print(count)


n = int(input())
k = 0
for i in range(1, n):
	if not i <= n // 2:
		break
	if (n - i) % i == 0:
		k += 1
print(k)


n = int(input())
c = 0
start = int(n / 2)
for k in range(start, 0, -1):
	if n % k == 0:
		c = c + 1
print(c)


from math import ceil
from math import floor
n = int(input())
aa = 0
for i in range(1, n):
	if ceil((n - i) / i) == floor((n - i) / i):
		aa += 1
print(aa)


import sys
n = int(sys.stdin.readline())
l = 0
for i in range(1, int(n / 2 + 1)):
	if n % i == 0:
		l += 1
print(l)


N = int(input())
s = 0
for i in range(N - 1):
	if N % (N - i) == 0:
		s += 1
print(s)


n = int(input())
y = 0
for x in range(1, n):
	if n % x == 0:
		y += 1
print(y)


from math import sqrt, floor
emp = int(input())
div = floor(sqrt(emp)) + 1
n = 0
for i in range(1, div):
	if emp != i and (emp - i) % i == 0:
		n += 1
		if emp % i == 0:
			s = emp // i
			if i != s and emp != s and ((emp - s) % s == 0):
				n += 1
print(n)


no_of_employees = int(input(''))
ways = 0
for no_of_leaders in range(1, no_of_employees):
	if (no_of_employees - no_of_leaders) % no_of_leaders == 0:
		ways += 1
print(ways)


from math import *
from copy import *
from string import *
from random import *
from sys import stdin
from sys import maxsize
from operator import *
from itertools import *
from collections import Counter
import math

def bin(l, r, ll, val):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		if ll[mid] == val:
			return mid
		elif ll[mid] > val:
			return bin(l, mid - 1, ll, val)
		else:
			return bin(mid + 1, r, ll, val)

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
n = int(input())
c = 1
for i in range(2, int(sqrt(n)) + 1):
	if n % i == 0:
		if n // i == i:
			c = c + 1
		else:
			c = c + 2
print(c)


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


a = int(input())
r = 2
c = 0
while r <= a:
	if a % r == 0:
		c = c + 1
	r = r + 1
print(int(c))


n = int(input())
x = n
total = 0
for i in range(1, n // 2 + 1):
	if i == 1:
		total += 1
	elif (x - i) % i == 0:
		total += 1
print(total)


import math

def count_factors(n):
	if 1 == n:
		return 1
	sqrtn = math.floor(math.sqrt(n))
	n_factors = 2
	for x in range(2, sqrtn + 1):
		if n % x == 0:
			if x * x == n:
				n_factors += 1
			else:
				n_factors += 2
	return n_factors
employees = int(input())
print(count_factors(employees) - 1)


import sys
if sys.version_info < (3, 0):
	lrange = range
	input = raw_input
	range = xrange
n = int(input())
from math import sqrt, ceil
from collections import defaultdict

def sieve(N):
	b = [True] * (N + 1)
	b[0] = False
	b[1] = False
	lim = ceil(sqrt(N))
	i = 2
	while i <= lim:
		if b[i]:
			for n in range(i ** 2, N + 1, i):
				b[n] = False
		i += 1
	return {i for (i, b) in enumerate(b) if b}
P = sieve(10 ** 4 + 10)

def divisors(n):
	F = factor(n, P)
	D = {1}
	for f in F:
		D |= {f * d for d in D}
	return D

def factor(n, P):
	if n in P:
		return [n]
	f = []
	for p in P:
		while n % p == 0:
			n //= p
			f.append(p)
		if n in P:
			f.append(n)
			return f
	if n != 1:
		f.append(n)
	return f
print(len(divisors(n)) - 1)


n = int(input())
count = 0
i = 1
while i <= int(n // 2):
	l = i
	r = n - l
	if r % l == 0:
		count = count + 1
	i = i + 1
print(count)


a = 0
x = int(input())
for k in range(1, x):
	if (x - k) % k == 0:
		a = a + 1
	else:
		continue
print(a)


n = int(input())
c = []
for i in range(1, n):
	x = (n - i) % i
	if x == 0:
		c.append(x)
print(len(c))


mem = int(input())
count = 0
for i in range(1, mem):
	if (mem - i) % i == 0:
		count += 1
print(count)


q = int(input())
ans = 0
for i in range(1, q):
	if (q - i) % i == 0:
		ans = ans + 1
print(ans)


e = int(input())
w = 0
for _ in range(1, e):
	if _ > e // 2:
		break
	elif (e - _) % _ == 0:
		w += 1
print(w)


people = int(input())
count = 0
for i in range(1, people):
	if (people - i) % i == 0:
		count += 1
print(count)


import sys
from math import sqrt, ceil

def solution(n):
	res = 0
	for i in range(1, int(ceil(n / 2)) + 1):
		if (n - i) % i == 0:
			res += 1
	return res
n = int(sys.stdin.readline().strip())
print(solution(n))


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


import math

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


N = int(input())
count = 0
for i in range(1, N):
	if (N - i) % i == 0:
		count += 1
print(count)


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


n = int(input())
cnt = 0
for i in range(1, n):
	a = n - i
	if a % i == 0:
		cnt += 1
		continue
print(cnt)


import math
m = int(input())
k = 0
l = math.floor(m / 2)
for i in range(1, l + 1, 1):
	if (m - i) % i == 0:
		k = k + 1
print(k)


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

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

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

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

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

def S():
	return input()

def main():
	n = I()
	c = 0
	for i in range(1, n + 1):
		if n - i > 0 and (n - i) % i == 0:
			c += 1
	return c
print(main())


n = int(input())
ans = 0
for l in range(1, n):
	if (n - l) % l == 0:
		ans += 1
print(ans)


t = int(input())
l = [i for i in range(1, t + 1)]
count = 0
for i in l:
	if (t - i) % i == 0 and i != t:
		count += 1
print(count)


import math
n = int(input())
ans = 0
for i in range(1, n):
	if not (n - i) % i:
		ans += 1
print(ans)


amount = int(input())
counter = 0
for i in range(1, amount):
	if (amount - i) % i == 0:
		counter += 1
print(counter)


total = 0
N = int(input())
for i in range(1, N // 2 + 1):
	a = N
	a -= i
	if a == N - 1:
		total += 1
		continue
	if a % i == 0 or a == N // 2:
		total += 1
print(total)


n = int(input())
ans = 0
for i in range(n):
	if i is 0:
		continue
	if (n - i) % i == 0:
		ans += 1
print(ans)


n = int(input())
sum = 0
i = 1
while i <= n // 2:
	if (n - i) % i == 0:
		sum += 1
	i += 1
print(sum)


emp = int(input(''))
sol = 0
ra = int(emp / 2)
for i in range(1, ra + 1):
	if (emp - i) % i == 0:
		sol += 1
print(sol)


from fractions import gcd
from heapq import *
import math
from collections import defaultdict, Counter, deque
from bisect import *
import itertools
import fractions
import sys
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7

def main():
	n = int(input())
	ans = 0
	for i in range(1, n + 1):
		if n % i == 0:
			ans += 1
	print(ans - 1)
main()


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


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


N = int(input())
C = 0
for index in range(1, N):
	e = N - index
	if e % index == 0:
		C += 1
print(C)


n = int(input())
za_list = [i for i in range(1, n // 2 + 1)]
count = 0
for i in range(len(za_list)):
	if (n - za_list[i]) % za_list[i] == 0:
		count += 1
print(count)


n = int(input())
tot = 0
for i in range(1, n):
	if n % i == 0 and n // i > 1:
		tot = tot + 1
		i = i + 1
	else:
		i = i + 1
print(tot)


def fafaAndCompany(n):
	l = 1
	ways = 0
	for _ in range(n):
		if n - l != 0 and (n - l) % l == 0:
			ways += 1
		l += 1
	return ways
n = int(input())
result = fafaAndCompany(n)
print(result)


def number_of_ways(number):
	max_leaders = number // 2
	ways = 0
	for i in range(1, max_leaders + 1):
		if i == 1 or (number - i) % i == 0:
			ways += 1
	return ways
number_employees = int(input())
print(number_of_ways(number_employees))


employees = int(input())
ways = 0
for i in range(1, employees):
	l = i
	members = employees - l
	if members % l == 0:
		ways = ways + 1
print(ways)


n = int(input())
i = 0
l = 0
while i < n - 1:
	i += 1
	if (n - i) % i == 0:
		l += 1
print(l)


x = 0
x = input()
x = int(x)
count = 0
for i in range(x):
	if x % (x - i) == 0:
		count = count + 1
print(count - 1)


import math

def find_factors(n):
	limit = int(math.sqrt(n) + 1)
	count = 0
	list1 = []
	for i in range(1, limit):
		if n % i == 0:
			list1.append(i)
			list1.append(int(n / i))
	count = len(set(list1))
	return (count, list1)
n = int(input())
print(find_factors(n)[0] - 1)


n = int(input())
s = 1
p = (n + 3) // 2
for i in range(2, p):
	if n % i == 0:
		s += 1
print(s)


employees = int(input())
valid_ways = []
for l in range(1, employees):
	ways = (employees - l) / l
	if str(ways).endswith('.0'):
		valid_ways.append(ways)
print(len(valid_ways))


i = int(input())
c = sum([i % x == 0 for x in range(1, i)])
print(c)


y = int(input())
sum = 0
for l in range(1, y):
	x = (y - l) % l
	if x == 0:
		sum = sum + 1
print(sum)


k = int(input())
K = 0
for i in range(1, k):
	if (k - i) % i == 0:
		K += 1
print(K)


n = int(input())
way = 0
for i in range(1, int(n / 2 + 1)):
	members = n - i
	if members % i == 0:
		way += 1
print(way)


n = int(input())
di = 0
for i in range(1, n):
	if n % i == 0:
		di += 1
print(di)


import sys
import os

def changeStdioToFile():
	path = os.path.dirname(os.path.abspath(__file__))
	sys.stdin = open(f'{path}/input.txt', 'r')
	sys.stdout = open(f'{path}/output.txt', 'w')
t = 1
for _ in range(t):
	n = int(input())
	res = 0
	for i in range(1, n):
		if n % i == 0:
			res += 1
	print(res)


n = int(input())
a = 0
sum = 0
while n > 1:
	a += 1
	n -= 1
	if n % a == 0:
		sum += 1
print(sum)


n = int(input())
ans = 0
m = 0
k = 1
for i in range(100000):
	if (n - k) % k == 0:
		m = n - k
		if m % k == 0:
			ans += 1
			k += 1
	else:
		k += 1
print(ans - 1)


workersCount = int(input())
directorsCount = 0
for i in range(workersCount):
	if i != 0 and workersCount % i == 0:
		directorsCount = directorsCount + 1
print(directorsCount)


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


import math
a = int(input())
r = 0
for i in range(math.floor(a / 2)):
	if a % (i + 1) == 0:
		r += 1
print(r)


from sys import stdin
inp = stdin.readline
n = int(inp().strip())
ans = 1
for i in range(2, n // 2 + 1):
	if (n - i) % i == 0:
		ans += 1
print(ans)


n = int(input())
x = 1
y = n - 1
c = 0
while x <= y:
	if y % x == 0:
		c += 1
	x += 1
	y -= 1
print(c)


n = eval(input())
count = 0
for i in range(1, n // 2 + 1):
	if (n - i) / i == (n - i) // i:
		count += 1
print(count)


a = int(input())
ans = 0
for i in range(1, int(a / 2) + 1):
	s = str((a - i) / i)
	if s[-1] == '0' and s[-2] == '.':
		ans += 1
print(ans)


x = int(input())
re = 0
for i in range(1, x):
	if x % i == 0:
		re += 1
print(re)


import sys
import os
import math
import re
n = int(input())
l = n // 2
count = 0
while l > 0:
	if (n - l) % l == 0:
		count += 1
	l -= 1
print(count)


n = int(input(''))
a = 0
for i in range(1, n + 1):
	if (n - i) % i == 0:
		a += 1
	else:
		pass
print(a - 1)


n = int(input())
ret = 0
for i in range(1, n):
	if i + i * int((n - i) / i) == n:
		ret += 1
print(ret)


import sys
n = int(sys.stdin.readline().strip())
ways = 0
for i in range(1, n // 2 + 1):
	if n % i == 0:
		ways += 1
print(ways)


def func(x):
	count = 0
	for i in range(1, x):
		if (x - i) % i is 0:
			count += 1
	return count
x = int(input())
print(func(x))


import sys
import math
input = sys.stdin.readline
n = int(input())
ans = 0
for i in range(2, n + 1):
	if not n % i:
		ans += 1
print(ans)


x = int(input())
hasil = 0
for i in range(1, x + 1):
	if x % i == 0:
		hasil += 1
print(hasil - 1)


n = int(input())
possibilities = 0
for l in range(1, n):
	if n % l == 0:
		possibilities += 1
print(possibilities)


a = int(input())
b = int(a / 2)
i = 2
j = 1
while i <= b:
	if (a - i) % i == 0:
		j += 1
	i += 1
print(j)


a = input() + ' '
b = ''
A = []
for j in range(len(a)):
	if a[j] == ' ':
		A.append(int(b))
		b = ''
	else:
		b += a[j]
g = 0
for i in range(1, A[0] // 2 + 1):
	if (A[0] - i) % i == 0:
		g += 1
print(g)


n = int(input())
num = 0
for x in range(1, 110000):
	if n % x == 0:
		num = num + 1
print(num - 1)


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


import math
N = int(input())
res = 0
for i in range(1, N // 2 + 1):
	if N % i == 0:
		res += 1
print(res)


from collections import defaultdict
from functools import reduce
d = defaultdict(int)
n = int(input())
j = 2
while n > 1:
	if not n % j:
		n //= j
		d[j] += 1
	else:
		j += 1
print(reduce(lambda a, b: a * (b + 1), d.values(), 1) - 1)


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


n = int(input())
total = 0
for a in range(1, n):
	if n % a == 0:
		total += 1
print(total)


(a, c) = (int(input()), 1)
for i in range(2, int(a / 2) + 1):
	if not a % i:
		c += 1
print(c)


def la(n):
	for x in range(1, n // 2 + 1):
		if not (n - x) % x:
			yield x
print(len(list(la(int(input())))))


def is_int(n):
	return int(n) == n
n = int(input())
print(sum([is_int((n - i) / i) for i in range(1, int(n / 2) + 1)]))


from math import sqrt
n = int(input())
m = int(sqrt(n))
ans = len(list(filter(lambda x: n % x == 0, range(2, m + 1)))) * 2 + 1 - (1 if m * m == n else 0)
print(ans)


k = int(input())
add = 0
for n in range(1, k):
	x = (k - n) / n
	if int(x) * n + n == k:
		add += 1
print(add)


a = int(input())
j = 0
for i in range(1, a):
	if a % i == 0:
		j += 1
print(j)


a = int(input())
su = 0
for i in range(1, a):
	if a % i == 0:
		su += 1
print(su)


nums = int(input())
ans = 0
i = 1
while i <= nums - i:
	if (nums - i) % i == 0:
		ans += 1
	i += 1
print(ans)


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


import math

def findFactors(x):
	i = 1
	count = 0
	while i < math.sqrt(x):
		if x / i == x // i:
			count += 1
		i += 1
	if math.sqrt(x) == int(math.sqrt(x)):
		return 2 * count + 1
	else:
		return 2 * count
n = int(input())
n_factor = findFactors(n)
print(n_factor - 1)


import sys
n = int(input())
if n == 2:
	print(1)
	sys.exit()
ans = 0
for c in range(1, n):
	new = n - c
	if new % c == 0:
		ans += 1
print(ans)


n = int(input())
out = 0
for x in range(n - 1, 0, -1):
	if n % x == 0:
		out += 1
print(out)


n = int(input())
c = 0
for i in range(1, n):
	l = i
	e = n - i
	flag = e % l
	if flag == 0:
		c += 1
print(c)


n = int(input())
if n == 2:
	print('1')
else:
	a = n // 2
	c = 1
	for i in range(2, a + 1):
		d = n - i
		if d % i == 0:
			c += 1
	print(c)


def div(n):
	arr = set()
	for x in range(1, int(n ** 0.5) + 1):
		if n % x == 0:
			arr.add(x)
			arr.add(n // x)
	return len(arr)
n = int(input())
num = div(n) - 1
print(num)


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


n_employees = int(input())
(leaders, subordinates) = (n_employees - 1, 1)
answer = 1
if n_employees > 2:
	for i in range(n_employees // 2):
		leaders -= 1
		subordinates += 1
		if leaders % subordinates == 0:
			answer += 1
print(answer)


import math
n = int(input())
if n == 2:
	print(1)
else:
	d = 1
	e = 0
	while n % 2 == 0:
		n /= 2
		e += 1
	d *= e + 1
	e = 0
	for x in range(3, int(n) + 1, 2):
		if n == 1:
			break
		while n % x == 0:
			n /= x
			e += 1
		d *= e + 1
		e = 0
	if n == 1:
		print(d - 1)
	else:
		print(1)


q = int(input())
count = 0
for i in range(1, q):
	if q % i == 0:
		count += 1
print(count)


p = int(input())
q = p // 2
s = 0
i = 1
while i != q + 1:
	r = (p - i) // i
	if r * i + i == p:
		s = s + 1
	i = i + 1
print(s)


A = int(input())
C = 1
Counter = 0
while A > C:
	if A % C == 0:
		Counter += 1
	C += 1
print(Counter)


workers = int(input())
res = 0
for i in range(1, int((workers - workers % 2) / 2) + 1):
	if (workers - i) % i == 0:
		res = res + 1
print(res)


n = int(input())
result = 0
for leader in range(1, n):
	employees = n - leader
	if employees % leader == 0:
		result += 1
print(result)


a = int(input())
l = 0
for i in range(1, a):
	if (a - i) % i == 0:
		l = l + 1
print(l)


from sys import stdin, stdout
n = int(input())
answer = 1
for i in range(2, n):
	if (n - i) % i == 0:
		answer += 1
print(answer)


a = int(input())
b = 0
for k in range(1, a):
	if a % k == 0:
		b += 1
print(b)


employees = int(input())
possibleAnswers = 0
i = 1
while i <= employees // 2:
	if (employees - i) % i == 0:
		possibleAnswers = possibleAnswers + 1
	i = i + 1
print(possibleAnswers)


def main():
	n = int(input())
	l = 1
	ans = 0
	while l < n:
		if (n - l) % l == 0:
			ans += 1
		l += 1
	print(ans)
main()


x = int(input())
w = 0
for i in range(1, x):
	if x % i == 0:
		w += 1
print(w)


def dividers(number: int) -> int:
	dividers_count = 1
	for i in range(2, number // 2 + 1):
		if number % i == 0:
			dividers_count += 1
	return dividers_count
n = int(input())
print(dividers(n))


emp = int(input())
n_ways = 0
for i in range(1, emp // 2 + 1):
	if (emp - i) % i == 0:
		n_ways += 1
print(n_ways)


num = int(input())
count = 0
for n in range(1, num):
	if num % n == 0:
		count = count + 1
print(count)


n = int(input())
worst_case = 0
way = 1
maxTeam = int(n / 2) + 1
for i in range(2, maxTeam):
	if n % i == 0:
		way += 1
print(way)


employ = int(input())
hasil = 0
for i in range(1, employ):
	employ -= 1
	if employ % i == 0:
		hasil += 1
print(hasil)


n = int(input())
ways = 0
for x in range(1, n):
	if (n - x) % x == 0:
		ways += 1
print(ways)


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nlargest, nsmallest, _heapify_max, _heapreplace_max
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as c
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from fractions import Fraction
mod = pow(10, 9) + 7
mod2 = 998244353

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

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

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

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

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
n = int(data())
(i, s) = (1, set())
while i * i <= n:
	if n % i == 0:
		s.add(i)
		s.add(n // i)
	i += 1
out(len(s) - 1)


a = int(input())
global c
c = 0
for i in range(1, 100000):
	if a % i == 0 and a // i > 1:
		c += 1
print(c)


def main():
	nb = int(input())
	inc = 0
	for x in range(1, nb):
		if nb % x == 0:
			inc += 1
	print(inc)
main()


def solve(n):
	i = 1
	j = n
	count = 0
	while i < j:
		if (j - 1) % i == 0:
			count += 1
		i += 1
		j -= 1
	print(count)

def input_num():
	return int(input())
n = input_num()
solve(n)


import math
from functools import reduce

def get_factors_count(nb: int) -> int:
	counts = {2: 0}
	while nb % 2 == 0:
		counts[2] += 1
		nb //= 2
	iter_range = range(3, int(math.sqrt(nb)) + 1, 2)
	counts = {**counts, **dict.fromkeys(iter_range, 0)}
	for i in iter_range:
		while nb % i == 0:
			counts[i] += 1
			nb //= i
	if nb > 2:
		counts[nb] = 1
	return reduce(lambda a, b: a * (b + 1), counts.values(), 1)
print(get_factors_count(int(input())) - 1)


emp = int(input())
tl = 1
temp = emp
div = 2
while div <= temp / 2:
	emp = temp - div
	if emp % div == 0:
		tl += 1
	div += 1
print(tl)


def num_ways(n):
	count = 0
	for team_lead in range(1, n):
		member = n - team_lead
		if team_lead == 1 or member % team_lead == 0:
			count = count + 1
	return count
n = int(input())
print(num_ways(n))


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


is_debug = False
n = int(input())
c = 0
for i in range(1, n):
	l = n - i
	t = n - l
	if l % t == 0:
		c = c + 1
print(c)


n = int(input())
s = int(n ** 0.5)
ans = 0
for i in range(1, s + 1):
	if n % i == 0:
		if i == 1 or (i == s and n == s * s):
			ans += 1
		else:
			ans += 2
print(ans)


n = int(input())
ways = []
l = 1
count = 0
while l < n:
	emp = n - l
	if emp % l == 0:
		count += 1
	l = l + 1
print(count)


n = int(input())
count = 0
i = 1
while i < n:
	divided = i / (n - i)
	condition = i % (n - i)
	if condition == 0:
		count = count + 1
	i = i + 1
print(count)


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


def factor(x):
	ans = 1
	if x % 2 == 0:
		for i in range(2, x // 2 + 1):
			if x % i == 0:
				ans += 1
	else:
		for i in range(2, x // 3 + 1):
			if x % i == 0:
				ans += 1
	return ans
x = int(input())
print(factor(x))


user_input = int(input())
count = 0
for i in range(user_input):
	if i != 0:
		if (user_input - i) % i == 0:
			count += 1
print(count)


N = int(input())
count = 1
while N // 2 > 1:
	for _ in range(2, N // 2 + 1, 1):
		if (N - _) % _ == 0:
			count += 1
		else:
			continue
	break
print(count)


emp = int(input())
count = 0
for i in range(1, emp // 2 + 1):
	if i == 1:
		count += 1
	elif count == emp // 2 + 1:
		count += 1
	else:
		leaderSelected = emp - i
		if leaderSelected % i == 0:
			count += 1
print(count)


def factors(n):
	results = set()
	count = 1
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			j = n // i
			if i == j:
				count += 1
			else:
				count += 2
	return count
n = int(input())
v = factors(n)
print(v)


import math
a = int(input())
possibilities = 0
for i in range(1, a + 1):
	if a % i == 0 and i != a:
		possibilities += 1
print(possibilities)


a = int(input())
if a % 2 == 0:
	j = a // 2 + 1
else:
	j = (a + 1) // 2 + 1
s = 0
for i in range(1, j):
	if (a - i) % i == 0:
		s += 1
print(s)


e = int(input())
w = 0
i = 1
while i <= e // 2:
	if (e - i) % i == 0:
		w += 1
	i += 1
print(w)


n = int(input())
ways = 0
for i in range(1, n):
	temp = n - i
	if temp < i:
		break
	if temp % i == 0:
		ways += 1
print(ways)


n = int(input())
sum = 0
for i in range(1, n):
	m = n - i
	if m % i == 0:
		sum += 1
	else:
		sum = sum
print(sum)


def card_game():
	table = list(input())
	hand = input()
	hand = hand.split()
	x = 0
	kokotina = []
	for items in hand:
		for kokot in items:
			kokotina.append(kokot)
	for item in kokotina:
		if item == table[0] or item == table[1]:
			return 'YES'
	return 'NO'
emp = int(input())
w = 0
for i in range(1, emp):
	x = emp - i
	if x % i == 0:
		w += 1
print(w)


n = int(input())
ans = 0
if n == 2:
	print(1)
else:
	for leader in range(1, n):
		employees = n - leader
		if employees % leader == 0:
			ans += 1
	print(ans)


from sys import stdin, stdout
import math
input = stdin.readline()

def main():
	k = int(input)
	n = math.floor(k / 2)
	leaders = 0
	while n:
		if k % n == 0:
			leaders += 1
		n -= 1
	print(leaders)
main()


n = int(input())
ways = 0
for i in range(1, n + 1):
	leader = i
	employees = n - i
	if employees % leader == 0:
		ways += 1
	if leader >= employees:
		break
print(ways)


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


n = int(input())
ans = 0
for e in range(1, n):
	if (n - e) % e == 0:
		ans += 1
print(ans)


n = int(input())
count = 0
for index in range(1, n):
	if n % index == 0:
		count += 1
print(count)


emp = int(input())
leader = 0
for i in range(1, emp):
	if emp % i == 0:
		leader += 1
print(leader)


n = int(input())
o = int()
for i in range(1, n):
	if n % i == 0:
		o += 1
	else:
		continue
print(o)


n = int(input())
i = n
r = 0
while i > 0:
	if n % i == 0:
		r += 1
	i -= 1
print(r - 1)


x = int(input())
count = 0
for i in range(1, x):
	if x - i == 0:
		pass
	elif (x - i) % i == 0:
		count += 1
	else:
		continue
print(count)


emp = int(input())
k = 0
for i in range(1, emp):
	if (emp - i) % i == 0:
		k += 1
print(k)


n = int(input())
import math
sq = math.sqrt(n)
i = 2
count = 0
while i < sq:
	if n % i == 0:
		count = count + 1
	i = i + 1
total = 2 * count
if sq == int(sq):
	total = total + 1
print(total + 1)


n = int(input())
ans = 0
for i in range(n - 1):
	ans += int((n - i - 1) % (i + 1) == 0)
print(ans)


def divisors_under(m):
	count = 0
	for r in range(1, m // 2 + 1):
		if m % r == 0:
			count += 1
	return count
a = int(input())
print(divisors_under(a))


n = int(input())
cont = 0
aux = 1
while n - aux >= n / 5:
	if (n - aux) % aux == 0:
		cont += 1
	aux += 1
print(cont)


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


n = int(input())
ans = 0
d = 1
f = 0
while f < n:
	if (n - d) % d == 0 and n - d != 0:
		ans += 1
	d += 1
	f += 1
print(ans)


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


n = int(input())
i = 2
count = 0
if 2 <= n <= 10 ** 5:
	while n >= i:
		if n % i == 0:
			count = count + 1
		i += 1
print(count)


import math
m = input()
m = int(m)
sum = 0
for i in range(1, m):
	if (m - i) % i == 0:
		sum += 1
print(sum)


n = input()
n = int(n)
limit = int(n / 2)
final = 0
for i in range(limit):
	numteamleaders = i + 1
	restemployees = n - numteamleaders
	if restemployees % numteamleaders == 0:
		final += 1
print(final)


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


def printDivisors(n):
	i = 1
	count = 0
	while i < n:
		if n % i == 0:
			count += 1
		i = i + 1
	print(count)
n = int(input())
printDivisors(n)


employees = int(input())
empty = []
for i in range(1, employees):
	if employees % i == 0:
		empty.append(1)
print(len(empty))


def main():
	import math
	n = int(input())
	total = 1
	for f in range(2, n // 2 + 1):
		if n % f == 0:
			total += 1
	print(total)
main()


calisan = int(input())
sayac = 0
for ari in range(1, calisan + 1):
	if calisan % ari == 0:
		sayac += 1
print(sayac - 1)


test = int(input())
count = 0
for l in range(1, test):
	if test % l == 0:
		count += 1
print(count)


a = int(input())
z = 0
for j in range(1, a // 2 + 1):
	if (a - j) % j == 0:
		z += 1
print(z)


import math
inp = lambda : (int, input().split())
n = int(input())
sum = 0
for i in range(1, math.ceil(n / 2) + 1):
	if n % i == 0:
		sum += 1
print(sum)


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


people = int(input())
yes = 0
for i in range(1, people):
	if (people - i) % i == 0:
		yes += 1
print(yes)


emp = int(input())
cnt = 0
for i in range(1, emp):
	if (emp - i) % i == 0:
		cnt += 1
print(cnt)


n = int(input())
c = 0
from math import sqrt
from functools import reduce

def factors(n):
	step = 2 if n % 2 else 1
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(sqrt(n)) + 1, step) if n % i == 0)))
if factors(n) == 0:
	print('0')
else:
	print(len(factors(n)) - 1)


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


n = int(input())
res = 0
i = 1
while 1:
	temp = (n - i) / i
	if temp >= 1 and temp // 1 == temp:
		res += 1
	if temp < 1:
		break
	i += 1
print(res)


import sys
n = int(sys.stdin.readline().strip())
res = 0
for i in range(1, n):
	if n % i == 0:
		res += 1
print(res)


no = input()
no = int(no)
n = 0
for i in range(1, no):
	if (no - i) % i == 0:
		n += 1
print(n)


def fafa_cmpny(n):
	ways = 0
	if n == 2 or n == 3:
		return ways + 1
	y = n - 1
	for x in range(1, n):
		if x * (y // x) + x == n:
			ways += 1
		y -= 1
		if y == 0:
			break
	return ways
n = int(input().strip(' '))
print(fafa_cmpny(n))


import time
import collections

class Time_test:

	def __enter__(self):
		self.enter_time = time.time()

	def __exit__(self, exc_type, exc_val, exc_tb):
		print('Command was executed in', time.time() - self.enter_time)
n = int(input())
counter = 0
for i in range(n // 2 + n % 2, n):
	if i % (n - i) == 0:
		counter += 1
print(counter)


n = int(input())
ans = 0
ld = 0
while n > ld:
	n -= 1
	ld += 1
	if n % ld == 0:
		ans += 1
print(ans)


n = eval(input())
c = 1
i = 1
while i < n:
	if n % i == 0:
		c += 1
	i += 1
print(c - 1)


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

def fi():
	return float(input())

def si():
	return input()

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

def li():
	return list(mi())
n = ii()
a = 0
for i in range(1, n):
	if n % i == 0:
		a += 1
print(a)


a = int(input())
c = 1
d = 0
while c < a:
	c += 1
	if a % c == 0:
		d += 1
print(d)


empl = int(input())
num = 0
for i in range(1, empl):
	if empl % i == 0:
		num += 1
print(num)


n = int(input())
print(sum((n % d == 0 for d in range(2, n + 1))))


def answer():
	a = int(input())
	i = 1
	ans = -1
	c_out = []
	while i <= a:
		if not a % i:
			ans += 1
		i += 1
	return ans
print(answer())


def solve():
	nr = int(input())
	ans = 0
	if nr <= 2:
		print(1)
	else:
		for i in range(2, nr // 2 + 1):
			if nr % i == 0:
				ans += 1
		print(ans + 1)
solve()


n = int(input())
p = 1
count = 0
while p < n:
	if n % p == 0:
		count = count + 1
	p = p + 1
print(count)


em = int(input())
res = 0
temp = em // 2
for b in range(1, temp + 1):
	em1 = em - b
	if em1 % b == 0:
		res += 1
print(res)


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


def ans(n):
	total = 0
	for l in range(1, n + 1):
		if (n / l).is_integer() and l < n:
			total += 1
	print(total)
ans(int(input()))


Amount = int(input())
ans = 0
for i in range(1, Amount):
	if Amount % i == 0:
		ans += 1
print(ans)


employes = int(input())
i = int(1)
possibleWays = int(0)
while i <= employes / 2:
	if (employes - i) % i == 0:
		possibleWays += 1
	i += 1
print(possibleWays)


employee = int(input())
teams = 0
for x in range(int(employee / 2) + 1):
	if x != 0:
		if (employee - x) % x == 0:
			teams += 1
print(teams)


import sys
from math import ceil
n = int(sys.stdin.readlines()[0])
k = 0
for i in range(1, ceil(n / 2) + 1):
	if (n - i) % i == 0:
		k += 1
sys.stdout.write(str(k))


kolsotr = int(input())
variants = 0
for kolruk in range(1, kolsotr // 2 + 1):
	kolpodchin = kolsotr - kolruk
	if kolpodchin % kolruk == 0:
		variants += 1
print(variants)


a = int(input())
e = 0
c = 2
for i in range(a - 1):
	if a % c == 0:
		e += 1
		c += 1
	else:
		c += 1
print(e)


n = int(input())
anz = 0
for i in range(1, n):
	if n % i == 0:
		anz += 1
print(anz)


class CodeforcesTask935ASolution:

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

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

	def process_task(self):
		ways = 0
		for x in range(1, self.employees // 2 + 1):
			if not (self.employees - x) % x:
				ways += 1
		self.result = str(ways)

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


def solve():
	n = int(input())
	max_leaders = round(n / 2)
	ways = 0
	for leaders in range(1, max_leaders + 1):
		subordinates = n - leaders
		if subordinates % leaders == 0:
			ways += 1
	print(ways)
solve()


num = int(input())
if num <= 2:
	print('1')
	exit()
res = 0
for i in range(1, int(num / 2) + 1):
	if int(num - i) % i == 0:
		res += 1
print(res)


n = int(input())
ways = 1
for l in range(2, n // 2 + 1):
	if not n % l:
		ways += 1
print(ways)


totalWorkers = int(input())
counter = 0
for i in range(1, totalWorkers):
	leaders = i
	if (totalWorkers - leaders) % leaders == 0:
		counter += 1
print(counter)


a = int(input())
counter = 0
for i in range(1, a):
	if a % i == 0:
		counter += 1
print(counter)


n = int(input())
ways = 0
for i in range(1, n // 2 + 1):
	n_left = n - i
	if n_left % i == 0:
		ways += 1
print(ways)


import math
no_of_employees = int(input())
c = 0
for i in range(1, no_of_employees):
	d = no_of_employees - i
	z = d / i
	if z.is_integer() in range(1, no_of_employees):
		c += 1
print(c)


n = int(input())
b = []
for x in range(1, n):
	if (n - x) % x == 0:
		b.append(x)
print(len(b))


n = int(input())

def countn(n):
	i = 1
	divs = []
	while i * i <= n:
		if n % i == 0:
			if i != n and (not i in divs):
				divs.append(i)
			b = n // i
			if b != n and (not b in divs):
				divs.append(b)
		i = i + 1
	return len(divs)
print(countn(n))


num = int(input())
counter = 0
for i in range(1, num):
	bosses = i
	employes = num - i
	if employes % bosses == 0:
		counter += 1
print(counter)


n = int(input())
pas = 0
for i in range(1, n):
	if (n - i) % i == 0:
		pas += 1
print(pas)


n = int(input())
count = 0
for x in range(n - 1):
	if n % (x + 1) == 0:
		count += 1
	else:
		pass
print(count)


p = int(input())
total = 0
for w in range(1, p):
	if (p - w) % w == 0:
		total += 1
print(total)


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


n = int(input())
c = 1
if n == 2:
	print(c)
else:
	for i in range(2, n):
		s = n - i
		if s % i == 0:
			c = c + 1
		else:
			pass
	print(c)


n = int(input())
l = 1
n = n - 1
cnt = 1
while l < n:
	l = l + 1
	n = n - 1
	if n % l == 0:
		cnt += 1
print(cnt)


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


n = int(input())
boss = n - 1
nb = 1
work = 1
for i in range(int(n / 2)):
	boss -= 1
	nb += 1
	if boss % nb == 0:
		work += 1
if n == 2:
	work = 1
print(work)


a = int(input())
s = 1
for i in range(2, a // 2 + 1):
	if i + (a - i) // i * i == a:
		s = s + 1
if a > 3:
	print(s)
else:
	print(1)


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


def checkSolutions(leaders, employees):
	if float(employees).is_integer():
		return 1
	return 0
n = int(input())
solutions = 0
if n < 2:
	print(1)
	exit()
for i in range(1, n):
	solutions += checkSolutions(i, (n - i) / i)
print(solutions)


from sys import stdin, stdout
n = int(stdin.readline().rstrip())
w = 0
for i in range(1, n):
	j = n - i
	if j % i == 0:
		w += 1
stdout.write(str(w))


t = int(input())
x = 2
c = 1
while x < t:
	temp = t - x
	if temp % x == 0:
		c = c + 1
	x = x + 1
print(c)


def read():
	return list(map(int, input().split()))
n = int(input())
ans = 0
for i in range(1, n):
	if (n - i) % i == 0:
		ans += 1
print(ans)


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


def solve(n):
	cnt = 0
	for i in range(1, n):
		if n % i == 0:
			cnt += 1
	return cnt
n = int(input())
print(solve(n))


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


import sys
n = int(sys.stdin.readline().strip())
ways = 0
print(len(list(filter(lambda x: n % x == 0, range(1, n // 2 + 1)))))


def solve(num):
	l = 0
	i = 1
	while i <= num / 2:
		if (num - i) % i == 0:
			l += 1
		i += 1
	return l
num = int(input())
print(solve(num))


n = int(input())
ways = 0
i = 1
while i <= n:
	if n % i == 0:
		ways += 1
	i += 1
print(ways - 1)


r = int(input())
c = 0
for i in range(1, r):
	t = r - i
	if t % i == 0:
		c += 1
print(c)


N = int(input())
N1 = N
count = 1
r = 2
while r <= N // 2:
	N1 = N1 - r
	if N1 % r == 0:
		count = count + 1
		r = r + 1
	else:
		r = r + 1
	N1 = N
print(count)


n = int(input())
x = 0
y = n // 2
k = 0
i = 1
while y > 0:
	x = n % i
	y -= 1
	if x == 0:
		k += 1
	i += 1
print(k)


n = int(input())
re = 0
for i in range(1, n):
	if (n - i) % i == 0:
		re += 1
print(re)


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


def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
n = int(input())
ans = 0
for i in range(1, n // 2 + 1):
	m = n - i
	g = m % i
	if g == 0:
		ans = ans + 1
print(ans)


import math
l = []

def TotDiv(n):
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n / i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n / i)
		i = i + 1
a = int(input())
TotDiv(a)
print(len(l) - 1)


a = int(input())
cpt = 0
for i in range(1, a):
	if a % i == 0:
		cpt += 1
print(cpt)


info = int(input())

def factors(x):
	ways = 0
	for i in range(1, x):
		if x % i == 0:
			ways += 1
	return ways
print(factors(info))


n = int(input())
result = 0
i = 1
while i < n:
	if (n - i) % i == 0:
		result += 1
	i += 1
print(result)


empl = int(input())
brojac = 0
for i in range(1, int(empl // 2) + 1):
	if (empl - i) % i == 0:
		brojac += 1
print(brojac)


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


emp = int(input())
opt = 0
for i in range(1, emp):
	if i == 1:
		opt += 1
		continue
	bosses = i
	employees = emp - i
	if bosses <= employees and employees % bosses == 0:
		opt += 1
print(opt)


n = int(input())
num = 0
for i in range(1, n):
	if (n - i) % i == 0:
		num += 1
print(num)


n = int(input())
canDos = 0
for i in range(1, n // 2 + 1):
	left = n - i
	if left % i == 0:
		canDos += 1
print(canDos)


n = int(input())
ways = 0
for j in range(1, n):
	if j % (n - j) == 0:
		ways += 1
print(ways)


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


coworkers = int(input())
count = 0
for i in range(1, coworkers):
	if (coworkers - i) % i == 0:
		count += 1
print(count)


n = int(input())
print(sum((n % j < 1 for j in range(1, n))))


a = int(input())
c = 0
for i in range(1, int(a * 0.5) + 1):
	if (a / i).is_integer() and a / i >= 2:
		c += 1
	else:
		pass
print(c)


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


GI = lambda : int(input())
GIS = lambda : map(int, input().split())

def main():
	n = GI()
	res = 0
	for i in range(1, n // 2 + 1):
		if not (n - i) % i:
			res += 1
	print(res)
main()


employees = int(input())
leaders = 0
cnt = 0
while leaders <= employees:
	if leaders == employees:
		break
	employees -= 1
	leaders += 1
	if employees / leaders == int(employees / leaders):
		cnt += 1
print(cnt)


n = int(input())
leaders = 1
c = 0
while leaders != n:
	others = n - leaders
	if others % leaders == 0:
		c = c + 1
	leaders += 1
print(c)


n = int(input())
validTeam = 0
for i in range(1, n):
	if (n - i) % i == 0:
		validTeam += 1
print(validTeam)


def foo(x):
	count = 0
	for i in range(1, x // 2 + 1):
		if not x % i:
			count += 1
	print(count)
first = int(input())
foo(first)


n = int(input())
k = 1
m = 2
while m <= n // 2:
	if n % m == 0:
		k += 1
	m += 1
print(k)


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


n = int(input())
x = 0
a = 0
while a < n:
	a = a + 1
	if n % a == 0:
		x = x + 1
print(x - 1)


n = int(input())
counter = 0
for number in range(1, int(n / 2) + 1):
	if n % number == 0 and n != number:
		counter = counter + 1
print(counter)


n = int(input())
w = 0
for x in range(2, n + 1):
	if (n - x) % x == 0:
		w = w + 1
	else:
		w = w + 0
print(w)


employees = input()

def solve(employees):
	if not employees:
		return 0
	employees = int(employees)
	res = 1
	leader = 2
	while leader <= employees / 2:
		temp = (employees - leader) % leader
		if temp == 0:
			res += 1
		leader += 1
	return res
print(solve(employees))


from sys import stdin, stdout
n = int(stdin.readline().strip())
ways = 0
for i in range(1, n // 2 + 1):
	if n % i == 0:
		ways += 1
stdout.write('%d\n' % ways)


a = int(input())
r = 0
for q in range(1, a):
	if a % q == 0:
		r = r + 1
print(r)


n = int(input())
if n == 0 or n == 1:
	print(0)
	exit(0)
count = 1
for i in range(2, n):
	if n % i == 0:
		count += 1
print(count)


n = int(input())
p = q = r = 1
while not n % 2:
	n //= 2
	r += 1
while p * p < n:
	p += 2
	while not n % p:
		n //= p
		q += 1
	r *= q
	q = 1
print(r * ((n > 1) + 1) - 1)


import sys
n = int(sys.stdin.readline().split()[0])
count = 0
for k in range(1, n):
	if (n - k) % k == 0:
		count += 1
print(count)


def solve(test):
	n = int(input())
	ans = 0
	for i in range(1, n):
		if n % i == 0:
			ans += 1
	print(ans)
t = 1
for _ in range(t):
	solve(_ + 1)


n = int(input())
print(sum((n % x == 0 for x in range(1, int(n / 2) + 1))))


emp = int(input())
temp = emp
tl = 1
flag = True
div = 2
while div <= temp / 2:
	while flag:
		emp -= div
		if emp % div == 0:
			tl += 1
		flag = False
	div += 1
	flag = True
	emp = temp
print(tl)


def solve():
	n = int(input())
	ans = 0
	for ruk in range(1, n):
		rab = n - ruk
		if ruk % rab == 0:
			ans += 1
	print(ans)
solve()


n = int(input())
r = sum(map(lambda x: 0 if n % x else 1, range(2, n + 1)))
print(r)


import math
from sys import stdin
n = int(stdin.readline())
number = 0
if math.sqrt(n) % 1 == 0:
	number = -1
for i in range(2, math.floor(math.sqrt(n)) + 1):
	if n % i == 0:
		number += 2
print(number + 1)


x = int(input())
t = 0
for i in range(1, x // 2 + 1):
	if not (x - i) % i:
		t += 1
print(t)


N = int(input())
c = 0
for leaders in range(1, N // 2 + 1):
	members = N - leaders
	if members % leaders == 0:
		c = c + 1
print(c)


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


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


__author__ = '#miner'
(a, count) = (int(input()), 0)
for i in range(1, a):
	if (a - i) % i == 0:
		count += 1
print(count)


n = int(input())
k = 1
a = 0
while n > k:
	if n % k == 0:
		a = a + 1
	k = k + 1
print(a)


employees = int(input())
mods = 0
for i in range(1, employees):
	if (employees - i) % i == 0:
		mods += 1
print(mods)


n = int(input())

def company(n):
	int = True
	W = 0
	L = 1
	M = n - L
	while L <= n / 2:
		if M % L == 0:
			W += 1
			L += 1
			M -= 1
		else:
			L += 1
			M -= 1
	print(W)
company(n)


n = int(input())
cnt = 0
m = int(n + 1 / 2)
for a in range(1, m):
	n1 = n - a
	if n1 % a == 0:
		cnt += 1
print(cnt)


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

def make_divisors_without_own(n):
	r = make_divisors(n)
	r.remove(1)
	r.remove(n)
	return r
n = int(input())
l = len(make_divisors_without_own(n)) + 1
print(l)


n = int(input())
no_of_ways = 0
for i in range(1, n + 1):
	emp = n - i
	if emp % i == 0 and emp != 0:
		no_of_ways += 1
print(no_of_ways)


n = int(input())
t = 0
for l in range(1, n):
	if (n - l) / l % 1 == 0:
		t += 1
print(t)


work = int(input())
count = 0
for i in range(1, work):
	if i % (work - i) == 0:
		count += 1
print(count)


w = input()
w = int(w)
c = -1
a = 1
while a <= w:
	if w % a == 0:
		c = c + 1
	a = a + 1
print(str(c))


from sys import stdin, stdout

def main():
	inp = int(input())
	way = 0
	if inp == 2:
		way = 1
	elif inp != 2:
		for i in range(1, inp // 2 + 1):
			person_rem = inp - i
			if person_rem % i == 0:
				way += 1
			else:
				continue
	print(way)
main()


x = int(input())
print(sum((x % i < 1 for i in range(2, x + 1))))


i = int(input())
l = 0
for x in range(1, 100001):
	if i % x == 0:
		l += 1
print(int(l) - 1)


from math import sqrt

def get_d_cnt(a):
	cnt = 0
	for i in range(1, int(sqrt(a)) + 1):
		cnt += 2 if a % i == 0 else 0
	return cnt - int(int(sqrt(a)) ** 2 == a)
n = int(input())
print(get_d_cnt(n) - 1)


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


n = int(input())
res = 0
c = 1
while c != n:
	if n % c == 0:
		res += 1
		c += 1
	else:
		c += 1
print(res)


a = int(input())
sum = 0
for i in range(1, a):
	if a % i == 0:
		sum = sum + 1
print(sum)


getInputList = lambda : list(input().split())
getInputIntList = lambda : list(map(int, input().split()))
n = int(input())
c = 0
for i in range(1, int(n / 2) + 1):
	if (n - i) % i == 0:
		c += 1
print(c)


x = int(input())
a = 0
for i in range(2, x + 1):
	if x % i == 0:
		a += 1
	else:
		pass
print(a)


import math
cou = 0

def is_prime(n):
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			return False
	return True
x = int(input())
if is_prime(x):
	print(1)
else:
	for i in range(2, int(x / 2) + 1):
		if x % i == 0:
			cou += 1
	print(cou + 1)


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


def kol(n):
	k = 0
	for i in range(1, n // 2 + 1):
		if n % i == 0:
			k += 1
	return k
n = int(input())
print(kol(n))


import sys
employee = int(input())
num_ways = 0
if employee == 2:
	print('1')
	sys.exit(0)
for x in range(2, employee):
	if employee % x == 0:
		num_ways += 1
print(num_ways + 1)


import sys
import math
employees = int(input())
halfEmployees = (employees + 1) / 2
leader = 1
ways = 0
while leader < halfEmployees:
	employeesRemain = employees - leader
	division = employees / leader
	if math.floor(division) == division:
		ways += 1
	leader += 1
print(ways)


n = int(input())
flag = 2
res = 1
if n % 2 != 0:
	while flag < 10 ** 5:
		flag = flag + 1
		if n % flag == 0 and flag != n:
			res = res + 1
	print(res)
if n % 2 == 0:
	res2 = 1
	while flag < 10 ** 5:
		flag = flag + 1
		if n % flag == 0:
			res2 = res2 + 1
	print(res2)


def Div(n, d):
	if n % d == 0:
		return True
	return False
n = int(input())
cnt = 0
for i in range(1, n):
	if Div(n, i) == True:
		cnt += 1
print(cnt)


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

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

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

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

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

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

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

def S():
	return input()

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

def main():
	n = I()
	r = 0
	for i in range(1, n // 2 + 1):
		if n % i == 0:
			r += 1
	return r
print(main())


import math
count = 1
n = int(input())
for i in range(2, n + 1):
	a = abs(n - i)
	if i <= a and a % i == 0:
		count += 1
	elif a < i:
		break
print(count)


import sys
n = int(input())
s = 0
for i in range(2, n + 1):
	if (n - i) % i == 0:
		s += 1
print(s)


a = int(input())
print(sum((a % i < 1 for i in range(1, a))))


inp = int(input())
output = 0
for x in range(1, int(inp / 2) + 1):
	s = str((inp - x) / x)
	if s[-1] == '0' and s[-2] == '.':
		output += 1
print(output)


import math
n = int(input())
print(len([x for x in range(1, math.trunc(n / 2) + 1) if (n - x) % x == 0]))


n = int(input())
c = 0
for v in range(1, n + 1):
	if n % v == 0:
		c += 1
print(c - 1)


n = int(input())
if n < 3:
	print(1)
else:
	cnt = 0
	for bosses in range(1, n):
		val = (n - bosses) / bosses
		if val == int(val):
			cnt += 1
	print(cnt)


n = int(input())
x = 1
count = 0
i = n // 2
while x <= i:
	t = n - x
	if t % x == 0:
		count += 1
	x += 1
print(count)


n = int(input())
r = 0
for i in range(1, n):
	j = n - i
	r += j % i == 0
print(r)


n = int(input())
l = [e for e in range(1, n // 2 + 1) if (n - e) % e == 0]
print(str(len(l)))


n = int(input())
res = 0
curr = 1
while n - curr > 0:
	test = n - curr
	if float(test / curr).is_integer():
		res += 1
	curr += 1
print(res)


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


def chef(s):
	count = 0
	for i in range(1, s + 1):
		if int((s - i) / i) != 0:
			if float((s - i) / i) % int((s - i) / i) == 0:
				count += 1
	return count

def main():
	s = int(input())
	print(chef(s))
main()


import math
n = int(input())
answer = 0
for leaders in range(1, n // 2 + 1):
	if (n - leaders) % leaders == 0:
		answer += 1
print(answer)


import sys
import math
input = sys.stdin.readline

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

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

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

def invr():
	return map(int, input().split())
n = inp()
ans = 0
for i in range(1, n):
	if n % i == 0:
		ans += 1
print(ans)


employees = int(input())
counter = 0
for i in range(1, employees // 2 + 1):
	if (employees - i) % i == 0:
		counter += 1
	else:
		counter += 0
print(counter)


t = int(input().strip())
e = 0
l = t // 2
co = 0
while l != 0:
	e = t - l
	if e % l == 0:
		co += 1
	l -= 1
print(co)


n = int(input())
i = 1
k = 0
if n == 2:
	print(1)
else:
	while i <= n:
		if n % i == 0:
			k = k + 1
		i = i + 1
	print(k - 1)


import math

def main():
	n = int(input())
	ways = 0
	for n_m in range(1, math.ceil((n + 1) / 2)):
		n_e = n - n_m
		if n_e % n_m == 0:
			ways += 1
	print(ways)
main()


a = int(input())
d = 0
for i in range(1, a):
	if a % i == 0:
		d = d + 1
print(int(d))


employees = int(input())
wayes = 0
for i in range(1, employees):
	if employees % i == 0:
		wayes += 1
print(wayes)


n = int(input())
if n == 2:
	print(1)
else:
	count = 1
	for i in range(2, n // 2 + 1):
		diff = n - i
		if diff >= i:
			rem = diff % i
			if rem % i == 0:
				count += 1
			else:
				continue
	print(count)


import math
Anzahl = int(input())
Wege = 0
for k in range(1, math.floor(Anzahl / 2) + 1):
	if (Anzahl - k) % k == 0:
		Wege += 1
print(Wege)


n = int(input())
ret = int()
for i in range(n):
	l = i + 1
	e = n - l
	if n % l == 0 and l != n:
		ret += 1
else:
	print(ret)


n = int(input())
c = 0
if n % 2 == 0:
	c += 1
if n % 3 == 0:
	c += 1
if n > 3:
	for i in range(4, n + 1):
		if n % i == 0:
			c += 1
print(c)