結果
問題 | No.2821 A[i] ← 2A[j] - A[i] |
ユーザー |
![]() |
提出日時 | 2024-07-27 05:31:02 |
言語 | Rust (1.77.0) |
結果 |
WA
|
実行時間 | - |
コード長 | 25,909 bytes |
コンパイル時間 | 18,213 ms |
コンパイル使用メモリ | 387,312 KB |
実行使用メモリ | 6,948 KB |
最終ジャッジ日時 | 2024-07-27 05:31:24 |
合計ジャッジ時間 | 17,826 ms |
ジャッジサーバーID (参考情報) |
judge3 / judge1 |
(要ログイン)
テストケース
テストケース表示入力 | 結果 | 実行時間 実行使用メモリ |
---|---|---|
testcase_00 | AC | 1 ms
6,812 KB |
testcase_01 | AC | 23 ms
6,812 KB |
testcase_02 | WA | - |
testcase_03 | AC | 29 ms
6,940 KB |
testcase_04 | WA | - |
testcase_05 | AC | 18 ms
6,940 KB |
testcase_06 | WA | - |
testcase_07 | WA | - |
testcase_08 | WA | - |
testcase_09 | AC | 6 ms
6,944 KB |
testcase_10 | WA | - |
testcase_11 | WA | - |
testcase_12 | WA | - |
testcase_13 | WA | - |
testcase_14 | AC | 6 ms
6,944 KB |
testcase_15 | AC | 8 ms
6,940 KB |
testcase_16 | AC | 5 ms
6,944 KB |
testcase_17 | AC | 7 ms
6,940 KB |
testcase_18 | WA | - |
testcase_19 | WA | - |
testcase_20 | WA | - |
testcase_21 | AC | 1 ms
6,940 KB |
testcase_22 | AC | 1 ms
6,940 KB |
testcase_23 | WA | - |
testcase_24 | WA | - |
testcase_25 | WA | - |
testcase_26 | WA | - |
testcase_27 | AC | 1 ms
6,944 KB |
testcase_28 | WA | - |
testcase_29 | AC | 1 ms
6,944 KB |
testcase_30 | WA | - |
testcase_31 | WA | - |
testcase_32 | WA | - |
testcase_33 | AC | 1 ms
6,940 KB |
コンパイルメッセージ
warning: a method with this name may be added to the standard library in the future --> src/main.rs:175:36 | 175 | (self as $uty).isqrt() as Self | ^^^^^ ... 187 | int!(isize, usize); | ------------------ in this macro invocation | = warning: once this associated item is added to the standard library, the ambiguity may cause an error or change in behavior! = note: for more information, see issue #48919 <https://github.com/rust-lang/rust/issues/48919> = help: call with fully qualified syntax `int::UInt::isqrt(...)` to keep using the current method = note: `#[warn(unstable_name_collisions)]` on by default = note: this warning originates in the macro `int` (in Nightly builds, run with -Z macro-backtrace for more info) warning: a method with this name may be added to the standard library in the future --> src/main.rs:175:36 | 175 | (self as $uty).isqrt() as Self | ^^^^^ ... 188 | int!(i8, u8); | ------------ in this macro invocation | = warning: once this associated item is added to the standard library, the ambiguity may cause an error or change in behavior! = note: for more information, see issue #48919 <https://github.com/rust-lang/rust/issues/48919> = help: call with fully qualified syntax `int::UInt::isqrt(...)` to keep using the current method = note: this warning originates in the macro `int` (in Nightly builds, run with -Z macro-backtrace for more info) warning: a method with this name may be added to the standard library in the future --> src/main.rs:175:36 | 175 | (self as $uty).isqrt() as Self | ^^^^^ ... 189 | int!(i16, u16); | -------------- in this macro invocation | = warning: once this associated item is added to the standard library, the ambiguity may cause an error or c
ソースコード
#![allow(unused_imports)] use input2::*; use std::{ array, collections::*, io::{self, BufWriter, Read, Write}, }; fn run<I: Read, O: Write>(mut ss: Input<I>, mut out: O) { let t: u32 = 1; for _ in 0..t { case(&mut ss, &mut out); } } fn case<I: Read, O: Write>(ss: &mut Input<I>, mut out: O) { use int::*; let n: usize = ss.input(); let a0: i32 = ss.input(); let mut g = 0; wln!(out, "0"); for a in ss.seq::<i32>(n - 1) { g = g.gcd(a - a0); wln!(out, "{}", g); } } fn main() { let stdin = io::stdin(); let ss = Input::new(stdin.lock()); let stdout = io::stdout(); let out = BufWriter::new(stdout.lock()); run(ss, out); } pub mod int { use std::ops::*; pub trait UInt: Sized + Copy + Eq + Ord + Add<Output = Self> + Sub<Output = Self> + Mul<Output = Self> + Div<Output = Self> + Rem<Output = Self> { const ZERO: Self; const ONE: Self; fn div_floor(self, other: Self) -> Self; fn div_ceil(self, other: Self) -> Self; fn abs(self) -> Self; fn gcd(self, other: Self) -> Self; fn lcm(self, other: Self) -> Self { self / self.gcd(other) * other } fn isqrt(self) -> Self; fn quotients(self) -> Qutients<Self> { Qutients::new(self) } } pub trait Int: UInt + Neg<Output = Self> { fn ext_gcd(mut self, mut other: Self) -> (Self, Self, Self) { use std::mem::swap; let mut a = (Self::ONE, Self::ZERO); let mut b = (Self::ZERO, Self::ONE); while other != Self::ZERO { let d = self / other; self = self % other; swap(&mut self, &mut other); a.0 = a.0 - d * b.0; a.1 = a.1 - d * b.1; swap(&mut a, &mut b); } if self >= Self::ZERO { (self, a.0, a.1) } else { (-self, -a.0, -a.1) } } } pub fn crt<T: Int>(r1: T, m1: T, r2: T, m2: T) -> Option<(T, T)> { if m1 > m2 { return crt(r2, m2, r1, m1); } let (g, v1, _) = m1.ext_gcd(m2); if m1 == g { return if r1 == r2 % m1 { Some((r1, m1)) } else { None }; } if (r2 - r1) % g != T::ZERO { return None; } let u2 = m2 / g; let q = (r2 - r1) / g * v1 % u2; let q = if q >= T::ZERO { q } else { u2 + q }; let x = m1 * q + r1; Some((x, m1 * u2)) } macro_rules! common_fns { ($ ty : ty) => { const ZERO: Self = 0; const ONE: Self = 0; fn gcd(self, other: Self) -> Self { let x = self.abs(); let y = other.abs(); if x == 0 { return y; } if y == 0 { return x; } let tzx = x.trailing_zeros(); let tzy = y.trailing_zeros(); let tzg = tzx.min(tzy); let mut x = x >> tzx; let mut y = y >> tzy; while x != y { if x < y { std::mem::swap(&mut x, &mut y); } x -= y; x >>= x.trailing_zeros(); } x << tzg } }; } macro_rules! uint { ($ ty : ty) => { impl UInt for $ty { common_fns!($ty); fn abs(self) -> Self { self } fn div_floor(self, other: Self) -> Self { self / other } fn div_ceil(self, other: Self) -> Self { let q = self / other; let r = self % other; q + (r != 0) as Self } fn isqrt(self) -> Self { let mut res = 0; let mut diff = self; for exp in (0..=(Self::BITS - self.leading_zeros()) / 2).rev() { if let Some(new_diff) = diff.checked_sub((res << (exp + 1)) + (1 << (2 * exp))) { diff = new_diff; res += 1 << exp; } } res } } }; } macro_rules! int { ($ ty : ty , $ uty : ty) => { impl UInt for $ty { common_fns!($ty); fn abs(self) -> Self { self.abs() } fn div_floor(self, other: Self) -> Self { let q = self / other; let r = self % other; q - ((other ^ r < 0) as Self & (r != 0) as Self) } fn div_ceil(self, other: Self) -> Self { let q = self / other; let r = self % other; q + ((other ^ r > 0) as Self & (r != 0) as Self) } fn isqrt(self) -> Self { assert!(self >= 0, "the value is negative ({self})"); (self as $uty).isqrt() as Self } } impl Int for $ty {} }; } uint!(usize); uint!(u8); uint!(u16); uint!(u32); uint!(u64); uint!(u128); int!(isize, usize); int!(i8, u8); int!(i16, u16); int!(i32, u32); int!(i64, u64); int!(i128, u128); pub fn gcd<T: UInt>(x: T, y: T) -> T { x.gcd(y) } pub fn ext_gcd<T: Int>(x: T, y: T) -> (T, T, T) { x.ext_gcd(y) } pub fn lcm<T: UInt>(x: T, y: T) -> T { x.lcm(y) } #[derive(Debug, Clone)] pub struct Qutients<T> { n: T, ndivh: T, h: T, } impl<T: UInt> Qutients<T> { #[inline] fn new(n: T) -> Self { if n < T::ZERO { unimplemented!() } let mut h = UInt::isqrt(n); if n >= h * (h + T::ONE) { h = h + T::ONE; } Qutients { n, h, ndivh: n / h } } #[inline] pub fn get(&self, i: T) -> Option<T> { if i < self.ndivh { Some(i) } else if self.h > i - self.ndivh { let j = i - self.ndivh; Some(self.n / (self.h - j)) } else { None } } #[inline] pub fn count(&self) -> T { self.h + self.ndivh } pub fn iter(&self) -> QutientsIter<T> { QutientsIter { i: T::ZERO, q: self.clone(), } } } pub struct QutientsIter<T> { i: T, q: Qutients<T>, } impl<T: UInt + TryInto<usize>> Iterator for QutientsIter<T> { type Item = T; fn next(&mut self) -> Option<Self::Item> { let q = self.q.get(self.i)?; self.i = self.i + T::ONE; Some(q) } fn size_hint(&self) -> (usize, Option<usize>) { let len = (self.q.count() - self.i).try_into().unwrap_or(usize::MAX); (len, Some(len)) } } } pub mod input2 { use std::{ convert::TryInto, io::{self, Read}, marker::PhantomData, mem::{self, MaybeUninit}, ptr, slice, }; pub struct Input<R: ?Sized> { buf: Vec<u8>, pos: usize, len: usize, src: R, } macro_rules! def_input2 { ($ f : ident , $ ty : ty) => { pub fn $f(&mut self) -> $ty { self.input() } }; } macro_rules! def_input { ($ ty : ident) => { def_input2!($ty, $ty); }; } impl<R: Read> Input<R> { pub fn new(src: R) -> Self { Self::with_capacity(src, 1 << 20) } pub fn with_capacity(src: R, cap: usize) -> Self { Self { src, buf: vec![0; cap], pos: 0, len: 0, } } pub fn input<T: Parse>(&mut self) -> T { T::parse(self) } pub fn map<T, F: MapOnce<T>>(&mut self, f: F) -> F::Output { f.map(self) } pub fn seq<T: Parse>(&mut self, n: usize) -> Seq<T, R> { Seq { src: self, n, marker: PhantomData, } } pub fn seq_map<T, F: Map<T>>(&mut self, n: usize, f: F) -> SeqMap<T, F, R> { SeqMap { src: self, n, f, marker: PhantomData, } } pub fn vec<T: Parse>(&mut self, n: usize) -> Vec<T> { self.seq(n).collect() } pub fn map_vec<T, F: Map<T>>(&mut self, n: usize, f: F) -> Vec<F::Output> { self.seq_map(n, f).collect() } pub fn str(&mut self) -> &str { std::str::from_utf8(self.bytes()).expect("utf8 error") } pub fn bytes(&mut self) -> &[u8] { let range = self.bytes_inner(); unsafe { self.buf.get_unchecked(range) } } pub fn byte_vec(&mut self) -> Vec<u8> { let range = self.bytes_inner(); if range.start == 0 && 2 * range.end >= self.buf.len() { let buf_len = self.buf.len(); let mut new_buf = vec![0; buf_len]; new_buf[..self.len].copy_from_slice(self.remaining()); let mut res = mem::replace(&mut self.buf, new_buf); self.pos = 0; res.truncate(range.end); res } else { self.buf[range].to_vec() } } #[inline] fn bytes_inner(&mut self) -> std::ops::Range<usize> { let mut i = 0; loop { if self.len > 0 { if let Some(d) = find_ws(unsafe { self.buf.get_unchecked(self.pos + i..self.pos + self.len) }) { let del = i + d; let range = self.pos..self.pos + del; self.pos += del + 1; self.len -= del + 1; if del == 0 { continue; } return range; } i = self.len; } if self.read() == 0 { let range = self.pos..self.pos + self.len; self.pos = 0; self.len = 0; return range; } } } #[cold] fn read(&mut self) -> usize { if self.pos != 0 { self.buf.copy_within(self.pos..self.pos + self.len, 0); self.pos = 0; } if self.len == self.buf.len() { self.buf.resize((2 * self.buf.len()).max(1 << 13), 0); } loop { match self .src .read(unsafe { self.buf.get_unchecked_mut(self.len..) }) { Ok(n) => { self.len += n; return n; } Err(e) if e.kind() == io::ErrorKind::WouldBlock => {} Err(e) => panic!("io error: {}", e), } } } #[inline] fn remaining(&self) -> &[u8] { unsafe { self.buf.get_unchecked(self.pos..self.pos + self.len) } } def_input!(usize); def_input!(u8); def_input!(u16); def_input!(u32); def_input!(u64); def_input!(isize); def_input!(i8); def_input!(i16); def_input!(i32); def_input!(i64); def_input!(f32); def_input!(f64); def_input!(char); def_input2!(string, String); } pub trait Map<T> { type Output; fn map<R: Read>(&mut self, src: &mut Input<R>) -> Self::Output; } pub trait MapOnce<T> { type Output; fn map<R: Read>(self, src: &mut Input<R>) -> Self::Output; } macro_rules ! map { ($ ($ T : ident) ,*) => { impl <$ ($ T : Parse ,) * O , F : FnMut ($ ($ T) ,+) -> O > Map < fn ($ ($ T) ,+) > for F { type Output = O ; fn map < R : Read > (& mut self , src : & mut Input < R >) -> O { self ($ (src . input ::<$ T > ()) ,*) } } impl <$ ($ T : Parse ,) * O , F : FnOnce ($ ($ T) ,+) -> O > MapOnce < fn ($ ($ T) ,+) > for F { type Output = O ; fn map < R : Read > (self , src : & mut Input < R >) -> O { self ($ (src . input ::<$ T > ()) ,*) } } } ; } map!(A); map!(A, B); map!(A, B, C); map!(A, B, C, D); map!(A, B, C, D, E); const CHUNK_SIZE: usize = mem::size_of::<usize>(); #[inline] pub(crate) fn find_ws(s: &[u8]) -> Option<usize> { let offset = (32 + s.as_ptr().align_offset(CHUNK_SIZE)).min(s.len()); let mut i = 0; while i < offset { if s[i] <= b' ' { return Some(i); } i += 1; } if i < s.len() { find_ws_long(s, i) } else { None } } fn find_ws_long(s: &[u8], mut i: usize) -> Option<usize> { while i + CHUNK_SIZE <= s.len() { if let Some(j) = find_ws_usize(usize::from_le_bytes( unsafe { s.get_unchecked(i..i + CHUNK_SIZE) } .try_into() .unwrap(), )) { return Some(i + j); } i += CHUNK_SIZE; } while i < s.len() { if s[i] <= b' ' { return Some(i); } i += 1; } None } #[inline] fn find_ws_usize(s: usize) -> Option<usize> { const SUB: usize = 0x2121212121212121; const MASK: usize = 0x8080808080808080; let t = s.wrapping_sub(SUB) & MASK; (t != 0).then(|| (t.trailing_zeros() / 8) as usize) } pub struct Seq<'a, T, R> { src: &'a mut Input<R>, n: usize, marker: PhantomData<*const T>, } impl<'a, T: Parse, R: Read> Iterator for Seq<'a, T, R> { type Item = T; fn next(&mut self) -> Option<Self::Item> { if self.n > 0 { self.n -= 1; Some(self.src.input()) } else { None } } fn size_hint(&self) -> (usize, Option<usize>) { (self.len(), Some(self.len())) } } impl<'a, T: Parse, R: Read> ExactSizeIterator for Seq<'a, T, R> { fn len(&self) -> usize { self.n } } pub struct SeqMap<'a, T, F, R> { src: &'a mut Input<R>, n: usize, f: F, marker: PhantomData<*const T>, } impl<'a, T, F: Map<T>, R: Read> Iterator for SeqMap<'a, T, F, R> { type Item = F::Output; fn next(&mut self) -> Option<Self::Item> { if self.n > 0 { self.n -= 1; Some(self.f.map(self.src)) } else { None } } fn size_hint(&self) -> (usize, Option<usize>) { (self.len(), Some(self.len())) } } impl<'a, T, F: Map<T>, R: Read> ExactSizeIterator for SeqMap<'a, T, F, R> { fn len(&self) -> usize { self.n } } pub trait Parse { fn parse<T: Read>(src: &mut Input<T>) -> Self; } impl Parse for Vec<u8> { fn parse<T: Read>(src: &mut Input<T>) -> Self { src.byte_vec() } } impl Parse for String { fn parse<T: Read>(src: &mut Input<T>) -> Self { String::from_utf8(src.byte_vec()).unwrap() } } pub trait ParseBytes { fn parse_bytes(s: &[u8]) -> Self; } macro_rules! parse_int { ($ ty : ident , $ ity : ident) => { impl ParseBytes for $ty { fn parse_bytes(s: &[u8]) -> Self { $ty(s, 0) } } impl ParseBytes for $ity { fn parse_bytes(s: &[u8]) -> Self { let (minus, s) = if let Some((b'-', s)) = s.split_first() { (true, s) } else { (false, s) }; let x = $ty(s, 0); (if minus { (!x).wrapping_add(1) } else { x }) as $ity } } }; } parse_int!(usize, isize); parse_int!(u8, i8); parse_int!(u16, i16); parse_int!(u32, i32); parse_int!(u64, i64); macro_rules! parse { ($ ty : ident) => { impl Parse for $ty { fn parse<T: Read>(src: &mut Input<T>) -> Self { Self::parse_bytes(src.bytes()) } } }; } parse!(usize); parse!(u8); parse!(u16); parse!(u32); parse!(u64); parse!(isize); parse!(i8); parse!(i16); parse!(i32); parse!(i64); parse!(f32); parse!(f64); macro_rules ! tuple { ($ ($ T : ident) ,+) => { impl <$ ($ T : Parse) ,+> Parse for ($ ($ T ,) +) { fn parse < T : Read > (src : & mut Input < T >) -> Self { ($ ($ T :: parse (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); impl<T: Parse, const N: usize> Parse for [T; N] { fn parse<R: Read>(src: &mut Input<R>) -> Self { struct Guard<T> { ptr: *mut T, i: usize, } impl<T> Drop for Guard<T> { fn drop(&mut self) { unsafe { ptr::drop_in_place(slice::from_raw_parts_mut(self.ptr, self.i)); } } } let mut res: MaybeUninit<[T; N]> = MaybeUninit::uninit(); let mut g = Guard { ptr: res.as_mut_ptr() as *mut T, i: 0, }; unsafe { while g.i < N { g.ptr.add(g.i).write(src.input()); g.i += 1; } mem::forget(g); res.assume_init() } } } #[inline] fn toi8bytes(s: &[u8]) -> (u32, &[u8]) { let (p, rest) = s.split_at(8); let x = u64::from_le_bytes(p.try_into().unwrap()); const MASK1: u64 = 0x000f000f000f000f; let hi = (x >> 8) & MASK1; let lo = x & MASK1; let x = 10 * lo + hi; const MASK2: u64 = 0x0000ffff0000ffff; let hi = (x >> 16) & MASK2; let lo = x & MASK2; let x = 100 * lo + hi; let hi = (x >> 32) as u32; let lo = x as u32; let x = 10000 * lo + hi; (x, rest) } #[inline] fn toi4bytes(s: &[u8]) -> (u32, &[u8]) { let (p, rest) = s.split_at(4); let x = u32::from_le_bytes(p.try_into().unwrap()); const MASK: u32 = 0x000f000f; let hi = (x >> 8) & MASK; let lo = x & MASK; let x = 10 * lo + hi; let hi = x >> 16; let lo = x & 0x0000ffff; let x = 100 * lo + hi; (x, rest) } #[cfg(target_pointer_width = "32")] fn usize(s: &[u8], pre: usize) -> usize { u32(s, pre as u32) as usize } #[cfg(target_pointer_width = "64")] fn usize(s: &[u8], pre: usize) -> usize { u64(s, pre as u64) as usize } #[inline] fn u64(mut s: &[u8], pre: u64) -> u64 { let mut res = pre; while s.len() >= 8 { let (x, rest) = toi8bytes(s); res = 100000000 * res + x as u64; s = rest; } if s.len() >= 4 { let (x, rest) = toi4bytes(s); res = 10000 * res + x as u64; s = rest; } for &c in s { res = 10 * res + (c & 0xf) as u64; } res } #[inline] fn u32(mut s: &[u8], pre: u32) -> u32 { let mut res = pre; if s.len() >= 8 { let (x, rest) = toi8bytes(s); res = x; s = rest; } if s.len() >= 4 { let (x, rest) = toi4bytes(s); res = 10000 * res + x; s = rest; } for &c in s { res = 10 * res + (c & 0xf) as u32; } res } #[inline] fn u16(mut s: &[u8], pre: u16) -> u16 { let mut res = pre; if s.len() >= 4 { let (x, rest) = toi4bytes(s); res = 10000 * res + x as u16; s = rest; } for &c in s { res = 10 * res + (c & 0xf) as u16; } res } #[inline] fn u8(s: &[u8], pre: u8) -> u8 { let mut res = pre; for &c in s { res = 10 * res + (c & 0xf); } res } macro_rules! float { ($ ty : ident , $ uty : ident) => { impl ParseBytes for $ty { fn parse_bytes(s: &[u8]) -> Self { const TEN: [$ty; 18] = [ 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, ]; let (minus, s) = if let Some((b'-', s)) = s.split_first() { (true, s) } else { (false, s) }; let (int, fract) = if let Some(p) = s.iter().position(|c| *c == b'.') { (&s[..p], &s[p + 1..]) } else { (s, &s[..0]) }; let x = $uty(int, 0); let x = if fract.is_empty() { x as $ty } else { let ten = TEN .get(fract.len()) .copied() .unwrap_or_else(|| $ty::powi(10.0, fract.len() as _)); $uty(fract, x) as $ty / ten }; if minus { -x } else { x } } } }; } float!(f32, u32); float!(f64, u64); impl Parse for char { fn parse<T: Read>(src: &mut Input<T>) -> Self { let s = src.str(); let mut cs = s.chars(); match cs.next() { Some(c) if cs.as_str().is_empty() => c, _ => panic!("input is not single char"), } } } pub struct Byte(pub u8); impl Parse for Byte { fn parse<T: Read>(src: &mut Input<T>) -> Self { if let [b] = src.bytes() { Byte(*b) } else { panic!("input is not single byte") } } } } pub mod macros { #[macro_export] macro_rules ! w { ($ dst : expr , $ ($ arg : tt) *) => { if cfg ! (debug_assertions) && std :: io :: IsTerminal :: is_terminal (& std :: io :: stdout ()) { write ! ($ dst , "\x1B[1;33m{}\x1B[0m" , format_args ! ($ ($ arg) *)) . unwrap () ; } else { write ! ($ dst , $ ($ arg) *) . unwrap () ; } } } #[macro_export] macro_rules ! wln { ($ dst : expr) => { writeln ! ($ dst) . unwrap () ; # [cfg (debug_assertions)] $ dst . flush () . unwrap () ; } ; ($ dst : expr , $ ($ arg : tt) *) => { { if cfg ! (debug_assertions) && std :: io :: IsTerminal :: is_terminal (& std :: io :: stdout ()) { writeln ! ($ dst , "\x1B[1;33m{}\x1B[0m" , format_args ! ($ ($ arg) *)) . unwrap () ; } else { 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] #[doc(hidden)] 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) ,*) => { if std :: env :: var ("ND") . map (| v | & v == "0") . unwrap_or (true) { eln ! (__tstr ! ($ ($ a) ,*) , file ! () , line ! () , $ (stringify ! ($ a) , $ a) ,*) ; } } ; } }