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.Scanner;

class RecycledNumbers {

    Scanner s = new Scanner(System.in);

    public static void main(String args[]) {
	    RecycledNumbers p = new RecycledNumbers();
	    p.run();
	}
	
	void run() {
	    int nCases = s.nextInt();
		for (int i=0; i<nCases; i++) {
		    int A = s.nextInt();
			int B = s.nextInt();
			System.out.println("Case #"+(i+1)+": "+count(A, B));
		}
	}

    int count(int A, int B) {
	    boolean[] dids = new boolean[B-A+1];
        int count = 0;
		int rotates = Integer.toString(A).length() - 1;
		int level = (int) Math.pow(10, rotates);

	    for (int i=A; i<B; i++) {
		    if (dids[i-A]) continue;
			int possibility = countPossibility(i, A, B, rotates, level, dids);
            if (possibility>1) count+=(possibility *(possibility-1)) / 2;			
		}
		return count;
	}

	int countPossibility(int v, int A, int B, int rotates, int level, boolean[] dids) {
	    int count = 1;
		dids[v-A] = true;
		
        for (int i=0; i<rotates; i++) {
		    int leftMost= v / level;
			v = (v % level) * 10 + leftMost;
			if (v<A || v>B) continue;
			if (dids[v-A]) continue;
			dids[v-A] = true;
			count++;
		}
    	return count;
	}
}