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.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author Hossam Yasseen
 */
public class ProblemC {

	/**
	 * @param args
	 */
	static Integer startEdge , endEdge ;
	
	public static void main(String[] args) {
		
		int numberOfRecycledNumbers = 0;

		String[] result = null ;
		for (int counter0 = 1; counter0 < args.length; counter0++) {
			result = args[counter0].split("\\s");
			startEdge = Integer.parseInt(result[0]);
			endEdge = Integer.parseInt(result[1]);
			numberOfRecycledNumbers=0 ;
			
			for (int counterA = startEdge; counterA < endEdge; counterA++) {
				List<Integer> recycledNumber = recycledNumbers(counterA);
				for (int counter = 0; counter < recycledNumber.size(); counter++) {
					if (recycledNumber.get(counter) <= endEdge )
						numberOfRecycledNumbers++;
				}
			}
			System.out.println("Case #" + counter0 + ": "
					+ numberOfRecycledNumbers);
		}
	}

	private static List<Integer> recycledNumbers(Integer number) {

		Map<Integer,String> map = new HashMap<Integer, String>();
		String dummyValue = null ;
		String candidateNumber = "";

		char[] characters = number.toString().toCharArray();

		int index;
		for (int counter = 0; counter < characters.length; counter++) {
			index = counter ;
			int loops = 0 ;
			candidateNumber="";
			
			for ( ; loops < characters.length; index++) {
				candidateNumber += characters[index % characters.length];
				loops++ ;
			}
			
			if(Integer.parseInt(candidateNumber)>number.intValue())
				map.put(Integer.parseInt(candidateNumber),dummyValue);
			
		}
		
		List<Integer> recycledNumber =  new ArrayList<Integer>( map.keySet());
		return recycledNumber;
	}
}
