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:
// Importing all important imports
 
import java.awt.Point;
import static java.lang.System.in;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.InputMismatchException;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.Queue;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.Set;
import java.util.SortedSet;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Vector;
 
 
 
/**
@author
* 
$$\      $$\                       $$\                $$$$$$\            
$$$\    $$$ |                      $$ |              $$  __$$\           
$$$$\  $$$$ |$$\   $$\  $$$$$$$\ $$$$$$\    $$$$$$\  $$ /  \__| $$$$$$\  
$$\$$\$$ $$ |$$ |  $$ |$$  _____|\_$$  _|   \____$$\ $$$$\      \____$$\ 
$$ \$$$  $$ |$$ |  $$ |\$$$$$$\    $$ |     $$$$$$$ |$$  _|     $$$$$$$ |
$$ |\$  /$$ |$$ |  $$ | \____$$\   $$ |$$\ $$  __$$ |$$ |      $$  __$$ |
$$ | \_/ $$ |\$$$$$$  |$$$$$$$  |  \$$$$  |\$$$$$$$ |$$ |      \$$$$$$$ |
\__|     \__| \______/ \_______/    \____/  \_______|\__|       \_______|
* 
*/
public class Main{
        
        static boolean testcase=false;
        public int mod=1000000007;
        
        public void solve() throws IOException
        {   
			char s[]=ns().toCharArray();
			ArrayList<Integer> data=new ArrayList<Integer>();
			int n=s.length;
			for(int i=0;i<n;i++){
				if(s[i]<='9')data.add(s[i]-48);
				else if(s[i]>='A' && s[i]<='Z')data.add(s[i]-55);
				else if(s[i]>='a' && s[i]<='z')data.add(s[i]-61);
				else if(s[i]=='-')data.add(62);
				else data.add(63);
			}
			long ans=1;
			//out.println(n);
			for(int i=0;i<n;i++){
				long temp=1;
				for(int j=0;j<6;j++){
					if((data.get(i)&(1<<j))==0)
					temp=(temp*3)%mod;
				}
				
				ans=(ans*temp)%mod;
			
			}
			out.println(ans%mod);
			
        }
        public long fastmodpow(long base,long exponent,int mod) 
{
		long result=1;
		while(exponent>0) 
		{
			if((exponent&1)==1) 
			{
			result=(result*base)%mod;
			}
			base =(base*base)%mod;
			exponent>>=1;
		}
		return result;
}
        
        public void precompute(){
		}
        
        // END OF SOLUTION
        
        
        
        // INPUT OUTPUT TEMPLATE
        static String TESTCASES="";
        static PrintWriter out;
        static int Space;
        
        public static void main(String[] args) throws Exception 
        {
               // generateTestCases(1); 
                long endTime,startTime=System.currentTimeMillis();
                out=new PrintWriter(new OutputStreamWriter(System.out));
                //mytestcases();
                InputStream myinp=TESTCASES.isEmpty() ? System.in : new ByteArrayInputStream(TESTCASES.getBytes());
                //InputStream myinp=System.in;
                init(myinp);
                
                Space=0;
                Main program=new Main();
                
                program.precompute();
                if(testcase==true){int test=ni();for(int tc=1;tc<=test;tc++)program.solve();}
                else program.solve();
                
                out.close();
                endTime=System.currentTimeMillis();
                //printTime("Time: "+(endTime-startTime)+"ms");
        }
        
