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.
# https://codeforces.com/contest/244/problem/B

def gen(digit, x, length, S):
    S.append(x)
    
    if length == 10:
        return
    
    if len(digit) == 1:
        for i in range(0, 10):
            next_x = x * 10 + i
            
            if i == digit[0]: 
                gen(digit, next_x, length+1, S)
            else:
                gen(digit+[i], next_x, length+1, S)
        
    else:
        next_x1 = x * 10 + digit[0]
        next_x2 = x * 10 + digit[1]
        gen(digit, next_x1, length+1, S)
        gen(digit, next_x2, length+1, S)
        
S = []
for i in range(1, 10):
    gen([i], i, 1, S)
    
S = sorted(S) 
x = int(input())

l = -1
u = len(S)

while u-l>1:
    md = (u+l) // 2
    if x >= S[md]:
        l = md
    else:
        u = md
print(u)            