Even if the world is full of counterfeits, I still regard it as wonderful.

Pile up herbs and incense, and arise again from the flames and ashes of its predecessor — as is known to many, the phoenix does it like this.

The phoenix has a rather long lifespan, and reincarnates itself once every a! years. Here a! denotes the factorial of integer a, that is, a! = 1 × 2 × ... × a. Specifically, 0! = 1.

Koyomi doesn't care much about this, but before he gets into another mess with oddities, he is interested in the number of times the phoenix will reincarnate in a timespan of b! years, that is, <image>. Note that when b ≥ a this value is always integer.

As the answer can be quite large, it would be enough for Koyomi just to know the last digit of the answer in decimal representation. And you're here to provide Koyomi with this knowledge.

Input

The first and only line of input contains two space-separated integers a and b (0 ≤ a ≤ b ≤ 1018).

Output

Output one line containing a single decimal digit — the last digit of the value that interests Koyomi.

Examples

Input

2 4


Output

2


Input

0 10


Output

0


Input

107 109


Output

2

Note

In the first example, the last digit of <image> is 2;

In the second example, the last digit of <image> is 0;

In the third example, the last digit of <image> is 2.
    import java.io.*;
    import java.math.BigInteger;
    import java.math.RoundingMode;
    import java.text.DecimalFormat;
    import java.util.*;
    
    
   public class some {
    
        static double eps=(double)1e-6;
        static long mod=(int)1e9+7;
        static long d,x,y;
        static long  phi[],sumOfGCD[];
        public static void main(String args[]){
            InputReader sc = new InputReader(System.in);
            OutputStream outputStream = System.out;
            PrintWriter out = new PrintWriter(outputStream);
            //---Code Begins Here--------
            long a = sc.nextLong();
            long b = sc.nextLong();
            
            if(b-a >= 10)
            	out.println(0);
            else if(a == b)
            	out.println(1);
            else
            {
            	a++;
            	long c = a%10;
            	while(a<b)
            	{
            		a++;
            		c = (c*a%10)%10;
            	}
            	out.println(c);
            }
            
            //---The End-----------------
            out.close();
        }
        static long cal2(int[] arr, long sum)
        {
        	long val = sum;
        	for(int i = 0; i <arr.length; i++)
        	{
        		if(val<=0)
        		{
        			sum += val;
        			return sum;
        		}
        		else
        		{
        			val = val - arr[i];
        		}
        	}
        	return sum;
        }
        
        static long count_one (long n)
        {
        	long count=0;
            while(n>0 )
            {
            n = n&(n-1);
               count++;
            }
            return count;
    }
        
        static long[] cal(int[] arr)
        {
        	long[] brr = new long[3];
        	long max_so_far = 0, max_ending_here = 0, index=0, pre=0;
        	for(int i=0; i<arr.length; i++)
        	{
        		max_ending_here = max_ending_here + arr[i];
        		if(max_ending_here < 0)
        		{
        			max_ending_here = 0;
        			pre = i;
        		}
        		
        		if(max_ending_here > max_so_far)
        		{
        			max_so_far = max_ending_here;
        			index = i;
        		}
        	}
        	brr[0] = max_so_far;
        	brr[1] = index;
        	brr[2] = pre;
        	return brr;
        }
        
        static long modInverse(long A,long M)
		{
		    return modularExpon(A,M-2,M);
		}
        static long modularExpon(long x,long n,long M)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result * x)%M;
		        x=(x*x)%M;
		        n=n/2;
		    }
		    return result%M;
		}
        static long[] dp = new long[10000001];
        
        static long[] initdp(long[] dp)
        {
        	for(int i=0; i<dp.length; i++)
        		dp[i] = -1;
        	return dp;
        }
        
        static long comb(long ans, long x, long mod)
        {
        	//System.out.println("x = " + x);
        	
        	if(x==0)
        	{
        		dp[(int)x]=1;
        		return 1;
        	}
        	
        	if(x<0 || x>ans)
        		return 0;
 
        	if(x>(ans-(ans/2)))
        		return comb(ans,ans-x,mod);
        	
        	if(dp[(int)x]!=-1)
        		return dp[(int)x];
        	
        	dp[(int)x] = (((ans-x+1+mod)%mod * comb(ans, x-1, mod)%mod)%mod * modInverse(x, mod)%mod)%mod;
        	return dp[(int)x];
        }
        
        
        private static long fact(long count) {
            long ans=1;
            for(int i=2;i<=count;i++)
                ans*=i;
            return ans;
        }
        static int[] spf(int n)
        {
            int spf[] = new int[n+1];
            Arrays.fill(spf,0);
            spf[1] = 1;
         
            for (int i = 2; i <= n; i++)
            {
                if (spf[i] == 0)
                {
                    spf[i] = i;
                    for (int j = 2*i; j <= n; j += i)
                        if (spf[j] == 0)
                           spf[j] = i;
                    
                }  
            }
            return spf;
        }
        
        static int[] sieve(int n)
            {
                int prime[] = new int[n+1];
                for(int i=0;i<n;i++)
                    prime[i] = 1;
                prime[0]=0;
                prime[1]=0;
                for(int p = 2; p*p <=n; p++)
                {
                    // If prime[p] is not changed, then it is a prime
                    if(prime[p] == 1)
                    {
                        // Update all multiples of p
                        for(int i = p*2; i <= n; i += p)
                            prime[i] = 0;
                    }
                
                }
                return prime;
            }
        
        
        public static void computeTotient(int n)
        {
            phi = new long[n+1];
            for (int i=1; i<=n; i++)
                phi[i] = i;
         
            for (int p=2; p<=n; p++)
            {
                // If phi[p] is not computed already,
                // then number p is prime
                if (phi[p] == p)
                {
                    // Phi of a prime number p is
                    // always equal to p-1.
                    phi[p] = p-1;
         
                    // Update phi values of all
                    // multiples of p
                    for (int i = 2*p; i<=n; i += p)
                    {
                       // Add contribution of p to its
                       // multiple i by multiplying with
                       // (1 - 1/p)
                       phi[i] = (phi[i]/p) * (p-1);
                    }
                }
            }
        }
        public static void sumOfGcdPairs(int MAX)
        {
            computeTotient(MAX);
            sumOfGCD = new long[MAX];
            for (int i=1; i<MAX; ++i)
            {
                // Iterate throght all the divisors
                // of i.
                for (int j=2; i*j<MAX; ++j)
                     sumOfGCD[i*j] += i*phi[j];
            }
         
            for (int i=2; i<MAX; i++)
                 sumOfGCD[i] +=  sumOfGCD[i-1];
        }
        
        static void extendedEuclid(long A, long B) {
            if(B == 0) {
                d = A;
                x = 1;
                y = 0;
            }
            else {
                extendedEuclid(B, A%B);
                long temp = x;
                x = y;
                y = temp - (A/B)*y;
            }
        }

        static int power(int x,int n)
        {
            if(n==0)
                return 1;
            else if(n%2 == 0)        //n is even
                return power(x*x,n/2);
            else                             //n is odd
                return x*power(x*x,(n-1)/2);
        }
         static long ce(long x)
            {
                if(x%2!=0)
                    return x/2+1;
                return x/2;
            }
        static boolean isSubSequence(String str1, String str2, int m, int n)
        {
           int j = 0;
           for (int i=0; i<n&&j<m; i++)
               if (str1.charAt(j) == str2.charAt(i))
                 j++;
         
           return (j==m);
        }
            
        static long fibo(long l) {
            if (l < 0) {
                throw new IllegalArgumentException("The fibo value cannot be negative");
            }
    
            if (l <= 1) return l;
    
            long[][] result = {{1, 0}, {0, 1}}; // identity matrix.
            long[][] fiboM = {{1, 1}, {1, 0}};
    
            while (l > 0) {
                if (l%2 == 1) {
                    multMatrix(result, fiboM);
                }
                l = l / 2;
                multMatrix(fiboM, fiboM);
            }
    
            return result[1][0];
        }
    
        private static void multMatrix(long[][] result, long[][] fiboM) {
            long a = (result[0][0]%mod * fiboM[0][0]%mod)%mod +  (result[0][1]%mod * fiboM[1][0]%mod)%mod;
            long b = (result[0][0]%mod * fiboM[0][1]%mod)%mod + ( result[0][1]%mod * fiboM[1][1]%mod)%mod;
            long c = (result[1][0]%mod * fiboM[0][0]%mod)%mod + ( result[1][1]%mod * fiboM[0][1]%mod)%mod;
            long d = (result[1][0]%mod * fiboM[0][1]%mod)%mod +  (result[1][1]%mod * fiboM[1][1]%mod)%mod;
    
            result[0][0] = a;
            result[0][1] = b;
            result[1][0] = c;
            result[1][1] = d;
        }
        
        
        static boolean isPal(String s)
        {
            for(int i=0, j=s.length()-1;i<=j;i++,j--)
            {
                if(s.charAt(i)!=s.charAt(j)) return false;
            }
            return true;
        }
        public static String rev(String s)
        {
            StringBuilder sb=new StringBuilder(s);
            sb.reverse();
            return sb.toString();
        }
            
        static long lcm(long a, long b)
        {
            return a * (b / gcd(a, b));
        }
        
        static long gcd(long a, long b)
        {
            while (b > 0)
            {
                long temp = b;
                b = a % b; // % is remainder
                a = temp;
            }
            return a;
        }
        static long modulo(long a,long b,long c) {
            long x=1;
            long y=a;
            while(b > 0){
                if(b%2 == 1){
                    x=(x*y)%c;
                }
                y = (y*y)%c; // squaring the base
                b /= 2;
            }
            return  x%c;
        }
        
        static int mergeSort(int arr[], int array_size)
        {
            int temp[] = new int[array_size];
            return _mergeSort(arr, temp, 0, array_size - 1);
        }
          
        /* An auxiliary recursive method that sorts the input array and
          returns the number of inversions in the array. */
        static int _mergeSort(int arr[], int temp[], int left, int right)
        {
          int mid, inv_count = 0;
          if (right > left)
          {
            /* Divide the array into two parts and call _mergeSortAndCountInv()
               for each of the parts */
            mid = (right + left)/2;
          
            /* Inversion count will be sum of inversions in left-part, right-part
              and number of inversions in merging */
            inv_count  = _mergeSort(arr, temp, left, mid);
            inv_count += _mergeSort(arr, temp, mid+1, right);
          
            /*Merge the two parts*/
            inv_count += merge(arr, temp, left, mid+1, right);
          }
          return inv_count;
        }
          
        /* This method merges two sorted arrays and returns inversion count in
           the arrays.*/
        static int merge(int arr[], int temp[], int left, int mid, int right)
        {
          int i, j, k;
          int inv_count = 0;
          
          i = left; /* i is index for left subarray*/
          j = mid;  /* j is index for right subarray*/
          k = left; /* k is index for resultant merged subarray*/
          while ((i <= mid - 1) && (j <= right))
          {
            if (arr[i] <= arr[j])
            {
              temp[k++] = arr[i++];
            }
            else
            {
              temp[k++] = arr[j++];
          
             /*this is tricky -- see above explanation/diagram for merge()*/
              inv_count = inv_count + (mid - i);
            }
          }
          
          /* Copy the remaining elements of left subarray
           (if there are any) to temp*/
          while (i <= mid - 1)
            temp[k++] = arr[i++];
          
          /* Copy the remaining elements of right subarray
           (if there are any) to temp*/
          while (j <= right)
            temp[k++] = arr[j++];
          
          /*Copy back the merged elements to original array*/
          for (i=left; i <= right; i++)
            arr[i] = temp[i];
          
          return inv_count;
        }
        
        
        
        
        public static void debug(Object... o) {
            System.out.println(Arrays.deepToString(o));
        }
        
        
        
        
        static class Pair implements Comparable<Pair>{
            int x;
            int y;
            Pair(int l,int i){
                x=l;
                y=i;
            }
            
            @Override
            public int compareTo(Pair o) {
                return Integer.compare(this.x, o.x);
            }
        }
    
        static class InputReader {
            public BufferedReader reader;
            public StringTokenizer tokenizer;
    
            public InputReader(InputStream inputstream) {
                reader = new BufferedReader(new InputStreamReader(inputstream));
                tokenizer = null;
            }
    
            public String nextLine(){
                String fullLine=null;
                while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                    try {
                        fullLine=reader.readLine();
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                    return fullLine;
                }
                return fullLine;
            }
            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 long nextLong() {
                return Long.parseLong(next());
            }
            public int nextInt() {
                return Integer.parseInt(next());
            }
        }
        
    }
