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 Rust (1.42.0) (judge verdict: Accepted)

// This code is generated by [cargo-atcoder](https://github.com/tanakh/cargo-atcoder)
// Original source code:
/*
use competitive::prelude::*;

fn solve(n: i64, v: &mut Vec<u8>) {
    dbg!(n);
    if n == 0 {
        return;
    }
    if n > 0 {
        let mut j = 1;
        let mut i = 1;
        let mut max = 1;
        while max < n {
            j += 2;
            i *= 4;
            max += i;
        }
        v[j] = 1;
        dbg!(i, max);
        solve(n - i, v);
    } else {
        let mut j = 2;
        let mut i = 2;
        let mut max = 2;
        while -max > n {
            j += 2;
            i *= 4;
            max += i;
        }
        v[j] = 1;
        dbg!(i, max);
        solve(n + i, v);
    }
}

#[proconio::fastout]
fn main() {
    input! {
        n: i64,
    }
    let m = 10000;
    let mut v = vec![0_u8; m];
    solve(n, &mut v);
    let mut started = false;
    for i in (1..m).rev() {
        if !started {
            if v[i] == 1 {
                started = true;
            }
        }
        if started {
            print!("{}", v[i]);
        }
    }
    if !started {
        echo!(0);
    }
}
*/

fn main() {
    let exe = "/tmp/bin83943B4F";
    std::io::Write::write_all(&mut std::fs::File::create(exe).unwrap(), &decode(BIN)).unwrap();
    std::fs::set_permissions(exe, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
    std::process::exit(std::process::Command::new(exe).status().unwrap().code().unwrap())
}

fn decode(v: &str) -> Vec<u8> {
    let mut ret = vec![];
    let mut buf = 0;
    let mut tbl = vec![64; 256];
    for i in 0..64 { tbl[TBL[i] as usize] = i as u8; }
    for (i, c) in v.bytes().filter_map(|c| { let c = tbl[c as usize]; if c < 64 { Some(c) } else { None } }).enumerate() {
        match i % 4 {
            0 => buf = c << 2,
            1 => { ret.push(buf | c >> 4); buf = c << 4; }
            2 => { ret.push(buf | c >> 2); buf = c << 6; }
            3 => ret.push(buf | c),
            _ => unreachable!(),
        }
    }
    ret
}

const TBL: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const BIN: &'static str = "<base64-encoded ELF executable removed>";