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.Scanner;

/**
 * Created by leen on 6/3/16.
 *
 * Codeforces
 */
public class MainC {

    static final long MOD = 1000000007;
    static long[] FACT = new long[1000001];
    static long[] POW = new long[1000001];

    static {
        FACT[0] = 1;
        for(int i = 1; i < FACT.length; i++)
            FACT[i] = (FACT[i - 1] * i) % MOD;

        POW[0] = 1;
        for(int i =1; i <POW.length; i++)
            POW[i] = (POW[i-1] << 1) % MOD;
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        while(scan.hasNext()) {
            int numZeros = calcNumZeros(scan.next());
            long numPairs = 0;
            for(int m = 0; m <= numZeros / 2; m++) {
                long c = C(numZeros, m);
                numPairs = (( c * POW[numZeros - m]) % MOD + numPairs) % MOD;
                if(m != numZeros -m)
                    numPairs = (( c * POW[m]) % MOD + numPairs) % MOD;
            }

            System.out.println(numPairs);
        }
    }

    static long fastPow(long base, long n) {
        if(n==0)
            return 1;
        if(n==1)
            return base;
        long halfn= fastPow(base, n / 2);
        if(n%2==0)
            return ( halfn * halfn ) % MOD;
        else
            return ( ( ( halfn * halfn ) % MOD ) * base ) % MOD;
    }

    static long findMMIFermat(long n) {
        return fastPow(n, MOD - 2);
    }

    static long C(int n, int m) {
        long numerator = FACT[n];
        long denominator = (FACT[m] * FACT[n-m]) % MOD;
        long mmi_denominator = findMMIFermat(denominator);
        return (numerator * mmi_denominator) % MOD;
    }

    static int calcNumZeros(String base64) {
        int numZeros = 0;
        for(int i = 0; i < base64.length(); i++) {
            char c = base64.charAt(i);

            int value;

            if(c == '-')
                value = 62;
            else if(c == '_')
                value = 63;
            else if(c >= 'a')
                value = (c - 'a') + 36;
            else if(c >= 'A')
                value = (c - 'A') + 10;
            else
                value = c - '0';

            for(int j = 0; j < 6; j++) {
                if((value & 0x1) == 0)
                    numZeros++;
                value >>= 1;
            }
        }
        return numZeros;
    }
}
