import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

class RecycledNumbers{
	
	
	
	int getcount(int small,int large){
		int count = 0;
		for(int currnum = small; currnum < large; currnum++){
			int permut = currnum;
			int no_of_digits = 0;
			while(permut > 0){
				permut = permut/10;
				no_of_digits++;
			}
			int lastDigit = currnum % 10;
			permut = currnum / 10;
			permut = permut + lastDigit * (int)Math.pow(10, no_of_digits-1);
			while(permut != currnum){
				
				if(permut >= currnum && permut <= large){
					
					count++;
				}
				lastDigit = permut % 10;
				permut = permut / 10;
				permut = permut + lastDigit * (int)Math.pow(10, no_of_digits-1);
				
			}
			
		}
		
		return count;
	}
	
	public static void main(String args[]){
		RecycledNumbers d = new RecycledNumbers();
		
		int no_of_cases = 0;
		String input = "";
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		try{
			no_of_cases = Integer.parseInt(br.readLine());
		}
		catch(Exception e){
			System.out.println("First line is not a number");
		}
		
		for(int i=1; i <= no_of_cases;i++){
			try{
				input = br.readLine();
			}
			catch(Exception e){
				System.out.println("Number of test cases different from the number mentioned in first line");
			}
			
			System.out.print("Case #" +i+": ");
			
			StringTokenizer t =  new StringTokenizer(input);
			int small=0,large=0;
			if(t.hasMoreTokens()){
				small = Integer.parseInt(t.nextToken());
			}
			if(t.hasMoreTokens()){
				large = Integer.parseInt(t.nextToken());
			}
			System.out.println(d.getcount(small,large));
			
		}
		
		
		

	}
	
	
}
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class SpeakingTongues extends JamProblem {


    Map<Character, Character> map = new HashMap<>();

    public static void main(String[] args) throws IOException {
        SpeakingTongues p = new SpeakingTongues();
        p.prepare();
        p.go();
    }


    void prepare() {
        map.put('y', 'a');
        map.put('e', 'o');
        map.put('q', 'z');

        String[] from = new String[3];
        String[] to = new String[3];

        to[0] = "ejp mysljylc kd kxveddknmc re jsicpdrysi";
        to[1] = "rbcpc ypc rtcsra dkh wyfrepkym veddknkmkrkcd";
        to[2] = "de kr kd eoya kw aej tysr re ujdr lkgc jv";
        from[0] = "our language is impossible to understand";
        from[1] = "there are twenty six factorial possibilities";
        from[2] = "so it is okay if you want to just give up";
        for (int i = 0; i < to.length; i++) {
            char[] t = to[i].toCharArray();
            char[] f = from[i].toCharArray();
            for (int j = 0; j < f.length; j++) {
                char fc = f[j];
                char tc = t[j];
                map.put(tc, fc);
            }
        }
        for (char c = 'a'; c <= 'z'; c++) {
            if (map.containsKey(c)) {
                continue;
            }

            for (char c2 = 'a'; c2 <= 'z'; c2++) {
                if (map.containsValue(c2)) {
                    continue;
                }
                map.put(c,c2);
            }

        }

    }


    @Override
    String solveCase(JamCase jamCase) {
        StringBuilder b = new StringBuilder();
        STCase ca = (STCase) jamCase;
        char[] chars = ca.str.toCharArray();

        for (int i = 0; i < chars.length; i++) {
            char c = chars[i];
            b.append(map.get(c));

        }
        return b.toString();
    }

    @Override
    JamCase parseCase(List<String> file, int line) {
        STCase ca = new STCase();
        ca.lineCount = 1;
        ca.str = file.get(line);
        return ca;
    }
}

class STCase extends JamCase {
    String str;
}