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.
# Time Complexity: O(log n)
# Space Complexity: O(n)
# The solution chooses two digits, x and y, and try every combination of those
# digits which is below n. There are less than 100 ways to choose two unique
# digits and every depth-first search tree will have a height of log n.
# Therefore, the solution can find every undoubtedly lucky number in O(log n)
n = int(input())
m = set()

def dfs(num, x, y):
    global n
    if num == 0 or num > n:
        return
    m.add(num)
    num *= 10
    dfs(num + x, x, y)
    dfs(num + y, x, y)

for x in range(10):
    for y in range(10):
        if x == y:
            continue
        dfs(x, x, y)

print(len(m))
  		  		      	 	   	  	 	    	