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


public class Label {
	
	public static void main(String[] args) throws java.lang.Exception {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(in, out);
		out.close();
	}
}

class TaskA {
	static final int mod = (int)(1e9+7);
	
	int getId(char c) {
		if (Character.isDigit(c))
			return c - '0';
		if (Character.isUpperCase(c))
			return c - 'A' + 10;
		if (Character.isLowerCase(c))
			return c - 'a' + 36;
		if (c == '-')
			return 62;
		return 63;
	}
	
	int getBits(int x) {
		int ret = 0;
		
		while (x > 0) {
			ret += x & 1;
			x >>= 1;
		}
		
		return ret;
	}
	
	long Pow(long base, long n) {
		long ret = 1;
		
		while (n > 0) {
			if ((n & 1) > 0)
				ret = ret * base % mod;
			base = base * base % mod;
			n >>= 1;
		}
		
		return ret;
	}
	
	long Inv(long x) {
		return Pow(x, mod-2);
	}
	
	public void solve(InputReader in, PrintWriter out) {
		String s = in.next();
		int[] bits = new int[64];
		
		for (int i=0; i<64; ++i)
			bits[i] = 6 - getBits(i);
		
		int len = s.length(), id, n = 0;
		for (int i=0; i<len; ++i) {
			id = getId(s.charAt(i));
			n += bits[id];
		}
		// out.println("n = " + n);
		
		long a2 = Pow(2, n), inv2 = Inv(2);
		long pre = 1, ans = 0;
		
		for (int i=0; i<=n; ++i) {
			ans += pre * a2 % mod;
			ans %= mod;
			// out.println("pre = " + pre + ", a2 = " + a2);
			a2 = a2 * inv2 % mod;
			pre = pre * (n-i) % mod * Inv(i+1) % mod;
		}
		
		// long ans = Pow(3, n);
		out.println(ans);
	}
}

class InputReader {
	public BufferedReader reader;
	public StringTokenizer tokenizer;
	
	public InputReader(InputStream stream) {
		reader = new BufferedReader(new InputStreamReader(stream), 32768);
		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 double nextDouble() {
		return Double.parseDouble(next());
	}
}