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.
import java.util.HashSet;
import java.util.Scanner;

public class C {
    static HashSet<Integer> set;
    static int n;

    public static int count(int num, int idx) {
        if (idx < 0)
            return 0;
        int f = Integer.parseInt(Integer.toBinaryString(num | (1 << idx)));
        int s = Integer.parseInt(Integer.toBinaryString(num));
        // System.out.println(f+"  "+s);
        int res = 0;
        if (f <= n) {
            if (!set.contains(f)) {
                res++;
                set.add(f);
            }
        }
        if (s <= n) {
            if (!set.contains(s)) {
                //System.out.println("Dak");
                res++;
                set.add(s);
            }
        }
        return res + count(Integer.parseInt("" + f, 2), idx - 1)
                + count(Integer.parseInt("" + s, 2), idx - 1);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        set=new HashSet<Integer>();
        n = sc.nextInt();
        int l = ("" + n).length();
        if(l==1) {
            System.out.println(1); return;
        }
        int res = 0;
        res += ((1 << (l - 1)) - 1);
        System.out.println(res + count(1 << (l - 1), (l - 2)));
    }
}
