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

Input data contains the only number n (1 ≤ n ≤ 109).

Output

Output the only number — answer to the problem.

Examples

Input

10


Output

2

Note

For n = 10 the answer includes numbers 1 and 10.
"""
from sys import stdin, stdout
import math
from functools import reduce
import statistics
import numpy as np
import itertools
import operator
"""
from math import sqrt
import os
import sys
from io import BytesIO, IOBase

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")


def prog_name():
    # n = int(input())
    # if n < 10:
    #     print(1)
    # else:
    #     cnt = 0
    #     check = 9
    #     t = 9
    #     flag = True
    #     while flag:
    #         if check <= n:
    #             cnt += 2**(len(str(check)) - 1)
    #             check = check*10 + t
    #         else:
    #             flag = False
    #     num = (int('1'*len(str(n))))
    #     start = int(str(check)[:-1])
    #
    #     if (min(n,num)) == num and n != start:
    #         cnt += 2 ** (len(str(check)) - 1)
    #     else:
    #         for x in range(start + 1,min(n,num) + 1):
    #             j = str(x)
    #             if j.count('0') + j.count('1') == len(j):
    #                 cnt += 1
    #     print(cnt)

    x = 1
    n = int(input())
    flag = True
    while flag:
        if int(bin(x)[2:]) <= n:
            x +=1
        else:
            flag = False
    print(x - 1)

def main():
    t = 1
    for unique in range(t):
        # print("Case #"+str(unique+1)+":",end = " ")
        prog_name()
if __name__ == "__main__":
    main()
