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
# def next_row(prev_row):
#         row = [prev_row[0]] * (len(prev_row) + 1)
#         for idx in range(len(prev_row) - 1):
#             row[idx + 1] = (prev_row[idx] + prev_row[idx + 1]) % 1000000007
#         return row
#
#
# def binomial(n, k, cache=None):
#     """
#         0             1
#         1            1 1
#         2           1 2 1
#         3          1 3 3 1
#         4         1 4 6 4 1
#     """
#     if k == 0 or k == n:
#         return 1
#     if k == 1 or k == n - 1:
#         return n
#
#     cache = cache or [[1]]
#
#     while len(cache) <= n:
#         cache.append(next_row(cache[-1]))
#
#     return cache[n][k]

# c = []
# for n in range(150):
#     for k in range(n + 1):
#         print('n={n}, k={k} -> {b}'.format(n=n, k=k, b=binomial(n, k, c)))

s = input().strip()
m = {}
for i in range(10):
    m[str(i)] = i

for i in range(ord('Z') - ord('A') + 1):
    m[chr(ord('A') + i)] = 10 + i

for i in range(ord('z') - ord('a') + 1):
    m[chr(ord('a') + i)] = 36 + i

m['-'] = 62
m['_'] = 63

zero_bits = 0
for c in s:
    n = m[c]
    for i in range(6):
        zero_bits += int(not (n & 1))
        n >>= 1

res = 1
for z in range(zero_bits):
    res = res*3 % 1000000007

# for zero_bits in range(5):
#     res = 0
#     for z in range(zero_bits + 1):
#         left_power = binomial(zero_bits, z)
#         for zz in range(zero_bits - z + 1):
#             right_power = binomial(zero_bits - z, zz)
#             res = (res + left_power*right_power) % 1000000007

print(res)
