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.
def bepi(n):
    l=[0]*(10000)
    mp={}
    x=0
    y=0
    ans=0
    while(x<10):
        y=x+1
        while(y<10):
            w=0
            r=0
            if x!=0 and x<=n:
                l[w]=x
                w+=1
            if y!=0 and y<=n:
                l[w]=y
                w+=1
            while(r<w):
                t=l[r]
                if t*10+x <= n:
                    l[w]=t*10+x
                    w+=1
                if t*10+y <=n:
                    l[w]=t*10+y
                    w+=1
                r+=1
            r=0
            while(r<w):
                if not l[r] in mp:
                    ans+=1
                    mp[l[r]]=1
                r+=1
            y+=1
        x+=1
    return ans


n=int(input())
print(bepi(n))
