Problem:
Score : 300 points

Problem Statement

Given an integer N, find the base -2 representation of N.

Here, S is the base -2 representation of N when the following are all satisfied:

S is a string consisting of 0 and 1.

Unless S = 0, the initial character of S is 1.

Let S = S_k S_{k-1} ... S_0, then S_0 \times (-2)^0 + S_1 \times (-2)^1 + ... + S_k \times (-2)^k = N.

It can be proved that, for any integer M, the base -2 representation of M is uniquely determined.

Constraints

Every value in input is integer.

-10^9 \leq N \leq 10^9

Input

Input is given from Standard Input in the following format:

N

Output

Print the base -2 representation of N.

Sample Input 1

-9

Sample Output 1

1011

As (-2)^0 + (-2)^1 + (-2)^3 = 1 + (-2) + (-8) = -9, 1011 is the base -2 representation of -9.

Sample Input 2

123456789

Sample Output 2

11000101011001101110100010101

Sample Input 3

0

Sample Output 3

0

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Linq;
using System.Collections.Generic;
using System.Text;

using E = System.Linq.Enumerable;

public class Program
{
    public static void Main()
    {
        var n = int.Parse(Console.ReadLine());

        if (n == 0)
        {
            Console.WriteLine("0");
            return;
        }

        var digits = new StringBuilder();
        var k = AntiBinary.Log(n);
        var p = (k % 2 == 0 ? 1 : -1) * 1L << k;
        var x = 0L;
        while (k >= 0)
        {
            var c = '0';
            var y = x + p;
            if (p > 0 && y + AntiBinary.MinValue(k) <= n || p < 0 && y + AntiBinary.MaxValue(k) >= n)
            {
                c = '1';
                x = y;
            }
            digits.Append(c);
            k--;
            p = -p / 2;
        }
        Console.WriteLine(digits);
    }

    static class AntiBinary
    {
        private const int len = 34;
        private static long[] minAntilog = new long[len];
        private static long[] maxAntilog = new long[len];

        static AntiBinary()
        {
            long x = 0x5555555555555555 & (1L << len) - 1;
            int i = len - 1;
            while (i >= 0)
            {
                if ((x & 1) > 0)
                {
                    maxAntilog[i] = x;
                    if (i < 1)
                    {
                        break;
                    }
                    x >>= 1;
                    minAntilog[i] = -x;
                }
                else
                {
                    minAntilog[i] = -x;
                    if (i < 1)
                    {
                        break;
                    }
                    x >>= 1;
                    maxAntilog[i] = x;
                }
                i--;
            }
        }

        public static int Log(int x)
        {
            if (x < -(int)1e9 || (int)1e9 < x)
            {
                throw new ArgumentOutOfRangeException();
            }

            if (x == 0)
            {
                return 1;
            }

            int i = 0;
            if (x < 0)
            {
                while (minAntilog[i++] > x);
            }
            else
            {
                while (maxAntilog[i++] < x);
            }
            return i - 2;
        }

        public static long Parse(string s)
        {
            var x = 0L;
            var k = 1L;
            var stack = new Stack<char>(s);
            while (stack.Any())
            {
                switch (stack.Pop())
                {
                    case '0': break;
                    case '1': x += k; break;
                    default: throw new FormatException();
                }

                k = -k * 2;
            }
            return x;
        }

        public static long MinValue(int n) => minAntilog[n];
        public static long MaxValue(int n) => maxAntilog[n];
    }
}