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.util.*; 
        import java.math.*;
        import java.io.*;
        import java.text.DecimalFormat;
        import java.math.BigInteger;
        public class Main{
            static int d=20,n;
            static int mod=1000000007 ;
            static HashMap<String,Integer> hm=new HashMap<>(); 
            public static void main(String[] args)  throws IOException {
                s.init(System.in);   
                
                PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
                String x=s.ns();
            

                int[] count=new int[1000];
                for(int i=0;i<=63;i++){
                    for(int j=0;j<=63;j++){
                        
                        count[i&j]++;}
                }
                
                int n=x.length();
                long ans=1;
                for(int i=0;i<n;i++){
                    String a="";
                    char ch=x.charAt(i);
                    if(ch>='0'  && ch<='9')
                        a+=ch-'0';
                    else if(ch>='A' && ch<='Z')
                        a+=ch-'A'+10;
                    else if(ch>='a' && ch<='z')
                        a+=ch-'a'+36;
                    else if(ch=='-')
                        a+=62;
                    else
                        a+=63;
                    ans=ans*count[Integer.parseInt(a)];
                    ans%=mod;
                }
                out.println(ans%mod);
                out.close();
            }
            public static long gcd(long a, long b){
                   if(a%b==0)
                        return b;
                    else
                        return gcd(b,a%b);
            }
                
 
            static class party implements Comparable<party>{
                int size;
                int id;
                public party(int x,int y){
                    id=x;
                    size=y;
                }
                public  int compareTo(party o){
                    return o.size-size;
                }
            }
               
            public static class s {
                static BufferedReader reader;
                static StringTokenizer tokenizer;
         
                /** call this method to initialize reader for InputStream */
                static void init(InputStream input) {
                    reader = new BufferedReader(
                                new InputStreamReader(input) );
                    tokenizer = new StringTokenizer("");
                }   
         
                /** get next word */
                static String ns() throws IOException {
                    while ( ! tokenizer.hasMoreTokens() ) {
                        //TODO add check for eof if necessary
                        tokenizer = new StringTokenizer(
                            reader.readLine() );
                    }
                    return tokenizer.nextToken();
                }
         
                static int ni() throws IOException {
                    return Integer.parseInt( ns() );
                }
            
                static double nd() throws IOException {
                    return Double.parseDouble( ns() );
                }
                static long nl() throws IOException {
                    return Long.parseLong( ns() );
                }
                
            }
        }       