package jp.funnything.competition.util;

import java.math.BigInteger;

/**
 * Utility for BigInteger
 */
public class BI {
    public static BigInteger ZERO = BigInteger.ZERO;
    public static BigInteger ONE = BigInteger.ONE;

    public static BigInteger add( final BigInteger x , final BigInteger y ) {
        return x.add( y );
    }

    public static BigInteger add( final BigInteger x , final long y ) {
        return add( x , v( y ) );
    }

    public static BigInteger add( final long x , final BigInteger y ) {
        return add( v( x ) , y );
    }

    public static int cmp( final BigInteger x , final BigInteger y ) {
        return x.compareTo( y );
    }

    public static int cmp( final BigInteger x , final long y ) {
        return cmp( x , v( y ) );
    }

    public static int cmp( final long x , final BigInteger y ) {
        return cmp( v( x ) , y );
    }

    public static BigInteger div( final BigInteger x , final BigInteger y ) {
        return x.divide( y );
    }

    public static BigInteger div( final BigInteger x , final long y ) {
        return div( x , v( y ) );
    }

    public static BigInteger div( final long x , final BigInteger y ) {
        return div( v( x ) , y );
    }

    public static BigInteger mod( final BigInteger x , final BigInteger y ) {
        return x.mod( y );
    }

    public static BigInteger mod( final BigInteger x , final long y ) {
        return mod( x , v( y ) );
    }

    public static BigInteger mod( final long x , final BigInteger y ) {
        return mod( v( x ) , y );
    }

    public static BigInteger mul( final BigInteger x , final BigInteger y ) {
        return x.multiply( y );
    }

    public static BigInteger mul( final BigInteger x , final long y ) {
        return mul( x , v( y ) );
    }

    public static BigInteger mul( final long x , final BigInteger y ) {
        return mul( v( x ) , y );
    }

    public static BigInteger sub( final BigInteger x , final BigInteger y ) {
        return x.subtract( y );
    }

    public static BigInteger sub( final BigInteger x , final long y ) {
        return sub( x , v( y ) );
    }

    public static BigInteger sub( final long x , final BigInteger y ) {
        return sub( v( x ) , y );
    }

    public static BigInteger v( final long value ) {
        return BigInteger.valueOf( value );
    }
}

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

public class GCJ3 {

	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		GCJ3 g = new GCJ3();

		// System.out.println();
		// long i1 = g.calculate(1, 9);
		// System.out.println();
//		 long i2 = g.calculate(10, 40);
		// System.out.println();
//		long i3 = g.calculate(100, 500);
//		long i4 = g.calculate(1111, 2222);
		
//		long i5 = g.calculate(28, 93);
		 
		// System.out.println(i1);
//		 System.out.println(i2);
//		 System.out.println(i3);
//		 System.out.println(i4);
//		System.out.println(i5);

		try {
			// Open the file that is the first
			// command line parameter
			FileInputStream fstream = new FileInputStream(
					"C:/PROG/java/work/tc/src/gcj3.txt");
			// Get the object of DataInputStream
			DataInputStream in = new DataInputStream(fstream);
			BufferedReader br = new BufferedReader(new InputStreamReader(in));
			String strLine;
			// Read File Line By Line
			int lineNum = 1;
			br.readLine();

			while ((strLine = br.readLine()) != null) {
				// Print the content on the console

//				 System.out.print(strLine+"\t");
				String[] val = strLine.split("\\s");
				System.out.print("Case #" + lineNum + ": ");
				System.out.println(g.calculate(Integer.valueOf(val[0]),
						Integer.valueOf(val[1])));
				
				
				
				
				// System.out.println();

				// System.out.println(strLine.charAt(0));
				lineNum++;
			}
			// Close the input stream
			in.close();
		} catch (Exception e) {// Catch exception if any
			e.printStackTrace();
		}

	}

	public long calculate(int A, int B) {
		
		HashMap<String,HashSet<String>> map = new HashMap<String,HashSet<String>>();

		String a = String.valueOf(A);
		String b = String.valueOf(B);
		if (a.length() == b.length() && a.length() > 1) {
			long count = 0;

			for (long i = A; i <= B; i++) {

				for (long l = 1; l < a.length(); l++) {
					long n = 0;
					long m = i;

					String nS = String.valueOf(m);

					String nS2 = nS.substring((int) l, a.length())
							+ nS.substring(0, (int) l);

					n = Long.valueOf(nS2);

					String nS3 = String.valueOf(n);

					if (n < m && nS3.length() == a.length() && A<=n && m<=B) {
//						System.out.println(n + " " + m);
						count++;
						if (map.get(nS3) == null){
							HashSet<String> s = new HashSet<String>();
							s.add(nS);
							map.put(nS3, s);
						}else {
							map.get(nS3).add(nS);
						}
					}
				}
			}
			
			long count2 = 0;
			for (String s : map.keySet()){
				
				for (Object o: map.get(s).toArray()){
					count2++;
				}
				
			}

			return count2;
		}

		return 0;
	}

}
