#include <bits/stdc++.h>
#define greedy int
#define mindset main()

#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")

using namespace std;
#define FOR(a,b,c) for(ll a = b; a < (c); a++)
#define FORR(a,b,c) for(ll a = b; a > (c); a--)
 
#define READ(x) ll x;cin>>x;
#define READAR(x,n) vll x(n); FOR(readar,0,n) cin >> x[readar];
#define READS(x) string x; cin>>x;
#define SEP(n,mx) (((n) == (mx)-1) ? '\n' : ' ')

#define speedfirst ios_base::sync_with_stdio(false); cin.tie(NULL); 
 
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll,ll> pll;
typedef vector<pll> vpll;
typedef tuple<ll,ll,ll> tll;


const ll MOD = 1000000007;

vll facts(5000), ifacts(5000);

ll modexp(ll a, ll e) {
    ll r = 1;
    while(e) {
        if(e & 1) r = (r*a) % MOD;
        a = (a * a) % MOD;
        e >>= 1;
    }
    return r;
}

ll nCk(ll n, ll k) {
    if(k > n) return 0;
    if(k < 0) return 0;
    ll ans = facts[n]*ifacts[k];
    ans %= MOD;
    ans *= ifacts[n-k];
    ans %= MOD;
    return ans;
}

array<array<ll,5000>,5000> ncks;

array<ll, 51> dp;
array<ll, 51> dp2;
ll solve(const array<ll, 9>& mxes, ll N) {
    ll su = 0;
    for(auto m: mxes) {
        if(m < 0) return 0;
        su += m;
    }
    if(su < N) return 0;

    dp = {}; // state = (n_spent, valid..) -> ways
    dp[0] = 1;
    for(ll i = 0; i < 9; i++) {
        dp2 = {};
        for(ll amt = 0; amt <= N; amt++) {
            for(ll amti = 0; (amti + amt <= N) && (amti <= mxes[i]); amti++) {
                dp2[amt + amti] += dp[amt] * ncks[N - amt][amti];
                dp2[amt+amti] %= MOD;
            }
        }
        dp = dp2;
    }

    return dp[N];
}



// last `nfree` digits are free, rest are fixed. calc answer.
ll calcsum(const array<ll, 10>& counts, ll nfree) {
    ll ans = 0;
    for(ll d = 0; d < 10; d++) {
        for(ll nd = counts[d]; nd <= counts[d] + nfree; nd++) {

            array<ll, 9> mxes;

            for(ll d2 = 0; d2 < d; d2++) {
                mxes[d2] = nd - counts[d2];
            }

            for(ll d2 = d+1; d2 < 10; d2++) {
                mxes[d2-1] = nd - counts[d2]-1;
            }

            ans = (ans + d*nCk(nfree, nd - counts[d])*solve(mxes, nfree - (nd-counts[d]))  ) % MOD;

        }
    }

    return ans;
}

void solve() {
    string S; cin >> S;
    
    // assert(calcsum({0,1,0,0,0,0,0,0,0,0}, 1) == 46);
    // assert()

    ll ans = 0;

    for(ll p = 0; p < S.size()-1; p++) {
        for(ll fd = 1; fd < 10; fd++) {
            array<ll, 10> cts = {};
            cts[fd]++;
            ans += calcsum(cts, p);
            ans %= MOD;
        }
    }

    array<ll, 10> cts_bef = {};
    for(ll p = 0; p < S.size(); p++) {
        ll d = S[p] - '0';
        if(p == S.size()-1) d++;
        ll lo = 0;
        if(p == 0) lo++;
        for(ll v = lo; v < d; v++) {
            array<ll,10> cts = cts_bef;
            cts[v]++;

            ans += calcsum(cts, S.size() - 1 - p);
            ans %= MOD;
        }

        if(p < S.size()-1) cts_bef[d]++;
    }

    cout << ans << "\n";



}

greedy mindset {
    speedfirst;

    facts[0]=1;
    for(ll i = 1; i < facts.size(); i++) facts[i] = (i*facts[i-1]) % MOD;

    

    ifacts.back() = modexp(facts.back(), MOD-2);
    for(ll i = facts.size()-2; i >= 0; i--) {
        ifacts[i] = ( (i+1)*ifacts[i+1] ) % MOD;
    }


        for(ll a = 0; a < 5000; a++) for(ll b = 0; b < 5000; b++) ncks[a][b] = nCk(a,b);


    READ(T); FOR(t,0,T) solve();
}