Polycarpus loves lucky numbers. Everybody knows that lucky numbers are positive integers, whose decimal representation (without leading zeroes) contain only the lucky digits *x* and *y*. For example, if *x* = 4, and *y* = 7, then numbers 47, 744, 4 are lucky.

Let's call a positive integer *a* undoubtedly lucky, if there are such digits *x* and *y* (0 ≤ *x*, *y* ≤ 9), that the decimal representation of number *a* (without leading zeroes) contains only digits *x* and *y*.

Polycarpus has integer *n*. He wants to know how many positive integers that do not exceed *n*, are undoubtedly lucky. Help him, count this number.
The first line contains a single integer *n* (1 ≤ *n* ≤ 10<sup class="upper-index">9</sup>) — Polycarpus's number.
n = input()
a = int(n[0])
l = len(n)
d = 1 << (l - 1)

def f(a, i):
    global n, l
    if i == l: return 0
    b = int(n[i])
    i += 1
    d = 1 << (l - i)
    if a > b: return b * d + g(a, b, i)
    if a == b: return b * d + f(a, i)
    return (b - 1) * d + g(a, b, i) + 9 * (d >> 1)
        
def g(a, b, i):
    if i == l: return 0
    c = int(n[i])
    d = 1 << (l - i - 1)
    if a > b: a, b = b, a
    if c < a: return 0
    if c == a: return g(a, b, i + 1)
    if c < b: return d
    if c == b: return d + g(a, b, i + 1)
    return 2 * d

print(a * (9 * d - 8) + 72 * (d - l) + f(a, 1))