This night wasn't easy on Vasya. His favorite team lost, and he didn't find himself victorious either — although he played perfectly, his teammates let him down every time. He had to win at least one more time, but the losestreak only grew longer and longer... It's no wonder he didn't get any sleep this night at all.

In the morning, Vasya was waiting the bus to the university on the bus stop. Vasya's thoughts were hazy and so he couldn't remember the right bus' number quite right and got onto the bus with the number n.

In the bus, Vasya thought that he could get the order of the digits in the number of the bus wrong. Futhermore, he could "see" some digits several times, but the digits he saw were definitely in the real number of the bus. For example, if Vasya saw the number 2028, it could mean that the real bus number could be 2028, 8022, 2820 or just 820. However, numbers 80, 22208, 52 definitely couldn't be the number of the bus. Also, real bus number couldn't start with the digit 0, this meaning that, for example, number 082 couldn't be the real bus number too.

Given n, determine the total number of possible bus number variants.

Input

The first line contains one integer n (1 ≤ n ≤ 10^{18}) — the number of the bus that was seen by Vasya. It is guaranteed that this number does not start with 0.

Output

Output a single integer — the amount of possible variants of the real bus number.

Examples

Input

97


Output

2


Input

2028


Output

13

Note

In the first sample, only variants 97 and 79 are possible.

In the second sample, the variants (in the increasing order) are the following: 208, 280, 802, 820, 2028, 2082, 2208, 2280, 2802, 2820, 8022, 8202, 8220.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;


public class Main {

	static boolean visited[] ; 
	static boolean ends[] ;
	static long mod = 1000000007 ;
	static int lens[] ; 
	static int seeds[] ; 
	static char a[] ;
	static double total ; 
	public static ArrayList adj[] ; 
	public static long x,y ;
	public static ArrayList<Long> xx ;	
	public static double dp[][][] ;
	public static void main(String[] args) throws IOException, InterruptedException {
		Scanner sc =  new Scanner(System.in) ;


		String s = sc.next() ; 
		int n[] = new int[10]; 
		for (int i = 0; i < s.length(); i++)
		{
			n[s.charAt(i)-48]++ ;
		}

		long res =0 ;
		int z=n[0];
		Arrays.sort(n);

		for (int i = 0; i < n.length; i++)
		{
			if(n[i]==z){z=i ; break;}
		}

		for (int i = 0; i <=n[0]; i++)
			for (int j = 0; j <=n[1]; j++)
				for (int j2 = 0; j2 <=n[2]; j2++)
					for (int k = 0; k <=n[3]; k++)
						for (int k2 = 0; k2 <=n[4]; k2++)
							for (int l = 0; l<=n[5]; l++)
								for (int l2 = 0; l2 <=n[6]; l2++)
									for (int m = 0; m <=n[7]; m++)
										for (int m2 = 0; m2 <=n[8]; m2++)
											for (int o = 0; o <=n[9]; o++)
											{
												int index=0 ;
												if(z==0) index= i; 
												else if(z==1) index=j ;
												else if(z==2) index=j2; 
												else if(z==3) index=k ; 
												else if(z==4) index=k2; 
												else if(z==5) index=l ; 
												else if(z==6) index=l2 ; 
												else if(z==7) index=m ; 
												else if(z==8) index=m2; 
												else if(z==9) index=o ;

												long ans=0,num=0,den=0;
												if(i==0 && n[0]>0)ans=0; 
												else if(j==0 &&n[1]>0)ans=0;
												else if(j2==0 &&n[2]>0)ans=0 ; 
												else if(k==0 &&n[3]>0)ans=0 ;
												else if(k2==0 &&n[4]>0)ans =0 ;
												else if(l==0 && n[5]>0)ans=0 ;
												else if(l2==0 && n[6]>0)ans=0;
												else if(m==0 &&n[7]>0)ans=0 ;
												else if (m2==0 && n[8]>0)ans=0 ; 
												else if(o==0 && n[9]>0)ans=0 ;
												else 
												{
													int sum = i+j+j2+k+k2+l+l2+m+m2+o ;
													num = fac(sum);
													den=1l*fac(i)*fac(j)*fac(j2)*fac(k)*fac(k2)*fac(l)*fac(l2)*fac(m)*fac(m2)*fac(o);
													num =1l*num*(sum-index)/sum ;
													ans = num/den ;
												}
												res+=ans;
												if(ans!=0)System.err.println(ans+" "+num+" "+den);



											}
		System.out.println(res);
	}

