While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 109 + 7.

To represent the string as a number in numeral system with base 64 Vanya uses the following rules:

  * digits from '0' to '9' correspond to integers from 0 to 9; 
  * letters from 'A' to 'Z' correspond to integers from 10 to 35; 
  * letters from 'a' to 'z' correspond to integers from 36 to 61; 
  * letter '-' correspond to integer 62; 
  * letter '_' correspond to integer 63. 

Input

The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.

Output

Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 109 + 7.

Examples

Input

z


Output

3


Input

V_V


Output

9


Input

Codeforces


Output

130653412

Note

For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.

In the first sample, there are 3 possible solutions: 

  1. z&_ = 61&63 = 61 = z
  2. _&z = 63&61 = 61 = z
  3. z&z = 61&61 = 61 = z


import java.io.BufferedReader;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;


import java.util.*;
import java.util.stream.IntStream;
public class random_num {
public static long m=(long) (Math.pow(10,9)+7);
	public static void main(String args[]){
		InputReader s= new InputReader(System.in);
		OutputStream outputStream= System.out;
		PrintWriter out= new PrintWriter(outputStream);
		String str=s.nextLine();
		int a[]=new int[str.length()];
		for(int i=0;i<str.length();i++){
			if(str.charAt(i)>='0' && str.charAt(i)<='9'){
				a[i]=(int)(str.charAt(i)-'0');
			}
			if(str.charAt(i)>='A' && str.charAt(i)<='Z'){
				a[i]=10+(int)(str.charAt(i)-'A');
			}
			if(str.charAt(i)>='a' && str.charAt(i)<='z'){
				a[i]=36+(int)(str.charAt(i)-'a');
			}
			if(str.charAt(i)=='-'){
				a[i]=62;
			}
			if(str.charAt(i)=='_'){
				a[i]=63;
			}
		}
		String ar[]=new String[str.length()];
		int count=0;
		for(int i=0;i<str.length();i++){
			ar[i]=Integer.toBinaryString(a[i]);
			//System.out.println(a[i]);
			count+=6-ar[i].length();
			for(int j=0;j<ar[i].length();j++){
				if(ar[i].charAt(j)=='0'){
					count++;
				}
			}
		}
		//System.out.println(count);
		long ans=0;
		if(count==0){
			ans=1;
		}
		else{
			ans+=expo(3,count);
		}
		//System.out.println(ans);
		/*for(int i=1;i<count;i++){
			ans=(ans%m+((binomialCoeff(count,i))%m)*((expo(2,i)-1)%m)%m)%m;
			//System.out.println(ans);
		}*/
		
		System.out.println(ans);
		//out.close();
		
	}
	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());
	    }
	  }
	public static int gcd(int number1, int number2) {  
		if(number2 == 0){
			return number1;
		} 
		return gcd(number2, number1%number2); 
	}
	public static int combinations(int n,int r){
		if(n==r) return 1;
		if(r==1) return n;
		if(r==0) return 1;
		return combinations(n-1,r)+ combinations(n-1,r-1);
	}
	public static long binomialCoeff(int n, int k)
	{
	    long C[][]= new long[n+1][k+1];
	    int i, j;
	 
	    // Caculate value of Binomial Coefficient in bottom up manner
	    for (i = 0; i <= n; i++)
	    {
	        for (j = 0; j <= Math.min(i, k); j++)
	        {
	            // Base Cases
	            if (j == 0 || j == i)
	                C[i][j] = 1;
	 
	            // Calculate value using previosly stored values
	            else
	                C[i][j] = C[i-1][j-1]%m + C[i-1][j]%m;
	        }
	    }
	 
	    return C[n][k]%m;
	}
	public static long expo(long a, long b){
	    if (b==1)
	        return a%m;
	    if (b==2)
	        return ((a%m)*(a%m))%m;

	    if (b%2==0){
	            return expo(expo(a%m,(b/2)%m),2)%m;
	    }
	    else{
	        return ((a%m)*(expo(expo(a%m,((b-1)/2))%m,2)%m))%m;
	    }
	}
	
	public static void sieve(int N){
		int arr[]= new int[N+1];
		for(int i=2;i<Math.sqrt(N);i++){
			if(arr[i]==0){
				for(int j= i*i;j<= N;j= j+i){
					arr[j]=1;
				}
			}
		}
		// All the i for which arr[i]==0 are prime numbers.
	}
	static class Pair implements Comparable<Pair>
    {
        int f,s;
        Pair(int ii, int cc)
        {
            f=ii;
            s=cc;
        }
        
        public int compareTo(Pair o) 
        {
            return Integer.compare(this.f, o.f);
        }
        
    }

}