Sometimes it is not easy to come to an agreement in a bargain. Right now Sasha and Vova can't come to an agreement: Sasha names a price as high as possible, then Vova wants to remove as many digits from the price as possible. In more details, Sasha names some integer price $n$, Vova removes a non-empty substring of (consecutive) digits from the price, the remaining digits close the gap, and the resulting integer is the price.

For example, is Sasha names $1213121$, Vova can remove the substring $1312$, and the result is $121$.

It is allowed for result to contain leading zeros. If Vova removes all digits, the price is considered to be $0$.

Sasha wants to come up with some constraints so that Vova can't just remove all digits, but he needs some arguments supporting the constraints. To start with, he wants to compute the sum of all possible resulting prices after Vova's move.

Help Sasha to compute this sum. Since the answer can be very large, print it modulo $10^9 + 7$.


-----Input-----

The first and only line contains a single integer $n$ ($1 \le n < 10^{10^5}$).


-----Output-----

In the only line print the required sum modulo $10^9 + 7$.


-----Examples-----
Input
107

Output
42

Input
100500100500

Output
428101984



-----Note-----

Consider the first example.

Vova can choose to remove $1$, $0$, $7$, $10$, $07$, or $107$. The results are $07$, $17$, $10$, $7$, $1$, $0$. Their sum is $42$.

Difficulty: interview

Starter code:

