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.*;
import java.util.*;

class CodejamC {
    public static int power[];
    public static void main (String [] args) throws IOException {
        BufferedReader in = new BufferedReader(new FileReader("E:/C-small-attempt0.in"));
        PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("E:/outC.txt")));
        int nTest = Integer.parseInt(in.readLine());
        power = new int[10];
        power[0] = 1;
        for (int i = 1; i < power.length; i++) {
            power[i] = power[i-1] * 10;
        }
        for (int testIndex = 0; testIndex < nTest; testIndex++) {
            out.print("Case #" + (testIndex + 1) + ": ");
            /***** start **********/
            StringTokenizer st = new StringTokenizer(in.readLine());
            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            long result = 0;
            for (int p = a; p <= b; p++) {
                int len = getLen(p);
                int q = p;
                for (int offset = 1; offset < len; offset++) {
                    int t = q * 10;
                    q = t % power[len] + t / power[len];
                    if (q == p) {
                        break;
                    }
                    if (q <= b && q > p) {
                        result++;
                    }
                }
            }
            out.print(result);
            /***** end   **********/
            out.println();
        }
        out.close();
    }
    public static int getLen(long l) {
        for (int i = 1; i < 10; i++) {
            if (l < power[i]) {
                return i;
            }
        }
        return -1;
    }
    public static int itoa(int a, char[] s) {
        int len = 0;
        while (a > 0) {
            s[len] = (char) (a % 10 + '0');
            a /= 10;
            len++;
        }
        return len;
    }
    /*
     * for (int i = lenCurrent - 1; i >= 0; i--) {
                        int shiftIndex = i + offset;
                        if (shiftIndex >= lenCurrent) {
                            shiftIndex -= lenCurrent;
                        }
                        if (lenMax <= lenCurrent && current[shiftIndex] > max[i]) {
                            continue;
                        }
                    }
                    for (int i = lenCurrent - 1; i >= 0; i--) {
                        int shiftIndex = i + offset;
                        if (shiftIndex >= lenCurrent) {
                            shiftIndex -= lenCurrent;
                        }
                        if (lenMax <= lenCurrent && current[shiftIndex] > max[i]) {
                            continue;
                        }
                        if (current[shiftIndex] > current[i]) {
                            ok = true;
                            break;
                        } else if (current[shiftIndex] < current[i]) {
                            break;
                        }
                    }
                    if (ok) {
                        result++;
                    }
                    
                    for (int i = lenCurrent - 1; i >= 0; i--) {
                        int shiftIndex = i + offset;
                        if (shiftIndex >= lenCurrent) {
                            shiftIndex -= lenCurrent;
                        }
                        if (lenMax <= lenCurrent && current[shiftIndex] > max[i]) {
                            continue;
                        }
                    }
                    for (int i = lenCurrent - 1; i >= 0; i--) {
                        int shiftIndex = i + offset;
                        if (shiftIndex >= lenCurrent) {
                            shiftIndex -= lenCurrent;
                        }
                        if (lenMax <= lenCurrent && current[shiftIndex] > max[i]) {
                            continue;
                        }
                        if (current[shiftIndex] > current[i]) {
                            ok = true;
                            break;
                        } else if (current[shiftIndex] < current[i]) {
                            break;
                        }
                    }
                    if (ok) {
                        result++;
                    }
                    */
}