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.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.BitSet;
import java.util.StringTokenizer;


public class sol {
	//...................... Global Variables .......................//
	static BitSet prime;             // used in seive generation
	// true = not prime     and false = prime
	//...................... Global Variables .......................//
	
	
	
	
	
	//===================  PROBLEM SOLVING COMES HERE ===== START  ====================//
	
    void solve() throws IOException, Exception {
    	long mod = (long)1e9+7;
    	int count =0;
    	char s[] = in.next().toCharArray();
    	for(char c : s){
    		int value = 63;
    		if(c >= '0' && c <= '9') value = c - '0';
    		if(c >= 'A' && c <= 'Z') value = c - 'A' + 10;
    		if(c >= 'a' && c <= 'z') value = c - 'a' + 36;
    		if(c == '-') value = 62;
    		count += 6 - Integer.bitCount(value);
    	}
    	out.println(modPow(3l, count, mod));
    	
    	
    }
    
    //===================  PROBLEM SOLVING COMES HERE ===== END ======================//
    
    
    
    
    
    
    public static void main(String[] args) throws FileNotFoundException, IOException, Exception {
    	
    	//--------------------------------- Console I/O ------------------------------//
    	   in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
           out = new PrintWriter(System.out);
    	//--------------------------------- Console I/O ------------------------------//
    	
    	
    	//--------------------------------- File I/O ---------------------------------//
        //   in = new FastScanner(new BufferedReader(new FileReader("input.txt")));
        //   out = new PrintWriter(new FileWriter("output.txt"));
        //--------------------------------- File I/O ---------------------------------//
        new sol().solve();
        out.close();
    }
    
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Useful Methods START ~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
    
    
    //Modular Exponentiation
	    public static long modPow(long base,long power, long m)   // with mod
	    {  // long m = (long) 1e9+7;
	    	long  result = 1;
	    	if(power==0)  return 1;
	    	if(power==1)  return base;
	    	while(power>0)
	    	{
	    	    if(power%2==1)
	    	        result = (result * base) % m;
	    	    power = power >> 1;     // divide by 2
	    	    base = (base * base) % m;
	    	}
	    	return result;
	    } 
	    
	    
	 // END Modular Exponentiation 
	    
	
		
	 
    
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Useful Methods END ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//

    static FastScanner in;
    static PrintWriter out;

    static class FastScanner {
        BufferedReader in;
        StringTokenizer st;

        public FastScanner(BufferedReader in) {
            this.in = in;
        }

        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public int nextInt() { return Integer.parseInt(nextToken()); }
        public long nextLong() { return Long.parseLong(nextToken()); }
        public double nextDouble() { return Double.parseDouble(nextToken()); }
        public BigInteger BigInteger()throws Exception { return new BigInteger(nextToken()); }
        public String next() throws IOException { return nextToken(); }
        public String nextLine() throws IOException { return in.readLine(); }
        
    }
}