Solutions:
s=input();M=10**9+7;o=u=v=0;n=len(s)
for i in range(n):c=int(s[i]);u+=v;v=(10*v+c)%M;o+=pow(10,n-i-1,M)*((i*i+i)//2*c+u)
print(o%M)

mod = int(1e9+7)
s = input()
n = len(s)
pref = [0] * (n+1)
for i in range(n):
    pref[i+1] = (int(s[i]) + pref[i]*10) % mod
for i in range(n):
    pref[i+1] = (pref[i+1] + pref[i]) % mod

res = 0
acc = 0
for i in range(n, 0, -1):
    res += pref[i-1] * pow(10, n-i, mod) + i*acc
    res %= mod
    acc = acc + int(s[i-1]) * pow(10, n-i, mod) % mod
print(res)


import sys
z=sys.stdin.readline
M=10**9+7
n=[*map(int,z().strip())]
l=len(n)
p=[0]
for i in range(l):p.append(p[-1]+n[i])
s=0
v=(l*l-l)//2
d=1
for i in range(1,l):
    r=p[l-i]*i+v*n[l-i]
    s=(s+r*d)%M
    d=(d*10)%M
    v-=l-i
print(s)

n = input().strip()
M = 1000000007
l = len(n)

a = 0
b = 0
for i,c in enumerate(n[::-1]):
	c = int(c)
	p = l - 1 - i
	a += p * (p + 1) // 2 * c * pow(10, i, M)
	a += b * c
	a %= M
	b += (i+1) * pow(10, i, M)
	b %= M
print(a)


import sys
input = sys.stdin.readline

MOD = 10 ** 9 + 7
N = 10 ** 5 + 100

fact = [0 for _ in range(N)]
invfact = [0 for _ in range(N)]
fact[0] = 1
for i in range(1, N):
    fact[i] = fact[i - 1] * i % MOD

invfact[N - 1] = pow(fact[N - 1], MOD - 2, MOD)

for i in range(N - 2, -1, -1):
    invfact[i] = invfact[i + 1] * (i + 1) % MOD
def nCk(n, k):
    if k < 0 or n < k:
        return 0
    else:
        return fact[n] * invfact[k] * invfact[n - k] % MOD

def main():
    n = input().strip()
    ans = 0
    l = len(n)
    plus = 0
    plus2 = 1
    plus3 = 1
    for i, str_num in enumerate(n[::-1]):
        num = int(str_num)
        j = l - i - 1
        ans += nCk(j + 1, 2) * pow(10, i, MOD) * num
        ans %= MOD
        ans += num * plus
        ans %= MOD
        plus += plus2 * plus3
        plus2 *= 10
        plus3 += 1
        plus %= MOD
        plus2 %= MOD
        plus3 %= MOD

    print(ans)
        
        
main()


n = list(input())
l = len(n)
x = 1
y = 0
z = 0
mod = pow(10, 9) + 7
ans = 0
for i in range(l):
    m = int(n[l - i - 1])
    ans += x * m * ((l - i) * (l - i - 1) // 2)
    ans %= mod
    ans += z * m
    ans %= mod
    y += 1
    z += x * y
    z %= mod
    x *= 10
    x %= mod
print(ans)

import sys

def minp():
	return sys.stdin.readline().strip()

def mint():
	return int(minp())

def mints():
	return list(map(int, minp().split()))

#from math import ceil

def solve():
	MOD = int(1e9+7)
	s = minp()
	n = len(s)
	p = [0]*(n+1)
	pp = [1]*(n+1)
	p10 = 1
	for i in range(1,n+1):
		p[i] = (p[i-1]+p10*i)%MOD
		pp[i] = p10
		p10 = (p10*10)%MOD
	res = (int(s[0])*p[n-1])%MOD
	#print(res)
	for i in range(1,n):
		#print(int(s[i])*pp[n-i],int(s[i])*(p[n-1-i] + pp[n-i]*(i)*(i+1)//2))
		res = (res+int(s[i])*(p[n-1-i] + pp[n-i]*(i)*(i+1)//2))%MOD
	print(res)

#for i in range(mint()):
solve()


import sys
input = sys.stdin.readline
from itertools import accumulate

S=input().strip()
mod=10**9+7
LEN=len(S)

ANS=[0]*(LEN+1)
ANS2=[0]*(LEN+1)
ANS3=[0]*(LEN+1)

for i in range(LEN):
    x=int(S[LEN-1-i])
    
    k=LEN-i-1
    p=k*(k+1)//2
    ANS[i]+=x*p

    
    ANS2[0]+=x
    ANS2[i]-=x
    ANS3[i]-=i*x

ANS2=list(accumulate(ANS2))
for i in range(LEN+1):
    ANS2[i]+=ANS3[i]
ANS2=list(accumulate(ANS2))

#print(ANS)
#print(ANS2)

A=0
for i in range(LEN):
    A+=(ANS[i]+ANS2[i])*pow(10,i,mod)
    A%=mod

print(A)


s=input()
ans=0
mod=10**9+7
n=len(s)
ps=[0]
cp=1
for i in range(n-1,-1,-1):
	ps.append((ps[-1]+int(s[i])*cp)%mod)
	cp=cp*10%mod
ps.reverse()
prefs=0
lastpref=0
for i in range(n):
	nextdigs=ps[i+1]
	ans=(ans+prefs*pow(10,n-i-1,mod)%mod+nextdigs*(i+1))%mod
	lastpref=(lastpref*10+int(s[i]))%mod
	prefs=(prefs+lastpref)%mod
print(ans)

s = [int(c) for c in input()][::-1]
n = len(s)

mod = 1000000007
def inv(x):
    return pow(x, mod - 2, mod)
teninv = inv(10)

P = [0]
p = 1
for x in s:
    P.append((P[-1] + x*p) % mod)
    p = p*10 % mod

Q = [0]
for i in range(n+1):
    Q.append((Q[-1] + P[i]*pow(teninv, i, mod))%mod) 

s = 0
for l in range(n):
    first = P[l] - P[0]
    s += (n - l)*first % mod
    s += P[n] * inv(9) % mod * (1 - inv(pow(10, n-l, mod))) % mod
    d = Q[n+1] - Q[l+1]

    s = (s - d*inv(pow(teninv,l,mod))%mod) % mod
print(s%mod)


def inv(x):
    return pow(x,1000000005,1000000007)
s=input()
ans=0
n=len(s)
for i in range(n-1,-1,-1):
    z=pow(10,n-1-i,1000000007)*int(s[i])
    z=z*((i)*(i+1))//2
    ans+=z
    ans%=1000000007
    k=n-1-i
    op=0
    op+=(pow(10,k,1000000007)*(9*k-1))
    op%=1000000007
    op+=1
    op=op*inv(81)
    op%=1000000007
    op=op*int(s[i])
    ans+=op
    ans%=1000000007
print(ans)


import sys
import random
from fractions import Fraction
from math import *
 
def input():
    return sys.stdin.readline().strip()
 
def iinput():
    return int(input())

def finput():
    return float(input())

def tinput():
    return input().split()

def linput():
    return list(input())
 
def rinput():
    return list(map(int, tinput()))

def fiinput():
    return list(map(float, tinput()))
 
def rlinput():
    return list(map(int, input().split()))
def trinput():
    return tuple(rinput())

def srlinput():
    return sorted(list(map(int, input().split())))

def NOYES(fl):
    if fl:
        print("NO")
    else:
        print("YES")
def YESNO(fl):
    if fl:
        print("YES")
    else:
        print("NO")
    
def main():
    #n = iinput()
    #k = iinput() 
    #m = iinput() 
    #n = int(sys.stdin.readline().strip()) 
    #n, k = rinput()
    #n, m = rinput()
    #m, k = rinput()
    #n, k, m = rinput()
    #n, m, k = rinput()
    #k, n, m = rinput()
    #k, m, n = rinput() 
    #m, k, n = rinput()
    #m, n, k = rinput()
    #q = rlinput()
    #q = linput()
    s = input(); n = len(s)
    mod = int(1e9) + 7
    q = [0 for i in range(100100)]
    w = [0 for i in range(100100)]
    q[0] = 1; w[0] = 1; res = 1
    for i in range(1, 100100):
        res = (res * 10) % mod
        q[i] = q[i - 1] + res
        q[i] %= mod
        w[i] = w[i - 1] * 10
        w[i] %= mod
    l, res, r = 0, 0, 0
    for i in range(n - 1):
        l *= 10
        l += int(s[i])
        l %= mod
        res += l * q[n - 2 - i] % mod
        res %= mod
    for i in range(n - 1, 0, -1):
        r += w[n - 1 - i] * int(s[i])
        r %= mod
        res += r * i % mod
        res %= mod
    print(res)
    
    
        

            
        
    
                
    
    
    
            
    
        
    

for i in range(1):
    main()