#![allow(unused_imports)] use pio2::*; use std::{ collections::*, io::{self, prelude::*}, }; fn run(mut pin: I, mut out: O) { let n: usize = pin.parse(); let c: Vec = pin.seq(9).collect(); let mut ans = 0; for i in (1..=9).rev() { for _ in 0..c[i - 1] { ans = 10 * ans + i; } } wln!(out, "{}", ans); } fn main() { let stdin = io::stdin(); let mut pin = Scanner::new(stdin.lock()); let stdout = io::stdout(); let mut out = stdout.lock(); run(&mut pin, &mut out); } pub mod macros { #[macro_export] macro_rules ! w { ($ ($ arg : tt) *) => { write ! ($ ($ arg) *) . unwrap () ; } } #[macro_export] macro_rules ! wln { ($ dst : expr $ (, $ ($ arg : tt) *) ?) => { { writeln ! ($ dst $ (, $ ($ arg) *) ?) . unwrap () ; # [cfg (debug_assertions)] $ dst . flush () . unwrap () ; } } } #[macro_export] macro_rules! w_iter { ($dst:expr, $fmt:expr, $iter:expr, $delim:expr) => {{ let mut first = true; for elem in $iter { if first { w!($dst, $fmt, elem); first = false; } else { w!($dst, concat!($delim, $fmt), elem); } } }}; ($dst:expr, $fmt:expr, $iter:expr) => { w_iter!($dst, $fmt, $iter, " ") }; } #[macro_export] macro_rules ! w_iter_ln { ($ dst : expr , $ ($ t : tt) *) => { { w_iter ! ($ dst , $ ($ t) *) ; wln ! ($ dst) ; } } } #[macro_export] macro_rules ! e { ($ ($ t : tt) *) => { # [cfg (debug_assertions)] eprint ! ($ ($ t) *) } } #[macro_export] macro_rules ! eln { ($ ($ t : tt) *) => { # [cfg (debug_assertions)] eprintln ! ($ ($ t) *) } } #[macro_export] macro_rules ! __tstr { ($ h : expr $ (, $ t : expr) +) => { concat ! (__tstr ! ($ ($ t) ,+) , ", " , __tstr ! (@)) } ; ($ h : expr) => { concat ! (__tstr ! () , " " , __tstr ! (@)) } ; () => { "\x1B[94m[{}:{}]\x1B[0m" } ; (@) => { "\x1B[1;92m{}\x1B[0m = {:?}" } } #[macro_export] macro_rules ! d { ($ ($ a : expr) ,*) => { eln ! (__tstr ! ($ ($ a) ,*) , file ! () , line ! () , $ (stringify ! ($ a) , $ a) ,*) } ; } } pub mod pio2 { use std::{ io::prelude::*, marker::PhantomData, mem::{self, MaybeUninit}, str, }; pub trait Input { fn bytes(&mut self) -> &[u8]; fn str(&mut self) -> &str { str::from_utf8(self.bytes()).unwrap() } fn parse(&mut self) -> T where DefaultParser: Parser, { self.parse_with(DefaultParser) } fn parse_with>(&mut self, mut parser: P) -> T { parser.parse(self) } fn seq(&mut self, n: usize) -> Seq where DefaultParser: Parser, { self.seq_with(n, DefaultParser) } fn seq_with>(&mut self, n: usize, parser: P) -> Seq { Seq { src: self, rest: n, parser, phantom: PhantomData, } } } impl Input for &mut I { fn bytes(&mut self) -> &[u8] { (**self).bytes() } } pub struct Scanner { src: R, buf: Vec, pos: usize, len: usize, } impl Scanner { pub fn new(src: R) -> Self { Self { src, buf: vec![0; 1 << 16], pos: 0, len: 0, } } 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 n = self.src.read(&mut self.buf[self.len..]).unwrap(); self.len += n; assert!(self.len <= self.buf.len()); n } } impl Input for Scanner { fn bytes(&mut self) -> &[u8] { loop { while let Some(d) = unsafe { self.buf.get_unchecked(self.pos..self.len) } .iter() .position(u8::is_ascii_whitespace) { let p = self.pos; self.pos += d + 1; if d > 0 { return unsafe { self.buf.get_unchecked(p..p + d) }; } } if self.read() == 0 { let p = self.pos; if p == self.len { panic!("reached EOF"); } self.pos = self.len; return unsafe { self.buf.get_unchecked(p..self.len) }; } } } } pub struct Seq<'a, I: ?Sized, T, P> { src: &'a mut I, rest: usize, parser: P, phantom: PhantomData<*const T>, } impl<'a, I: Input + ?Sized, T, P: Parser> Iterator for Seq<'a, I, T, P> { type Item = T; fn next(&mut self) -> Option { if self.rest > 0 { self.rest -= 1; Some(self.src.parse_with(&mut self.parser)) } else { None } } fn size_hint(&self) -> (usize, Option) { (self.rest, Some(self.rest)) } } impl<'a, I: Input + ?Sized, T, P: Parser> ExactSizeIterator for Seq<'a, I, T, P> {} pub trait Parser { fn parse(&mut self, src: &mut I) -> T; } impl> Parser for &mut P { fn parse(&mut self, src: &mut I) -> T { (*self).parse(src) } } #[derive(Clone, Copy, Debug)] pub struct DefaultParser; macro_rules! int { ($ty:ident) => { impl Parser<$ty> for DefaultParser { fn parse(&mut self, src: &mut I) -> $ty { let f = |s: &[u8]| s.iter().fold(0, |x, b| 10 * x + (b & 0xf) as $ty); let s = src.bytes(); if let Some((&b'-', t)) = s.split_first() { -f(t) } else { f(s) } } } }; } int!(isize); int!(i8); int!(i16); int!(i32); int!(i64); int!(i128); macro_rules! uint { ($ty:ident) => { impl Parser<$ty> for DefaultParser { fn parse(&mut self, src: &mut I) -> $ty { src.bytes().iter().fold(0, |x, b| 10 * x + (b & 0xf) as $ty) } } }; } uint!(usize); uint!(u8); uint!(u16); uint!(u32); uint!(u64); uint!(u128); macro_rules! from_bytes { ($ty:ty) => { impl Parser<$ty> for DefaultParser { fn parse(&mut self, src: &mut I) -> $ty { src.bytes().into() } } }; } from_bytes!(Vec); from_bytes!(Box<[u8]>); macro_rules! from_str { ($ty:ident) => { impl Parser<$ty> for DefaultParser { fn parse(&mut self, src: &mut I) -> $ty { src.str().parse::<$ty>().expect("failed to parse") } } }; } from_str!(String); from_str!(char); from_str!(f32); from_str!(f64); macro_rules ! tuple { ($ ($ T : ident) ,+) => { impl <$ ($ T) ,+> Parser < ($ ($ T ,) +) > for DefaultParser where $ (DefaultParser : Parser <$ T >) ,+ { fn parse < I : Input + ? Sized > (& mut self , src : & mut I) -> ($ ($ T ,) +) { ($ (< Self as Parser <$ T >>:: parse (self , src) ,) +) } } } ; } tuple!(A); tuple!(A, B); tuple!(A, B, C); tuple!(A, B, C, D); tuple!(A, B, C, D, E); tuple!(A, B, C, D, E, F); tuple!(A, B, C, D, E, F, G); tuple!(A, B, C, D, E, F, G, H); macro_rules ! array { ($ ($ N : literal) *) => { $ (impl < T > Parser < [T ; $ N] > for DefaultParser where DefaultParser : Parser < T > { fn parse < I : Input + ? Sized > (& mut self , src : & mut I) -> [T ; $ N] { unsafe { let mut arr : [MaybeUninit < T >; $ N] = MaybeUninit :: uninit () . assume_init () ; for elem in & mut arr { * elem = MaybeUninit :: new (src . parse ()) ; } mem :: transmute_copy (& arr) } } }) * } } array ! (1 2 3 4 5 6 7 8); }