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:

import java.util.*;
import java.util.LinkedList;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class tmp {
    public static void main(String [] args) throws Exception{
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(in.readLine());
        StringBuilder sb = new StringBuilder();
        
        
        HashMap<Integer, Integer> map = new HashMap();

        String s = st.nextToken();
        char c;
        int bit = 0, comp = 63, comb=0;
        long out = 1,tmp=0;
        int mod = 1000000007;
        for(int i=0; i< s.length(); i++){
            c = s.charAt(i);
            if(c >= '0' && c<='9'){
                bit = c - '0';
            }else if(c >= 'A' && c <= 'Z'){
                bit = c - 'A' + 10;
            }else if(c >= 'a' && c <= 'z'){
                bit = c - 'a' + 36;
            }else if(c == '-'){
                bit = 62;
            }else
                bit = 63;
            

            comb = Integer.bitCount(bit^comp);

            
            tmp = (long)Math.pow(3, comb);
            out = (out*tmp)%mod;
        }
         
        System.out.println(out);
            
        
        
        
        
        
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
    }
    
    public static long maxarea(int [] hor, int [] ver){
        int maxh = 0,tmp=1;
        for(int i=1; i<hor.length; i++){
            if(hor[i] == 0)
                tmp++;
            else{
                maxh = maxh < tmp ? tmp : maxh;
                tmp = 1;
            }
        }
        
        int maxw = 0;
        tmp=1;
        for(int i=1; i<ver.length; i++){
            if(ver[i] == 0)
                tmp++;
            else{
                maxw = maxw < tmp ? tmp : maxw;
                tmp = 1;
            }
        }

        return 1l*maxh*maxw;
        
    }

    static void add(TreeMap<Integer, Integer> map, int x, int v){
        if(!map.containsKey(x)) 
            map.put(x, 0);
        map.put(x, map.get(x)+v);
        if(map.get(x) == 0) 
            map.remove(x);
    }
    
    
    
    
    

	public static void mergeSort(int [ ] a)
	{
		int[] tmp = new int[a.length];
		mergeSort(a, tmp,  0,  a.length - 1);
	}


	private static void mergeSort(int [ ] a, int [ ] tmp, int left, int right)
	{
		if( left < right )
		{
			int center = (left + right) / 2;
			mergeSort(a, tmp, left, center);
			mergeSort(a, tmp, center + 1, right);
			merge(a, tmp, left, center + 1, right);
		}
	}


    private static void merge(int[ ] a, int[ ] tmp, int left, int right, int rightEnd )
    {
        int leftEnd = right - 1;
        int k = left;
        int num = rightEnd - left + 1;

        while(left <= leftEnd && right <= rightEnd)
            if(a[left] <= a[right])
                tmp[k++] = a[left++];
            else
                tmp[k++] = a[right++];

        while(left <= leftEnd)    // Copy rest of first half
            tmp[k++] = a[left++];

        while(right <= rightEnd)  // Copy rest of right half
            tmp[k++] = a[right++];

        // Copy tmp back
        for(int i = 0; i < num; i++, rightEnd--)
            a[rightEnd] = tmp[rightEnd];
    }
    
    
    
    
    


    
    
    
    
}

class Pair implements Comparable<Pair>{
    int x,h;
    
    public Pair(int fi, int ti){
        x = fi;
        h = ti;
    }
    
    public int compareTo(Pair p){
        return x < p.x ? -1 : (x == p.x ? (h < p.h ? -1 : 1) : 1);
    }
}