	public static long fac(int s)
	{
		if(s==0 || s==1) return 1 ;
		return 1l*s*fac(s-1);
	}































	public static void dfss(int root , int len)
	{
		visited[root]=true ; 
		if(ends[root] && root!=0) lens[root] = len ; 

		for (int i = 0; i < adj[root].size(); i++)
		{
			int c= (int) adj[root].get(i) ; 
			if(visited[c]==false)
				dfss(c, len+1);
		}
	}

	public static void pr(int root ,  int seed){
		visited[root] = true ;
		int dv = adj[root].size()-1 ; 
		if(root==0) dv++ ;

		for (int i = 0; i < adj[root].size(); i++)
		{
			int c = (int)adj[root].get(i) ; 
			seeds[c]=dv*seed ;
		}

		for (int i = 0; i < adj[root].size() ; i++)
		{
			int c = (int)adj[root].get(i) ; 
			if(visited[c]==false)
				pr(c , seeds[c]);

		}

	}



	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		public boolean ready() throws IOException {
			return br.ready();
		}
	}


	public static long getGCD(long n1, long n2) {
		if (n2 == 0) {
			return n1;
		}
		return getGCD(n2, n1 % n2);
	}


	public static void shuffle(pair[] ss){
		if(ss.length==1)
			return ; 
		for (int i = 0; i < ss.length; i++)
		{
			Random rand = new Random();

			int  n = rand.nextInt(ss.length-1) + 0;

			pair temp = ss[i] ; 
			ss[i] = ss[n] ; 
			ss[n] = temp ;
		}
	}
	//	public static int binary(ArrayList<pair> arr, int l, int r, long x)   /// begin by 0 and n-1
	//	{
	//		if (r>=l)
	//		{
	//			int mid = l + (r - l)/2;
	//			if (arr.get(mid).x== x)
	//				return mid;
	//			if (arr.get(mid).x> x)
	//				return binary(arr, l, mid-1, x);
	//			return binary(arr, mid+1, r, x);
	//		}
	//		return -1;
	//	}

	/// searching for the index of first elment greater than x
	public static int binary1(int[]arr , int x) {
		int low = 0, high = arr.length; // numElems is the size of the array i.e arr.size() 
		while (low != high) {
			int mid = (low + high) / 2; // Or a fancy way to avoid int overflow
			if (arr[mid] <= x) {
				/* This index, and everything below it, must not be the first element
				 * greater than what we're looking for because this element is no greater
				 * than the element.
				 */
				low = mid + 1;
			}
			else {
				/* This element is at least as large as the element, so anything after it can't
				 * be the first element that's at least as large.
				 */
				high = mid;
			}
		}
		return low ; // return high ; 
	}


	////// searching for last element less than X 
	//	public static int binary2(pair[]arr , int x) {
	//		int low = 0, high = arr.length; // numElems is the size of the array i.e arr.size() 
	//		while (low != high) {
	//			int mid = (low + high) / 2; // Or a fancy way to avoid int overflow
	//			if (arr[mid].x >= x) {
	//				/* This index, and everything below it, must not be the first element
	//				 * greater than what we're looking for because this element is no greater
	//				 * than the element.
	//				 */
	//				high=mid;
	//			}
	//			else {
	//				/* This element is at least as large as the element, so anything after it can't
	//				 * be the first element that's at least as large.
	//				 */
	//				low = mid+1 ; 
	//			}
	//		}
	//		return low ; // return high ; 
	//	}







	public static int binary(long []arr , long target , int low , long shift) {
		int high = arr.length; 
		while (low != high) {
			int mid = (low + high) / 2; 
			if (arr[mid]-shift <= target) {
				low = mid + 1;
			}
			else {
				high = mid;
			}
		}
		return low ; // return high ; 
	}
	public static boolean isLetter(char x){
		if(x+0 <=122 && x+0 >=97 )
			return true ;
		else if (x+0 <=90 && x+0 >=65 )
			return true ; 
		else return false; 
	}
	public static long getPrimes(long x ){
		if(x==2 || x==3 || x==1)
			return 2 ;
		if(isPrime(x))
			return 5 ;
		for (int i = 2; i*i<=x; i++)
		{
			if(x%i==0 && isPrime(i))
				return getPrimes(x/i) ;
		}
		return -1;
	}







	public static int lis( int[]a , int n){
		int lis[] = new int[n] ; 
		Arrays.fill(lis,1) ; 

		for(int i=1;i<n;i++)
			for(int j=0 ; j<i; j++)
				if (a[i]>a[j] &&  lis[i] < lis[j]+1)   
					lis[i] = lis[j] + 1;           

		int max = lis[0];

		for(int i=1; i<n ; i++)
			if (max < lis[i])
				max = lis[i] ;
		return (max);

		//			ArrayList<Integer> s = new ArrayList<Integer>() ;
		//			for (int i = n-1; i >=0; i--)
		//			{
		//				if(lis[i]==max)
		//				{
		//					s.add(a[i].z);
		//					max --; 
		//				}
		//			}
		//
		//			for (int i = s.size()-1 ; i>=0 ;  i--)
		//			{
		//				System.out.print(s.get(i)+" ");
		//			}
		//
	}
	public static int calcDepth(Vertix node){
		if(node.depth>0) return node.depth; 
		// meaning it has been updated before;
		if(node.parent != null)
			return 1+ calcDepth(node.parent);
		else
			return -1;
	}

	public static boolean isPrime (long num){
		if (num < 2) return false;
		if (num == 2) return true;
		if (num % 2 == 0) return false;
		for (int i = 3; i * i <= num; i += 2)
			if (num % i == 0) return false;
		return true;
	}


	public static ArrayList<Long> getDiv(Long n)
	{
		ArrayList<Long>  f = new ArrayList<Long>() ; 

		while (n%2==0)
		{
			if(!f.contains(2))f.add((long) 2) ;
			n /= 2;
		}

		// n must be odd at this point.  So we can
		// skip one element (Note i = i +2)
		for (long i = 3; i <= Math.sqrt(n); i+= 2)
		{
			// While i divides n, print i and divide n
			while (n%i == 0)
			{
				if(!f.contains(i))f.add(i);
				n /= i;
			}
		}

		// This condition is to handle the case whien
		// n is a prime number greater than 2
		if (n > 2)
			if(!f.contains(n))f.add(n);


		return f ;



	}

	//		public static boolean dfs(Vertix v , int target){
	//			try{
	//				visited[v.i]= true ;
	//			} catch (NullPointerException e)
	//			{
	//				System.out.println(v.i);
	//			}
	//			if(v.i == target)
	//
	//				return true ;
	//			for (int i =0 ; i< v.neighbours.size() ; i++)
	//			{ 
	//
	//				Vertix child = v.neighbours.get(i) ;
	//				if(child.i == target){
	//					found = true  ; 
	//				}
	//				if(visited[child.i]==false){
	//					found |= dfs(child, target) ;
	//				}
	//			}
	//			return found; 
	//		}









	public static class Vertix{
		long i ; 
		int depth ;
		ArrayList<Vertix> neighbours ; 
		Vertix parent ; 
		Vertix child ; 


		public Vertix(long i){
			this.i = i ;
			this.neighbours = new ArrayList<Vertix> () ;
			this.parent = null ;
			depth =-1;
			this.child = null ;
		}
	}

	public static class pair implements Comparable<pair> {
		int value ; 
		int i ; 




		public pair(int x, int y ){

			this.value=x ; 
			this.i =y ;


		}


		@Override
		public int compareTo(pair p) {
			if(this.value > p.value)
				return 1 ; 
			else if (this.value == p.value) 
				return 0 ; 
			else 
				return -1 ;
		}




	}

	public static class pair2 implements Comparable<pair2>{
		int i ; 
		int j ;
		int plus ;

		public pair2(int i , int j , int plus){
			this.i =i ;
			this.j = j ; 
			this.plus = plus ;
		}

		@Override
		public int compareTo(pair2 p) {
			if(this.j > p.j)
				return 1 ; 
			else if (this.j == p.j) return 0 ;
			else 
				return -1 ;
		}


	}
	public static class point implements  Comparable<point>
	{
		int x, y ; 
		public point(int x,int y){
			this.x=x ; this.y=y;
		}
		@Override
		public boolean equals(Object o) {

			// If the object is compared with itself then return true  
			if (o == this) {
				return true;
			}

			/* Check if o is an instance of Complex or not
	          "null instanceof [type]" also returns false */
			if (!(o instanceof point)) {
				return false;
			}

			// typecast o to Complex so that we can compare data members 
			point c = (point) o;

			// Compare the data members and return accordingly 
			return Integer.compare(x, c.x) == 0
					&& Integer.compare(y, c.y) == 0;
		}
		@Override
		public int compareTo(point p) {
			if(this.x == p.x && this.y ==p.y)
				return 0 ; 
			else
				return -1 ; 
		}

		@Override
		public int hashCode()
		{
			return 15+x+(y%2) ;
		}



	}


}