One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of *n* different natural numbers from 1 to *n* to obtain total control over her energy.

But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.
Input data contains the only number *n* (1 ≤ *n* ≤ 10<sup class="upper-index">9</sup>).
For *n* = 10 the answer includes numbers 1 and 10.
10
2
20
3
72
3
99
3
100
4
101
5
102
5
111
7
112
7
745
7
23536
31
1
1
1010011
83
312410141
511
1000000000
512
999999999
511
111111111
511
101010101
341
121212121
511
106341103
383
901556123
511
832513432
511
3
1
732875234
511
7
1
9
1
2
1
11
3
12
3
13
3
101020101
351
111100100
484
110110101
437
100111001
313
100100
36
110100102
421
class A:

    def solve(self):
        [y, w] = [int(x) for x in input().split(" ")]
        winning_chances = 6 - max(y, w) + 1
        num = winning_chances
        den = 6

        for i in range(2, 7):
            if num % i == 0 and den % i == 0:
                num /= i
                den /= i

        print("{}/{}".format(int(num), int(den)))

class B:

    def distance_to_university(self, xu, yu, stop):
        import math as m
        return m.sqrt((stop - xu)**2 + yu**2)

    def solve(self):
        [n, vb, vs] = [int(x) for x in input().split(" ")]
        stops = [int(x) for x in input().split(" ")]
        [xu, yu] = [int(x) for x in input().split(" ")]
        time_to_stop = [x / vb for x in stops]
        distance = [self.distance_to_university(xu, yu, x) for x in stops]
        time_from_stop_to_uni = [x / vs for x in distance]
        total_time = [t1 + t2 for t1, t2 in zip(time_to_stop, time_from_stop_to_uni)]
        min_index = []
        import sys
        min_time = sys.maxsize
        for i in range(1, len(total_time)):
            if total_time[i] < min_time:
                min_time = total_time[i]
                min_index = [i]
            elif total_time[i] == min_time:
                min_index.append(i)

        if len(min_index) > 1:
            closest_index = 0
            closest_distance = sys.maxsize
            for i in min_index:
                if distance[i] < closest_distance:
                    closest_distance = distance[i]
                    closest_index = i
            print(closest_index + 1)
        else:
            print(min_index[0] + 1)
class C:

    def solve(self):
        from collections import deque
        n = int(input())

        q = deque()
        q.append(1)
        elements_stored = 0

        while len(q) != 0:
            e = q.popleft()
            if e > n:
                break
            elements_stored += 1
            q.append(e * 10)
            q.append(e * 10 + 1)

        print(elements_stored)

C().solve()
