/*
    一個數是Balanced ，指這個數的力矩為0
    如 4139 選支點為3  4*2 + 1*1 = 9*1 
    為[x,y]內有多少個Balanced Number   0<=x<=y<=10^18

    watashi的博客里提到如果 <=10^9 用 sqrt(n)的方法打表，打印每10w個數之間有多少個Balanced Number
    感覺這種方法很好  sqrt(n)

    這題數據規模很大10^18，要用數位統計

    dp的預處理我想的少了一位，最后問別人
    dp[all,len,total] 表示總長度為all，字符占的長度為len，力矩為total的方案數
    如xxx123 即是 dp[6,3,1*3+2*4+3*5]

    init后，就用數位統計cal(x)統計[0,x]內多少個Balanced Number
    枚舉位數，枚舉該位小于bit[i]的數字j
    然后再枚舉支點位置，1到len  然后統計
    （枚舉的位置是1到len,第一次遇到枚舉的位置可以是pre的東西）

    由于一個數的支點只有一個！！！所以不會重復計數
    “就會發現一個數最多關于一個digit是balanced的（一個嚴格單調函數最多有一個零點）。
    注意到了這一點就會知道，這題是不存在重復計算這種問題的。”

    但注意的是0的支點不止一個，所以要減去重復的0
    000000  支點任意一個都可以
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<cmath>
#include<cstdlib>
#include<cassert>
#include<iostream>

using namespace std;

const int INF = 1000000000;

long long _dp[2][200][2000];//len sum total
long long dp[20][20][2000];//all  len  total


bool debug = true;

void init()
{
    _dp[0][0][0] = 1;
    for(int all = 0 ; all <= 19 ; all++)
        dp[all][0][0] = 1;
    int pre = 0 , now = 1;
    for(int len = 1 ; len <= 19 ; len++)//要算到19位！！
    {
        int sum = len * 9;
        int total = (len+1)*len/2*9;
        //clear
        for(int s = 0 ; s <= sum ; s++)
            for(int t = 0; t <= total ; t++)
                _dp[now][s][t] = 0;

        int _sum = (len-1)*9;
        int _total = (len-1)*len/2*9;
        for(int s = 0 ; s <= _sum ; s++)
            for(int t =  0 ; t <= _total ; t++)
                for(int j = 0 ; j <= 9 ; j++)
                {
                    _dp[now][s+j][t+s] += _dp[pre][s][t];
                }

        for(int x = 0 ; x+len <= 19 ; x++)
            for(int s = 0 ; s <= sum ; s++)
                for(int t = 0 ; t <= total ; t++)
                {
                    dp[len+x][len][t+s*x] += _dp[now][s][t];
                }

        swap(pre,now);
    }
}

long long cal(long long x)//[0,x]
{
    if(x<0)return 0;
    x++;

    int len = 0 , bit[21];
    while(x)
    {
        bit[++len] = x % 10;
        x /= 10;
    }

    long long res = 0;
    int toRight[21] = {0} , toLeft[21] = {0};
    int sum[21] = {0};

    for(int i = len ; i ; i--)//[1,_x)     _x = x+1
    {
        toRight[i] = toRight[i+1] + sum[i+1];
        toLeft[i] = toLeft[i+1] + (len-i)*bit[i];
        sum[i] = sum[i+1] + bit[i];

        if(debug)
            printf("%d %d %d %d \n",i , toRight[i] , toLeft[i] , sum[i]);

        for(int j = 0 ; j < bit[i] ; j++)//枚舉第i位數字j
        {

            //枚舉支點位置p
            for(int p = len ; p > i ; p--)
            {
                int balance = toRight[p];
                int sub = toLeft[i+1] - toLeft[p] - (len-p)*(sum[i+1] - sum[p]) + (p-i)*j;
                if(balance >= sub)
                {
                    if(debug)
                        printf("j   %d %d %d %lld\n",j,balance ,sub,dp[p][i-1][balance - sub]);
                    res += dp[p][i-1][balance - sub];
                }
            }

            if(debug)
                printf("> i     res  %lld\n",res);

            //p == i
            {
                res += dp[i][i-1][toRight[i]];
            }

           if(debug)
                printf("= i     res  %lld\n",res);

            for(int p = i-1 ; p ; p--)
            {
                int _balance = toRight[i] + (i-p) * (sum[i+1]+j) ;
                if(debug)
                    printf("j  %d p%d %d\n",j,p,_balance);
                int total = p*(p+1)/2*9;
                for(int t = 0 ; t <= total; t++)
                {
                    if(debug)
                        printf("%d %lld %lld\n",t,dp[i-p][i-p][t] , dp[p][p-1][_balance+t]);
                    if( dp[i-p][i-p][t] && dp[p][p-1][_balance+t] )
                        res += dp[i-p][i-p][t]*dp[p][p-1][_balance+t];
                }
            }
           if(debug)
              printf("<i     res  %lld\n",res);
        }        
    }
    
    return res - (len-1);//減去重復計數的0
}


bool bruteChk(long long x)//布魯特—福斯  ^_^
{
    int left = 0 ,right = 0;
    int bit[21]={0} , len = 0 , sum[21] = {0};
    while(x)
    {
        bit[++len] = x % 10;
        x /= 10;
    }
    for(int i = len  ; i ; i --)
        sum[i] = sum[i+1] + bit[i];
    for(int i = 1; i <= len ; i++)
        right += (len-i+1)*bit[i];

    for(int i = len ; i ; i--)
    {
        right -= (sum[1]-sum[i+1]);
        left += sum[i+1];
        if(left == right)return true;
    }
    return left == right;
}

int main()
{

#ifdef ONLINE_JUDGE
#else
    freopen("in", "r", stdin);
#endif

    init();
   
    debug = false;

    int T;
    for(scanf("%d",&T) ; T-- ; )
    {
        long long x,y;
        scanf("%lld%lld",&x,&y);
            printf("%lld\n",cal(y)-cal(x-1));
    }
    return 0;
}