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

public class Recycle
{
  public static void main(String[] args)
  {
    Scanner in = new Scanner(new BufferedInputStream(System.in));
    int T = in.nextInt();
    for(int i=0; i <T;i++)
    {
      int A = in.nextInt();
      int B = in.nextInt();
      
      int x = A;
      int digits = 1;
      while(x >=10)
      {
        x = x/10;
        digits++;
      }
      //System.out.println("digits: " + digits);
      int sum = 0;
      int[] m = new int[digits-1];
      for(int k = 0; k < m.length; k++)
        m[k] = (k+1)*-1;
      
      for(int j = A; j < B; j++) 
      {
        //reset m 
        for(int k = 0; k < m.length; k++)
          m[k] = (k+1)*-1;
        
        //try every possible combination
        //count it if j < combo < B
        for(int k = 1; k < digits; k++)
        {
          int divisor = (int) Math.pow(10,k);
          int multiplier = (int)Math.pow(10,digits-k);
          int temp = (j%divisor)*multiplier + j/divisor;
          
          //if all digits the same skip
          String number = Integer.toString(temp);
          if(number.matches("^([0-9])\\1*$")) continue;
          
          if(temp > j && temp <= B) 
          {
            m[k-1] = temp;
            sum++;
          }
        }
        //if redundancy subtract
        Arrays.sort(m);
        for(int k = 1; k < m.length; k++)
          if(m[k] == m[k-1]) sum--;
      }
      System.out.printf("Case #%d: %d\n",i+1,sum);
    }
  }
}