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 ≤ 105) — 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. 

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;


public class main {

   
    
    public static void main(String[] args) {        
        InputReader in = new InputReader(System.in);
        Scanner sc = new Scanner(System.in);
        PrintWriter p = new PrintWriter(System.out); 
        
        int n = in.nextInt();
        int ans=1;
        if(n==2)
            ans=1;
        else{
            for(int i=2;i<=n/2;i++){
                if(((n-i)%i)==0){
                    ans++;
                }
            }
            
        }
        System.out.println(ans);
        
    } 

    // print all prime numbers between l and r
    public static void segmentedSieve(int l, int r){
        ArrayList<Integer> prime = new ArrayList<Integer>();
        int limit = (int) Math.floor(Math.sqrt(r)) +1;
        
        prime = sieveOfEratosthenes(limit, prime);
        
        boolean mark[] = new boolean[r-l+1];
        for(int i=0;i<mark.length;i++){
            mark[i] = true;
        }
        
        for(int i=0;i<prime.size();i++){
            int loLim = (int) Math.floor(l/prime.get(i))*(prime.get(i));
            if(loLim<l){
                loLim+=prime.get(i);
            }
            
            for(int j=loLim;j<r;j+=prime.get(i)){             
                    mark[j-l] = false;
            }
        }          
        for(int i=l;i<r;i++){
            if(mark[i - l]==true){
                System.out.print(i+" ");
            }
        }    
    }
    
    public static ArrayList<Integer> sieveOfEratosthenes(int limit, ArrayList<Integer> prime){
        boolean isPrime[] = new boolean[limit];
        for(int i=0;i<limit;i++){
            isPrime[i] = true;
        }
        for(int p=2; p*p<limit; p++){
            if(isPrime[p] == true){
                for(int i=2*p; i<limit;i+=p){
                    isPrime[i] = false;
                }
            }    
        }
        for(int p=2; p<limit; p++){
            if(isPrime[p]==true){
                prime.add(p);
            }
        }        
        return prime;
    }
    public static int[] sieveOfEratosthenes(int limit, int[] isPrime){
        
        for(int i=0;i<limit;i++){
            isPrime[i] = 1;
        }
        for(int p=2; p*p<limit; p++){
            if(isPrime[p] == 1){
                for(int i=2*p; i<limit;i+=p){
                    isPrime[i] = 0;
                }
            }    
        }        
        return isPrime;
    }
    public static int KMP(String text, String pattern){
        int n = text.length();
        int m = pattern.length();
        if(m==0) return 0;
        int fail[] = computeFailArray(pattern);
        int i=0;
        int j=0;
        
        while(i<n){
            if(text.charAt(i)==pattern.charAt(j)){
                if(j==m-1)    
                    return i-j; 
                i++;
                j++;     
            }
            else if(j>0)
                j=fail[j-1];
            else
                i++;            
        }
        return -1;
    }

    public static int[] computeFailArray(String pattern){
        int m = pattern.length();
        int fail[] = new int[m];
        fail[0] = 0;
        int j=0;
        int i=1;
        while(i<m){
            if(pattern.charAt(j)==pattern.charAt(i)){
                fail[i]=j+1;
                j++;
                i++;
            }
            else if(j>0){
                j=fail[j-1];
            }
            else
                i++;
                
        }
        return fail;
    }
    public static void reverseArray(int a[], int start, int end){
        if(start>=end)
            return;
        int temp = a[start];
        a[start] = a[end];
        a[end] = temp;
        reverseArray(a, start+1, end-1);
    }
    
    public static long fib(long n){
        long F[][] = new long[][]{{1,1},{1,0}};
        if (n == 0)
            return 0;
        power(F, n-1);
      
        return F[0][0];
    }
    
    static void multiply(long F[][], long M[][]){
        long x =  (F[0][0]*M[0][0] + F[0][1]*M[1][0])%1000000007;
        long y =  (F[0][0]*M[0][1] + F[0][1]*M[1][1])%1000000007;
        long z =  (F[1][0]*M[0][0] + F[1][1]*M[1][0])%1000000007;
        long w =  (F[1][0]*M[0][1] + F[1][1]*M[1][1])%1000000007;
     
        F[0][0] = x;
        F[0][1] = y;
        F[1][0] = z;
        F[1][1] = w;
    }
      
