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.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;


public class R1Q3 {
	public static HashMap<String, String> wordMap;
	
	public static void main(String []args) throws NumberFormatException, IOException{
		BufferedReader bf = new BufferedReader(new FileReader(new File("input")));
		BufferedWriter bw = new BufferedWriter(new FileWriter(new File("output")));
		int num = Integer.parseInt(bf.readLine());
		String aString = "123";
		
		for (int i = 1 ; i<=num; i++){
			int nums = 0;
			String line = bf.readLine();
			String[] argss =line.split(" ");
			int small = Integer.parseInt(argss[0]);
			int large = Integer.parseInt(argss[1]);
			HashSet<Integer> already = new HashSet<Integer>();
			for (int j = small; j< large; j++){
				if (j<10) continue;
				already.clear();
				already.add(j);
				String temp = String.valueOf(j);
				for (int k = 1; k < temp.length(); k++){
					int m = k;
					int newnum  = j/(int)(Math.pow(10, temp.length()-k));
					newnum+= (j%(int)(Math.pow(10, temp.length()-k)))*Math.pow(10, k);
					if (!already.contains(newnum)&&newnum<=large&&newnum>=small&&newnum>j){
						nums++;
						already.add(newnum);
					}
				}
				if (j == 1221) System.out.println(already.toString());
				
			}
			bw.write("Case #"+i+": "+nums+"\n");
		}
		bf.close();
		bw.close();
	}
}
