Problem: 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

Solution (in JAVA):

Solution:
/*
     * Code Author: Akshay Miterani
     * DA-IICT
     */
    import java.io.*;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;
     
     
    public class MainA {
     
    	static double eps=(double)1e-6;
    	static long mod=(int)1e9+7;
    	public static void main(String args[]){
    		InputReader in = new InputReader(System.in);
    		OutputStream outputStream = System.out;
    		PrintWriter out = new PrintWriter(outputStream);
    		//----------My Code----------
    		HashMap<Character,Long> h=new HashMap<>();
    		for(char p='0';p<='9';p++){
    			h.put(p, (long)(p-'0'));
    		}
    		for(char p='A';p<='Z';p++){
    			h.put(p, (long)(p-'A'+10));
    		}
    		for(char p='a';p<='z';p++){
    			h.put(p, (long)(p-'a'+36));
    		}
    		h.put('-', (long)62);
    		h.put('_', (long)63);
    		String s=in.nextLine();
    		long total=1;
    		for(int i=0;i<s.length();i++){
    			long ans=0;
    			long x=h.get(s.charAt(i));
    			long count=Long.bitCount(x);
    			int left=6-(int)count;
    			int ind=left;
    			int sel=0;
    			while(ind>=0){
    				ans+=(pow(2, ind, mod)*C(left, sel, mod))%mod;
    				ans%=mod;
    				ind--;
    				sel++;
    			}
    			//System.out.println(ans);
    			total*=ans%mod;
    			total%=mod;
    		}
    		out.println(total%mod);
    		out.close();
    		//---------------The End------------------
    		
    	}
    	
    	static public int f(int x,int c[],int k) {
    		int ans=0;
    		for(int i=0;i<26;i++){
    			if(c[i]==0)
    				continue;
    			if(c[i]<x){
    				ans+=(c[i]);
    			}
    			if(c[i]>x+k){
    				ans+=(c[i]-(x+k));
    			}
    		}
    		return ans;
    	}
    	
    	static long InverseEuler(long n, long MOD)
    	{
    	    return pow(n,MOD-2,MOD);
    	}
    	
    	static long C(int n, int r, long MOD)
    	{
    	    BigInteger ret=BigInteger.ONE;
    	   for(int i=0;i<r;i++){
    		   ret=ret.multiply(BigInteger.valueOf(n-i));
    	   }
    	   for(int i=0;i<r;i++){
    		   ret=ret.divide(BigInteger.valueOf(i+1));
    	   }
    	   ret=ret.mod(BigInteger.valueOf(mod));
    	   return Long.parseLong(ret.toString());
    	}
    	
    	static long pow(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;
    	    	}
    	static long gcd(long x, long y)
        {
            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 Pair implements Comparable<Pair>{
    		int x;
    		int y;
    		int i;
    		Pair(int xx,int yy){
    			x=xx;
    			y=yy;
    		}
    		@Override
    		public int compareTo(Pair o) {
    			return Integer.compare(this.x, o.x);
					
    		}
    	}
    	
    	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());
    	    }
    	  }
    }