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.
import datetime


def only_two_digits(number):
    uniquedigits = set(str(number))

    # if unique digits are 1 or two then count the number as undoubtedly lucky
    if len(uniquedigits) <= 2:
        return True

    return False


answer = 0


def generate_all(number, n):
    global answer

    if number > 0 and number <= n:
        answer += 1
        # print(number, only_two_digits(number))

    if number >= n:
        return

    for i in range(0, 10):
        next_number = number * 10 + i
        if next_number > 0 and only_two_digits(next_number):
            generate_all(next_number, n)


def solve():
    num = int(input().strip())

    count = 0

    # List valid numbers
    generate_all(0, num)

    print(answer)


# import time

# start = time.time()
solve()
# end = time.time()
# print(end - start)
