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.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;

import static java.lang.Math.*;

public class Main {


	public static void solve(FastScanner fscan, BufferedWriter bw) throws IOException {
		final int MOD = 1000000007;

		int charMap[] = new int[256];
		int idx = 0;
		for (int i = 0; i < 10; ++i) {
			charMap['0' + i] = zeroBitCount(0xffffffc0 | (idx++)); 
		}
		for (int i = 0; i < 26; i++) {
			charMap['A'+ i] = zeroBitCount(0xffffffc0 | idx);
			charMap['a'+ i] = zeroBitCount(0xffffffc0 | (idx+26));
			idx++;
		}
		charMap['-'] = zeroBitCount(0xffffffc0 | 62);
		charMap['_'] = zeroBitCount(0xffffffc0 | 63);
		
		
		String in = fscan.nextString();
		int zeroCount = 0;
		for (int i = 0; i < in.length(); i++) {
			zeroCount += charMap[in.charAt(i)];
		}
		
		long ans = 1;
		for (int i = 0; i < zeroCount; i++) {
			ans = ans * 3 % MOD;
		}
		
		bw.append(String.valueOf(ans));
	}
	
	public static int zeroBitCount(int x) 
	{
		//brute
//		int counter = 0;
//		for (int i = 0; i < 32; i++) {
//			counter += 1 - (x & 0x01);
//			x >>>= 1;
//		}
//		return counter;
		
//		return 32 - hammingWeight(x);
		
		return 32 - Integer.bitCount(x);
	
	}

	static int hammingWeight(int x)
	{
		//Hacker's Delight, p. 66, Figure 5-2
		x = x - ((x >> 1) & 0x55555555);
	    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
	    x = (x + (x >> 4)) & 0x0F0F0F0F;
	    x = x + (x >> 8);
	    x = x + (x >> 16);
	    return x & 0x0000003F;
	}
	/**************** ENTER HERE   ********************/
	public static void main(String[] args) throws Exception {
		
		if(args.length != 0){
			test();
			return;
		}
		
		FastScanner fscan = new FastScanner(System.in);
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		solve(fscan,bw);
		bw.close();
	}
	
	/****   Test Static test cases      **/
	public static void test() throws IOException{
		String testcase[] = new String[]{};
		String answer[] = new String[]{};
		
		for (int i = 0; i < testcase.length; i++) {
			ByteArrayOutputStream result = new ByteArrayOutputStream();
			FastScanner fscan = new FastScanner(new ByteArrayInputStream(testcase[i].getBytes()));
			BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(result));
			
			solve(fscan, bw);
			
			String r = new String(result.toByteArray());
			if(! r.equals(answer[i])){
				String q = testcase[i];
				String a = answer[i];

				System.err.println("Wrong Answer on test:"+(i+1));
				System.err.println("Q:"+q);
				System.err.println("A:"+a);
				System.err.println("R:"+r);
			}
			
		}

	}
}






class IO {
	public static void readIntArray(int a[], int N, FastScanner fscan)
			throws IOException {
		readIntArray(a, N, 0, fscan);
	}

	public static void readIntArray(int a[], int N, int start, FastScanner fscan)
			throws IOException {
		for (int i = 0; i < N; i++) {
			a[start + i] = fscan.nextInt();
		}
	}

	public static void readArray(long a[], int N, FastScanner fscan)
			throws IOException {
		readArray(a, N, 0, fscan);
	}

	public static void readArray(long a[], int N, int start, FastScanner fscan)
			throws IOException {
		for (int i = 0; i < N; i++) {
			a[start + i] = fscan.nextInt();
		}
	}
}

class FastScanner {
	InputStream is;
	byte buff[] = new byte[1024];
	int currentChar = -1;
	int buffChars = 0;

	public FastScanner(InputStream inputStream) {
		is = inputStream;
	}

	public boolean hasNext() throws IOException {
		return currentChar == -1 || buffChars > 0;
	}

	public char nextChar() throws IOException {
		// if we already have that next char read, just return else input
		if (currentChar == -1 || currentChar >= buffChars) {
			currentChar = 0;
			buffChars = is.read(buff);
		}

		if (buffChars <= 0) {
			throw new RuntimeException("No char found...");
		}

		int ch;
		while (isSpace(ch = nextCharAsInt()))
			;
		return (char) ch;
	}

	public int nextCharAsInt() throws IOException {
		// if we already have that next char read, just return else input
		if (currentChar == -1 || currentChar >= buffChars) {
			currentChar = 0;
			buffChars = is.read(buff);
		}

		if (buffChars <= 0) {
			return -1;
		}
		return (char) buff[currentChar++];
	}

	public String nextLine() throws IOException {
		StringBuilder bldr = new StringBuilder();
		int ch;
		while (isLineEnd(ch = nextCharAsInt()))
			// ignore empty lines ???
			;

		do {
			bldr.append((char) ch);
		} while (!isLineEnd(ch = nextCharAsInt()));

		return bldr.toString();
	}

	public String nextString() throws IOException {
		StringBuilder bldr = new StringBuilder();
		int ch;
		while (isSpace(ch = nextCharAsInt()))
			;

		do {
			bldr.append((char) ch);
		} while (!isSpace(ch = nextCharAsInt()));

		return bldr.toString();
	}

	public int nextInt() throws IOException {
		// considering ASCII files--> 8 bit chars, unicode files has 16 bit
		// chars (byte1 then byte2)
		int result = 0;
		int sign = 1;
		int ch;
		while (isSpace(ch = nextCharAsInt()))
			;

		if (ch == '-') {
			sign = -1;
			ch = nextCharAsInt();
		}

		do {
			if (ch < '0' || ch > '9')
				throw new NumberFormatException("Found '" + ch
						+ "' while parsing for int.");

			result *= 10;
			result += ch - '0';
		} while (!isSpace(ch = nextCharAsInt()));

		return sign * result;
	}

	public long nextLong() throws IOException {
		// considering ASCII files--> 8 bit chars, unicode files has 16 bit
		// chars (byte1 then byte2)
		long result = 0;
		int sign = 1;
		int ch;
		while (isSpace(ch = nextCharAsInt()))
			;

		if (ch == '-') {
			sign = -1;
			ch = nextCharAsInt();
		}

		do {
			if (ch < '0' || ch > '9')
				throw new NumberFormatException("Found '" + ch
						+ "' while parsing for int.");

			result *= 10;
			result += ch - '0';
		} while (!isSpace(ch = nextCharAsInt()));

		return sign * result;
	}

	private boolean isLineEnd(int ch) {
		return ch == '\n' || ch == '\r' || ch == -1;
	}

	private boolean isSpace(int ch) {
		return ch == '\n' || ch == ' ' || ch == '\t' || ch == '\r' || ch == -1;
	}

	public void close() throws IOException {
		is.close();
	}
}