/*
    a positive integer number is beautiful if and only if it is divisible by each of its nonzero digits.
    问一个区间内[l,r]有多少个Beautiful数字
    范围9*10^18
    
    数位统计问题，构造状态也挺难的，我想不出，我的思维局限在用递推去初始化状态，而这里的状态定义也比较难
    跟pre的具体数字有关

    问了NotOnlySuccess的，豁然开朗  Orz
    
    一个数字要被它的所有非零位整除，即被他们的LCM整除，可以存已有数字的Mask，但更好的方法是存它们的LCM{digit[i]}
    int MOD = LCM{1,2,9} = 5 * 7 * 8 * 9 = 2520
    按照定义，数字x为Beautiful ： 
    x % LCM{digit[xi]} = 0
    即 x % MOD % LCM{digit[xi]} = 0
    所以可以只需存x % MOD，范围缩小了
    而在逐位统计时，假设到了pre***（pre指前面的一段已知的数字，而*是任意变）
        ( preSum * 10^pos + next )  % MOD % LCM(preLcm , nextLcm)
    =  ( preSum * 10 ^ pos % MOD + next % MOD ) % LCM(preLcm , nextLcm)
    == 0
    而next，nextLcm是变量，上面的比较式的意义就是
    在已知pos , preSum , preLcm情况下有多少种(next,nextLcm)满足式子为0
    而这个就是一个重复子问题所在的地方了，需要记录下来，用记忆化搜索
    dfs(pos , preSum , preLcm , doing)
    加一个标记为doing表示目前是在计算给定数字的上限，还是没有上限，即***类型的
    这样就将初始化以及逐位统计写在一个dfs了，好神奇！！！
    
    还有一点，10以内的数字情况为2^3 , 3^2 , 5 , 7
    所以最小公倍数组合的情况只有4*3*2*2 = 48
    可以存起来，我看NotOnlySuccess的写法是
    for(int i = 1 ; i <= MOD ; i ++)
    {
        if(MOD % i == 0)
            index[i] = num++;
    }
    很棒！！

    所以复杂度大概为19*2520*48*10（状态数*决策数）

    我觉得这题状态的设计不能跟具体数字分开，否则会很难设计吧
    所以用记忆化搜索，存起来
    用具体数字去计算，重复的子问题跟pre关系比较密切
    有一个比较重要的切入点就是LCM，还有%MOD缩小范围，才能存储

    还有优化到只需%252的，更快
    不过我觉得%2520比较好理解
 */
#include < iostream >
#include < cstring >
#include < map >
#include < algorithm >
#include < stack >
#include < queue >
#include < cmath >
#include < cstring >
#include < cstdlib >
#include < vector >
#include < cstdio >

using   namespace  std;

 const   int  MOD  =   2520 ;

__int64 dp[ 19 ][MOD][ 48 ];
 int  index[MOD + 10 ];
 int  digit[ 19 ];

 int  gcd( int  a ,  int  b)
{
     return  b  ==   0   ?  a : gcd(b , a  %  b);
}

 int  lcm( int  a,  int  b)
{
     return  a  /  gcd(a,b)  *  b;
}

 void  init()
{
     // 编号
     int  num  =   0 ;
     for ( int  i  =   1  ; i  <=  MOD ; i  ++ )
    {
         if (MOD  %  i  ==   0 )
            index[i]  =  num  ++ ;
    }
    memset(dp, - 1 , sizeof (dp));
}

__int64 dfs( int  pos ,  int  preSum ,  int  preLcm ,  bool  doing)
{
     if (pos  ==   - 1 ) // 为一个数字时
         return  preSum  %  preLcm  ==   0 ;

     if ( ! doing  &&  dp[pos][preSum][index[preLcm]]  !=   - 1 )
         return  dp[pos][preSum][index[preLcm]];

    __int64 ans  =   0 ;
     int  end  =  doing  ?  digit[pos] :  9 ;
     for ( int  i  =   0  ; i  <=  end ; i ++ ) // 上界
    {
         int  nowSum  =  (preSum  *   10   +  i )  %  MOD;
         int  nowLcm  =  preLcm;
         if (i)
        {
            nowLcm  =  lcm(nowLcm , i);
        }
        ans  +=  dfs(pos  -   1  ,  nowSum , nowLcm , doing  &&  i  ==  end); // doing && i == end
    }

     if ( ! doing)
    {
        dp[pos][preSum][index[preLcm]]  =  ans;
    }

     return  ans;
}

__int64 cal(__int64 x)
{
     int  pos  =   0 ;
     while (x)
    {
        digit[pos ++ ]  =  x  %   10 ;
        x  /=   10 ;
    }
     return  dfs(pos  -   1  ,  0  ,  1  ,  1 );    
}

 int  main()
{
    init();
     int  T;
     for (scanf( " %d " , & T) ; T  --  ; )
    {
        __int64 left , right ;
        cin  >>  left  >>  right;
        cout  <<  cal(right)  -  cal(left  -   1 )  <<  endl;
    }     
     return   0 ;
}