#![allow(unused_imports, unused_macros)] use kyoproio::*; use std::{ collections::*, io::{self, prelude::*}, iter, mem::{replace, swap}, }; fn run(mut kin: I, mut out: O) { macro_rules! output { ($($args:expr),+) => { write!(&mut out, $($args),+).unwrap(); }; } macro_rules! outputln { ($($args:expr),+) => { output!($($args),+); outputln!(); }; () => { output!("\n"); if cfg!(debug_assertions) { out.flush().unwrap(); } } } let n: usize = kin.input(); let rn = ((n as f64).sqrt() as usize + 2) & !1; let calc = |it| { let mut cost = vec![!0 / 2; n + 1]; let mut value = vec![!0; n + 1]; cost[0] = 0; for i in it { if i * i > n { continue; } for j in 0..=n - i * i { let k = j + i * i; if cost[j] + i <= cost[k] { cost[k] = cost[j] + i; value[k] = i; } } } value }; let mut it_inc = (2..=rn).step_by(2).chain((1..=rn).step_by(2)); let mut it_dec = (2..=rn).rev().step_by(2).chain((1..=rn).step_by(2)); let big = calc(&mut it_inc as &mut dyn Iterator); let small = calc(&mut it_dec as &mut dyn Iterator); let mut i = n; let mut ans = Vec::new(); let mut head = 0; while i > 0 { let x = if big[i] % 2 == 1 || head == 0 { big[i] } else { small[i] }; for _ in 0..x { ans.push(head as u8 + b'0'); head ^= 1; } head ^= 1; i -= x * x; } out.bytes(&ans); out.ln(); } // ----------------------------------------------------------------------------- fn main() -> io::Result<()> { std::thread::Builder::new() .stack_size(64 * 1024 * 1024) .spawn(|| { run( KInput::new(io::stdin()), io::BufWriter::new(io::stdout().lock()), ) })? .join() .unwrap(); Ok(()) } // ----------------------------------------------------------------------------- pub mod kyoproio { use std::{ io::prelude::*, iter::FromIterator, marker::PhantomData, mem::{self, MaybeUninit}, ptr, slice, str, }; pub trait Input { fn bytes(&mut self) -> &[u8]; fn str(&mut self) -> &str { str::from_utf8(self.bytes()).unwrap() } fn input(&mut self) -> T { T::input(self) } fn iter(&mut self) -> Iter { Iter(self, PhantomData) } fn seq>(&mut self, n: usize) -> B { self.iter().take(n).collect() } } pub struct KInput { src: R, buf: Vec, pos: usize, len: usize, } impl KInput { pub fn new(src: R) -> Self { Self { src, buf: vec![0; 1 << 16], pos: 0, len: 0, } } } impl Input for KInput { fn bytes(&mut self) -> &[u8] { loop { while let Some(delim) = self.buf[self.pos..self.len] .iter() .position(|b| b.is_ascii_whitespace()) { let p = self.pos; self.pos += delim + 1; if delim > 0 { return &self.buf[p..p + delim]; } } if self.read() == 0 { return &self.buf[mem::replace(&mut self.pos, self.len)..self.len]; } } } } impl KInput { fn read(&mut self) -> usize { if self.pos > 0 { self.buf.copy_within(self.pos..self.len, 0); self.len -= self.pos; self.pos = 0; } else if self.len >= self.buf.len() { self.buf.resize(2 * self.buf.len(), 0); } let read = self.src.read(&mut self.buf[self.len..]).unwrap(); self.len += read; read } } pub struct Iter<'a, T, I: ?Sized>(&'a mut I, PhantomData<*const T>); impl<'a, T: InputItem, I: Input + ?Sized> Iterator for Iter<'a, T, I> { type Item = T; fn next(&mut self) -> Option { Some(self.0.input()) } fn size_hint(&self) -> (usize, Option) { (!0, None) } } pub trait InputItem: Sized { fn input(src: &mut I) -> Self; } impl InputItem for Vec { fn input(src: &mut I) -> Self { src.bytes().to_owned() } } macro_rules! from_str_impl { { $($T:ty)* } => { $(impl InputItem for $T { fn input(src: &mut I) -> Self { src.str().parse::<$T>().unwrap() } })* } } from_str_impl! { String char bool f32 f64 } macro_rules! parse_int_impl { { $($I:ty: $U:ty)* } => { $(impl InputItem for $I { fn input(src: &mut I) -> Self { let f = |s: &[u8]| s.iter().fold(0, |x, b| 10 * x + (b & 0xf) as $I); let s = src.bytes(); if let Some((&b'-', t)) = s.split_first() { -f(t) } else { f(s) } } } impl InputItem for $U { fn input(src: &mut I) -> Self { src.bytes().iter().fold(0, |x, b| 10 * x + (b & 0xf) as $U) } })* }; } parse_int_impl! { isize:usize i8:u8 i16:u16 i32:u32 i64:u64 i128:u128 } macro_rules! tuple_impl { ($H:ident $($T:ident)*) => { impl<$H: InputItem, $($T: InputItem),*> InputItem for ($H, $($T),*) { fn input(src: &mut I) -> Self { ($H::input(src), $($T::input(src)),*) } } tuple_impl!($($T)*); }; () => {} } tuple_impl!(A B C D E F G); macro_rules! array_impl { { $($N:literal)* } => { $(impl InputItem for [T; $N] { fn input(src: &mut I) -> Self { let mut arr = MaybeUninit::uninit(); unsafe { let ptr = arr.as_mut_ptr() as *mut T; for i in 0..$N { ptr.add(i).write(src.input()); } arr.assume_init() } } })* }; } array_impl! { 1 2 3 4 5 6 7 8 } pub trait Output: Write + Sized { fn bytes(&mut self, buf: &[u8]) { self.write_all(buf).unwrap(); } fn output(&mut self, x: T) { x.output(self); } fn outputln(&mut self, x: T) { self.output(x); self.ln(); } fn byte(&mut self, b: u8) { self.bytes(slice::from_ref(&b)); } fn ws(&mut self) { self.byte(b' '); } fn ln(&mut self) { self.byte(b'\n'); self.flush_debug(); } fn seq>(&mut self, iter: I, delim: u8) { let mut first = true; for x in iter.into_iter() { if !first { self.byte(delim); } first = false; self.output(x); } } fn flush_debug(&mut self) { if cfg!(debug_assertions) { self.flush().unwrap(); } } } impl Output for W {} pub trait OutputItem { fn output(self, dest: &mut O); } impl OutputItem for &str { fn output(self, dest: &mut O) { dest.bytes(self.as_bytes()); } } macro_rules! output_int_impl { ($conv:ident; $via:ident; $($T:ident)*) => { $(impl OutputItem for $T { fn output(self, dest: &mut O) { let mut buf = MaybeUninit::<[u8; 20]>::uninit(); unsafe { let ptr = buf.as_mut_ptr() as *mut u8; let ofs = $conv(self as $via, ptr, 20); dest.bytes(slice::from_raw_parts(ptr.add(ofs), 20 - ofs)); } } } impl OutputItem for &$T { fn output(self, dest: &mut O) { (*self).output(dest); } })* }; } output_int_impl!(i64_to_bytes; i64; i8 i16 i32 i64); output_int_impl!(u64_to_bytes; u64; u8 u16 u32 u64); static DEC_DIGITS_LUT: &[u8; 200] = b"0001020304050607080910111213141516171819\ 2021222324252627282930313233343536373839\ 4041424344454647484950515253545556575859\ 6061626364656667686970717273747576777879\ 8081828384858687888990919293949596979899"; unsafe fn i64_to_bytes(x: i64, buf: *mut u8, len: usize) -> usize { let (neg, x) = if x < 0 { (true, -x) } else { (false, x) }; let mut i = u64_to_bytes(x as u64, buf, len); if neg { i -= 1; *buf.add(i) = b'-'; } i } unsafe fn u64_to_bytes(mut x: u64, buf: *mut u8, len: usize) -> usize { let lut = DEC_DIGITS_LUT.as_ptr(); let mut i = len; while x >= 10000 { let rem = (x % 10000) as usize; i -= 4; ptr::copy_nonoverlapping(lut.add(2 * (rem / 100)), buf.add(i), 2); ptr::copy_nonoverlapping(lut.add(2 * (rem % 100)), buf.add(i + 2), 2); x /= 10000; } let mut x = x as usize; if x >= 100 { i -= 2; ptr::copy_nonoverlapping(lut.add(2 * (x % 100)), buf.add(i), 2); x /= 100; } if x >= 10 { i -= 2; ptr::copy_nonoverlapping(lut.add(2 * x), buf.add(i), 2); } else { i -= 1; *buf.add(i) = x as u8 + b'0'; } i } #[macro_export] macro_rules! kdbg { ($($v:expr),*) => { if cfg!(debug_assertions) { dbg!($($v),*) } else { ($($v),*) } } } }