    static void power(long F[][], long n){
        if( n == 0 || n == 1) 
            return;
        long M[][] = new long[][]{{1,1},{1,0}};
      
        power(F, n/2);
        multiply(F, F);
      
        if (n%2 != 0)
            multiply(F, M);
    }
   static boolean isPrime(int n)
    {
    // Corner cases
    if (n <= 1)  return false;
    if (n <= 3)  return true;
 
    // This is checked so that we can skip 
    // middle five numbers in below loop
    if (n%2 == 0 || n%3 == 0) return false;
 
    for (int i=5; i*i<=n; i=i+6)
        if (n%i == 0 || n%(i+2) == 0)
           return false;
 
    return true;
    }
    
    static class Pair implements Comparable<Pair> {
	int u;
	int v;
	BigInteger bi;
	public Pair(int u, int v) {
		this.u = u;
		this.v = v;
	}
 
	public int hashCode() {
		int hu = (int) (u ^ (u >>> 32));
		int hv = (int) (v ^ (v >>> 32));
		return 31 * hu + hv;
	}
 
	public boolean equals(Object o) {
		Pair other = (Pair) o;
		return u == other.u && v == other.v;
	}
 
	public int compareTo(Pair other) {
		return Long.compare(u, other.u) != 0 ? Long.compare(u, other.u) : Long.compare(v, other.v);
	}
 
	public String toString() {
		return "[u=" + u + ", v=" + v + "]";
	}
    }
 
    public static void debug(Object... o) {
            System.out.println(Arrays.deepToString(o));
    }
 
    static long modulo(long a,long b,long c) {
        long x=1;
        long y=a;
        while(b > 0){
                if(b%2 == 1){
                        x=(x*y)%c;
                }
                y = (y*y)%c; // squaring the base
                b /= 2;
        }
        return  x%c;
    }
    
    public static long getClosestK(long[] a, long x) {
 
        int low = 0;
        int high = a.length - 1;
 
        while (low <= high) {
            int mid = (low + high) / 2;
 
            // test lower case
            if (mid == 0) {
                if (a.length == 1) {
                    return a[0];
                }
 
                return Math.min(Math.abs(a[0] - x), Math.abs(a[1] - x)) + x;
            }
 
 
            // test upper case
            if (mid == a.length - 1) {
                return a[a.length - 1];
            }
 
            // test equality
            if (a[mid] == x || a[mid + 1] == x) {
                return x;
            }
 
 
            // test perfect range.
            if (a[mid] < x  && a[mid + 1] > x) {
                return Math.min(Math.abs(a[mid] - x), Math.abs(a[mid + 1] - x)) + x;
            }
 
            // keep searching.
            if (a[mid] < x) {
                low = mid + 1;
            } else { 
                high = mid;
            }
        }
        throw new IllegalArgumentException("The array cannot be empty");
    }
 
    long factorial(long n,long M) {
        long ans=1;
        while(n>=1)
        {
            ans=(ans*n)%M;
            n--;
        }
        return ans;
    }
 
    static long gcd(long x, long y){
	if(x==0)
		return y;
	if(y==0)
		return x;
	long r=0, a, b;
	a = (x > y) ? x : y; // a is greater number
	b = (x < y) ? x : y; // b is smaller number
	r = b;
	while(a % b != 0)
	{
		r = a % b;
		a = b;
		b = r;
	}
	return r;
    }
 
    static class InputReader {
	public BufferedReader reader;
	public StringTokenizer tokenizer;
 
	public InputReader(InputStream inputstream) {
		reader = new BufferedReader(new InputStreamReader(inputstream));
		tokenizer = null;
	}
 
	public String nextLine(){
		String fullLine=null;
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				fullLine=reader.readLine();
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
			return fullLine;
		}
		return fullLine;
	}
	public String next() {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(reader.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}
	public long nextLong() {
		return Long.parseLong(next());
	}
	public int nextInt() {
		return Integer.parseInt(next());
	}
    }
}
