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.
'''input
12365
'''


# def f(n):
#     ans = 0
#     for i in range(int("1" + "0"*(n-1)), int("9"*n)+1):
#         tmp = set([j for j in str(i)])
#         if(len(tmp) < 3):
#             print(i)
#             ans += 1

#     return ans



def f_m(n):
    return 10 + 9*9*(2**(n-1)) - 82

def f_n(n):
    return 81*(2**(n) - 1) - 72*n

def f_m2(n):
    ans = 0
    for i in range(1, n+1):
        ans += f_m(i)
    return ans



def conCheck(n):
    tmp = set()
    while(n > 0):
        tmp.add(n%10)
        n = n//10
        if(len(tmp) > 3):
            return False

    return True



def fin(l, r):
    ans = 0
    for i in range(l, r+1):
        if(conCheck(i)):
            # print(i)
            ans += 1

    return ans



n = int(input())
if(n <= 99):
    print(n)
else:

    k = len(str(n)) - 1
    final_ans = 0
    final_ans += f_n(k)
    final_ans += fin(int("1" + "0"*k), n)
    print(final_ans)




