"""
桁DPを使う
dp[i][j][k] => 合計値のi桁目がjになるようなABの組み合わせの数。kは未満フラグ
jが1のとき、その桁ではAが1でBが0のパターンと、Aが0でBが1のパターンが考えられる。
したがってdp[i+1][1] += dp[i][j]*2という遷移となる。
jが0のとき、その桁では必ずAもBも0となる。
したがってdp[i+1][0] += dp[i][j]という遷移となる。
"""
mod = 10**9 +7
L = input()
N = len(L)
dp = [[[0]*(2) for _ in range(2)]for _ in range(N)]
dp[0][0][1] = 1
dp[0][1][0] = 2

for i in range(N-1):
    x = int(L[i+1])
    for j in range(2):
        for k in range(2):
            if k == 0:
                r = x+1
            else:
                r = 2
            for l in range(r):
                if k == 0 and l == x:
                    flag = 0
                else:
                    flag = 1
                if l == 0:
                    dp[i+1][l][flag] += dp[i][j][k]
                else:
                    dp[i+1][l][flag] += dp[i][j][k]*2
                dp[i+1][l][flag] %= mod
ans = sum(dp[-1][1])+sum(dp[-1][0])
print(ans%mod) """
桁DPを使う
dp[i][j][k] => 合計値のi桁目がjになるようなABの組み合わせの数。kは未満フラグ
jが1のとき、その桁ではAが1でBが0のパターンと、Aが0でBが1のパターンが考えられる。
したがってdp[i+1][1] += dp[i][j]*2という遷移となる。
jが0のとき、その桁では必ずAもBも0となる。
したがってdp[i+1][0] += dp[i][j]という遷移となる。
""" mod = 10**9 +7 mod 10**9 +7 10**9 10 9 7 L = input() L input() input N = len(L) N len(L) len L [[0]*(2) for _ in range(2)]for _ in range(N) for _ in range(N) _ range(N) range N for _ in range(N) [[0]*(2) for _ in range(2)] dp = [[[0]*(2) for _ in range(2)]for _ in range(N)] dp [[[0]*(2) for _ in range(2)]for _ in range(N)] dp[0][0][1] = 1 dp[0][0][1] [0] [0] dp 0 0 1 1 dp[0][1][0] = 2 dp[0][1][0] [1] [0] dp 0 1 0 2 for i in range(N-1):
    x = int(L[i+1])
    for j in range(2):
        for k in range(2):
            if k == 0:
                r = x+1
            else:
                r = 2
            for l in range(r):
                if k == 0 and l == x:
                    flag = 0
                else:
                    flag = 1
                if l == 0:
                    dp[i+1][l][flag] += dp[i][j][k]
                else:
                    dp[i+1][l][flag] += dp[i][j][k]*2
                dp[i+1][l][flag] %= mod i range(N-1) range N-1 N 1 x = int(L[i+1]) x int(L[i+1]) int L[i+1] L i+1 i 1 for j in range(2):
        for k in range(2):
            if k == 0:
                r = x+1
            else:
                r = 2
            for l in range(r):
                if k == 0 and l == x:
                    flag = 0
                else:
                    flag = 1
                if l == 0:
                    dp[i+1][l][flag] += dp[i][j][k]
                else:
                    dp[i+1][l][flag] += dp[i][j][k]*2
                dp[i+1][l][flag] %= mod j range(2) range 2 for k in range(2):
            if k == 0:
                r = x+1
            else:
                r = 2
            for l in range(r):
                if k == 0 and l == x:
                    flag = 0
                else:
                    flag = 1
                if l == 0:
                    dp[i+1][l][flag] += dp[i][j][k]
                else:
                    dp[i+1][l][flag] += dp[i][j][k]*2
                dp[i+1][l][flag] %= mod k range(2) range 2 if k == 0:
                r = x+1
            else:
                r = 2
             k == 0 k 0 r = x+1 r x+1 x 1 r = 2 r 2 for l in range(r):
                if k == 0 and l == x:
                    flag = 0
                else:
                    flag = 1
                if l == 0:
                    dp[i+1][l][flag] += dp[i][j][k]
                else:
                    dp[i+1][l][flag] += dp[i][j][k]*2
                dp[i+1][l][flag] %= mod l range(r) range r if k == 0 and l == x:
                    flag = 0
                else:
                    flag = 1
                 k == 0 and l == x k == 0 k 0 l == x l x flag = 0 flag 0 flag = 1 flag 1 if l == 0:
                    dp[i+1][l][flag] += dp[i][j][k]
                else:
                    dp[i+1][l][flag] += dp[i][j][k]*2
                 l == 0 l 0 dp[i+1][l][flag] += dp[i][j][k] dp[i+1][l][flag] [l] [i+1] dp i+1 i 1 l flag dp[i][j][k] [j] [i] dp i j k dp[i+1][l][flag] += dp[i][j][k]*2 dp[i+1][l][flag] [l] [i+1] dp i+1 i 1 l flag dp[i][j][k]*2 dp[i][j][k] [j] [i] dp i j k 2 dp[i+1][l][flag] %= mod dp[i+1][l][flag] [l] [i+1] dp i+1 i 1 l flag mod ans = sum(dp[-1][1])+sum(dp[-1][0]) ans sum(dp[-1][1])+sum(dp[-1][0]) sum(dp[-1][1]) sum dp[-1][1] [-1] dp -1 1 sum(dp[-1][0]) sum dp[-1][0] [-1] dp -1 0 print(ans%mod) print ans%mod ans mod r = x+1 x+1 r r = 2 2 r ans = sum(dp[-1][1])+sum(dp[-1][0]) sum(dp[-1][1])+sum(dp[-1][0]) ans dp = [[[0]*(2) for _ in range(2)]for _ in range(N)] [[[0]*(2) for _ in range(2)]for _ in range(N)] dp flag = 0 0 flag mod = 10**9 +7 10**9 +7 mod N = len(L) len(L) N flag = 1 1 flag x = int(L[i+1]) int(L[i+1]) x L = input() input() L
"""
桁DPを使う
dp[i][j][k] => 合計値のi桁目がjになるようなABの組み合わせの数。kは未満フラグ
jが1のとき、その桁ではAが1でBが0のパターンと、Aが0でBが1のパターンが考えられる。
したがってdp[i+1][1] += dp[i][j]*2という遷移となる。
jが0のとき、その桁では必ずAもBも0となる。
したがってdp[i+1][0] += dp[i][j]という遷移となる。
"""
mod = 10**9 +7
L = input()
N = len(L)
dp = [[[0]*(2) for _ in range(2)]for _ in range(N)]
dp[0][0][1] = 1
dp[0][1][0] = 2

for i in range(N-1):
    x = int(L[i+1])
    for j in range(2):
        for k in range(2):
            if k == 0:
                r = x+1
            else:
                r = 2
            for l in range(r):
                if k == 0 and l == x:
                    flag = 0
                else:
                    flag = 1
                if l == 0:
                    dp[i+1][l][flag] += dp[i][j][k]
                else:
                    dp[i+1][l][flag] += dp[i][j][k]*2
                dp[i+1][l][flag] %= mod
ans = sum(dp[-1][1])+sum(dp[-1][0])
print(ans%mod)