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.io.*;
import java.util.*;

public class Codeforces {

    public static long MOD = 1_000_000_007;

    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);

        String s = in.next();

        long res = 1;
        StringBuilder full = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            StringBuilder bin = new StringBuilder();

            char cur = s.charAt(i);
            if (cur - '0' >= 0 && cur - '0' <= 9) {
                bin.append(Integer.toBinaryString(cur - '0'));
            } else if (cur - 'A' >= 0 && cur - 'A' <= 25) {
                bin.append(Integer.toBinaryString((cur - 'A') + 10));
            } else if (cur - 'a' >= 0 && cur - 'a' <= 25) {
                bin.append(Integer.toBinaryString((cur - 'a') + 36));
            } else if (cur == '-') {
                bin.append(Integer.toBinaryString(62));
            } else {
                bin.append(Integer.toBinaryString(63));
            }

            while (bin.length() < 6) {
                bin.insert(0, '0');
            }

            full.append(bin);
        }

        for (int j = 0; j < full.length(); j++) {
            if (full.charAt(j) == '0') {
                res *= 3;
                res %= MOD;
            }
        }

        out.println(res);
        out.close();
    }

    public static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
            tokenizer = null;
        }

        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 int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int[] nextIntArr(int n) {
            int[] arr = new int[n];
            for (int j = 0; j < arr.length; j++) {
                arr[j] = nextInt();
            }

            return arr;
        }

        public long[] nextLongArr(int n) {
            long[] arr = new long[n];
            for (int j = 0; j < arr.length; j++) {
                arr[j] = nextLong();
            }

            return arr;
        }
    }
}