         // Testcases reader from FILE. If file not found, input is taken from console.
        public static void mytestcases()
        {
            try
            {
            TESTCASES=new String(Files.readAllBytes(Paths.get("C:\\Users\\user\\Desktop\\out.txt")));
            }
            catch(Exception e){TESTCASES="";}
        }
           public static void generateTestCases(int count)
        {
            PrintStream console=System.out;
            try{
            PrintStream out = new PrintStream(new FileOutputStream("C:\\Users\\user\\Desktop\\out.txt"));
            
            System.setOut(out);
            Random r=new Random();
           // System.out.println(count);
            for(int tc=0;tc<count;tc++)
            {
                // generate
                int n=2000;
                int q=30;
                out.println(n+" "+q);
                for(int i=0;i<n;i++)
                {
                  out.print((r.nextInt(10)+1)+" ");
                }
                out.println();
                for(int i=0;i<q;i++)
                {
                    int ty=r.nextInt(4)+1;
                    //while(ty==3)ty=r.nextInt(4)+1;
                    int rr=r.nextInt(n)+1;
                    out.print(ty+" "+(r.nextInt(rr)+1)+" "+rr+" ");
                    if(ty!=4)out.print(r.nextInt(10)+1);
                    out.println();
                }
            }
            System.setOut(console);
            }
            catch(FileNotFoundException fe){System.setOut(console);}
        }
          
          
        // Just to print time, not to use anywhere else
        public static void printTime(Object ...obj){if(TESTCASES.length()!=0)System.err.println(Arrays.deepToString(obj));}
        static InputStream is;
        static BufferedReader brr;
        protected static byte[] inbuf = new byte[1024];
        static int lbuffer = 0, pbuffer = 0;
        public static void init(InputStream input) {is=input;brr=new BufferedReader(new InputStreamReader(input));}
        // Fundamental
        protected static int rb(){if(lbuffer == -1)throw new InputMismatchException();if(pbuffer >= lbuffer){pbuffer = 0;try { lbuffer = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }if(lbuffer <= 0)return -1;}return inbuf[pbuffer++];}       
        protected static String line() throws IOException{return brr.readLine();}   
        protected static boolean isSpace(int c) { return !(c >= 33 && c <= 126); }
        protected static int skip(){ int b; while((b = rb()) != -1 && isSpace(b)); return b; }
        // Inputs
        protected static double nd() throws IOException { return Double.parseDouble(ns()); }
        protected static char nc() { return (char)skip(); }
        protected static String ns() throws IOException{if(Space==1)return line();int b = skip();StringBuilder sb = new StringBuilder();while(!(isSpace(b))){ sb.appendCodePoint(b);b = rb();}return sb.toString();}
        protected static char[] nca(int n){char[] buf = new char[n];int b = skip(), p = 0;while(p < n && !(isSpace(b))){buf[p++] = (char)b;b = rb();} return n == p ? buf : Arrays.copyOf(buf, p);}
        protected static int[] nia(int n) throws IOException{int[] a = new int[n];for(int i = 0;i < n;i++)a[i] = ni();return a;}
        protected static int[][] niaindex(int n) throws IOException{int ea[][]=new int[n][2];for(int i=0;i<n;i++){ea[i][0]=ni();ea[i][1]=i;}return ea;}
        protected static long[] nla(int n) throws IOException{long[] a = new long[n];for(int i = 0;i < n;i++)a[i] = nl();return a;}
        protected static long[][] nlaindex(int n) throws IOException{long ea[][]=new long[n][2];for(int i=0;i<n;i++){ea[i][0]=ni();ea[i][1]=i;}return ea;}
        protected static String[] nsa(int n) throws IOException{String[] a = new String[n];for(int i = 0;i < n;i++)a[i] = ns();return a;    }
        protected static double[] nda(int n) throws IOException{double[] a = new double[n];for(int i = 0;i < n;i++)a[i] = nd();return a;}
        protected static int ni() throws IOException{if(Space==1)return Integer.parseInt(line());int num=0,b;boolean minus = false;while((b = rb())!= -1 && !((b>='0'&&b<='9') || b =='-'));if(b =='-'){minus=true;b = rb();    }while(true){if(b >= '0' && b <= '9'){num = num * 10 + (b - '0');}else{return minus ? -num : num;}b = rb();}}  
        protected static long nl() throws IOException{if(Space==1)return Long.parseLong(line());long num = 0;int b;boolean minus = false;while((b = rb()) != -1 && !((b >= '0' && b <= '9') || b == '-'));if(b == '-'){   minus = true;b = rb();}while(true){if(b >= '0' && b <= '9'){num = num * 10 + (b - '0');}else{return minus ? -num : num;}b = rb();}}
        // Outputs
        public static void pln(){out.println();}
        public static void ps(String s){out.print(s);}
        public static void pi(int s){out.print(s);}
        public static void pl(long s){out.print(s);}
        public static void pd(double s){out.print(s);}
        public static void psp(){out.print(" ");}
        public static void parr(int s[]){out.println(Arrays.toString(s));}
        public static void parr(String s[]){out.println(Arrays.toString(s));}
        public static void parr(long s[]){out.println(Arrays.toString(s));}        
        public static void parr2(int s[][]){for(int i=0;i<s.length;i++)out.println(Arrays.toString(s[i]));}
        public static void parr2(long s[][]){for(int i=0;i<s.length;i++)out.println(Arrays.toString(s[i]));}
        public static void parr2(String s[][]){for(int i=0;i<s.length;i++)out.println(Arrays.toString(s[i]));}
        
        
}