competitive/tools/
fastio.rs1use std::{
2 ffi::{c_int, c_void},
3 fs::File,
4 io::{BufWriter, Read, StdoutLock, Write, stdout},
5 os::fd::FromRawFd,
6 ptr,
7 str::FromStr,
8};
9
10unsafe extern "C" {
11 fn mmap(
12 addr: *mut c_void,
13 len: usize,
14 prot: c_int,
15 flags: c_int,
16 fd: c_int,
17 offset: isize,
18 ) -> *mut c_void;
19}
20
21pub struct FastInput {
22 ptr: *const u8,
23}
24
25impl FastInput {
26 pub unsafe fn stdin() -> Self {
27 unsafe {
28 let mut stdin = File::from_raw_fd(0);
29 let ptr = if let Ok(metadata) = stdin.metadata() {
30 let len = metadata.len() as usize;
31 mmap(ptr::null_mut(), len, 1, 2, 0, 0) as *const u8
32 } else {
33 let mut buf = vec![];
34 stdin.read_to_end(&mut buf).unwrap();
35 Box::into_raw(buf.into_boxed_slice()) as *const u8
36 };
37 FastInput { ptr }
38 }
39 }
40
41 pub unsafe fn from_slice(s: &[u8]) -> Self {
42 FastInput { ptr: s.as_ptr() }
43 }
44
45 unsafe fn fetch_ud4(&mut self) -> u16 {
46 unsafe {
47 let mut x: u32 = ptr::read_unaligned(self.ptr as *const u32);
48 x ^= 0x30303030;
49 let tmp = (x & 0xf0f0f0f0).trailing_zeros() >> 3;
50 x <<= 32 - (tmp << 3);
51 x = x.wrapping_mul(10).wrapping_add(x >> 8) & 0x00ff00ff;
52 x = x.wrapping_mul(100).wrapping_add(x >> 16) & 0x0000ffff;
53 self.ptr = self.ptr.add((tmp + 1) as usize);
54 x as u16
55 }
56 }
57
58 unsafe fn fetch_ud8(&mut self) -> u32 {
59 unsafe {
60 let mut x: u64 = ptr::read_unaligned(self.ptr as *const u64);
61 x ^= 0x3030303030303030;
62 let tmp = (x & 0xf0f0f0f0f0f0f0f0).trailing_zeros() >> 3;
63 x <<= 64 - (tmp << 3);
64 x = x.wrapping_mul(10).wrapping_add(x >> 8) & 0x00ff00ff00ff00ff;
65 x = x.wrapping_mul(100).wrapping_add(x >> 16) & 0x0000ffff0000ffff;
66 x = x.wrapping_mul(10000).wrapping_add(x >> 32) & 0x00000000ffffffff;
67 self.ptr = self.ptr.add((tmp + 1) as usize);
68 x as u32
69 }
70 }
71
72 pub unsafe fn u8(&mut self) -> u8 {
73 unsafe { self.fetch_ud4() as u8 }
74 }
75
76 pub unsafe fn u16(&mut self) -> u16 {
77 unsafe { self.fetch_ud8() as u16 }
78 }
79
80 pub unsafe fn u32_small(&mut self) -> u32 {
82 unsafe { self.fetch_ud8() }
83 }
84
85 pub unsafe fn u32(&mut self) -> u32 {
86 unsafe {
87 let mut res = 0u32;
88 let mut buf: [u64; 2] = ptr::read_unaligned(self.ptr as *const [u64; 2]);
89 buf[0] ^= 0x3030303030303030;
90 buf[1] ^= 0x3030303030303030;
91 let mut rem;
92 {
93 let mut x = buf[0];
94 rem = x;
95 if (x & 0xf0f0f0f0f0f0f0f0) == 0 {
96 rem = buf[1];
97 x = x.wrapping_mul(10).wrapping_add(x >> 8) & 0x00ff00ff00ff00ff;
98 x = x.wrapping_mul(100).wrapping_add(x >> 16) & 0x0000ffff0000ffff;
99 x = x.wrapping_mul(10000).wrapping_add(x >> 32) & 0x00000000ffffffff;
100 res = x as u32;
101 self.ptr = self.ptr.add(8);
102 }
103 }
104 {
105 let mut x = (rem & 0xffffffff) as u32;
106 if (x & 0xf0f0f0f0) == 0 {
107 rem >>= 32;
108 x = x.wrapping_mul(10).wrapping_add(x >> 8) & 0x00ff00ff;
109 x = x.wrapping_mul(100).wrapping_add(x >> 16) & 0x0000ffff;
110 res = res.wrapping_mul(10000).wrapping_add(x);
111 self.ptr = self.ptr.add(4);
112 }
113 }
114 {
115 let mut x = (rem & 0xffff) as u16;
116 if (x & 0xf0f0) == 0 {
117 rem >>= 16;
118 x = x.wrapping_mul(10).wrapping_add(x >> 8) & 0x00ff;
119 res = res.wrapping_mul(100).wrapping_add(x as u32);
120 self.ptr = self.ptr.add(2);
121 }
122 }
123 {
124 let x = (rem & 0xf0) == 0;
125 if x {
126 res = res.wrapping_mul(10).wrapping_add((rem & 0xff) as u32);
127 }
128 self.ptr = self.ptr.add(x as usize + 1);
129 }
130 res
131 }
132 }
133
134 pub unsafe fn u64(&mut self) -> u64 {
135 unsafe {
136 let mut res;
137 let mut x = ptr::read_unaligned(self.ptr as *const u64);
138 x ^= 0x3030303030303030;
139 if (x & 0xf0f0f0f0f0f0f0f0) == 0 {
140 self.ptr = self.ptr.add(8);
141 let mut y = ptr::read_unaligned(self.ptr as *const u64);
142 x = x.wrapping_mul(10).wrapping_add(x >> 8) & 0x00ff00ff00ff00ff;
143 x = x.wrapping_mul(100).wrapping_add(x >> 16) & 0x0000ffff0000ffff;
144 x = x.wrapping_mul(10000).wrapping_add(x >> 32) & 0x00000000ffffffff;
145 res = x;
146 y ^= 0x3030303030303030;
147 if (y & 0xf0f0f0f0f0f0f0f0) == 0 {
148 self.ptr = self.ptr.add(8);
149 y = y.wrapping_mul(10).wrapping_add(y >> 8) & 0x00ff00ff00ff00ff;
150 y = y.wrapping_mul(100).wrapping_add(y >> 16) & 0x0000ffff0000ffff;
151 y = y.wrapping_mul(10000).wrapping_add(y >> 32) & 0x00000000ffffffff;
152 res = res.wrapping_mul(100000000).wrapping_add(y);
153 let mut rem = ptr::read_unaligned(self.ptr as *const u32);
154 rem ^= 0x30303030;
155 if (rem & 0xf0f0f0f0) == 0 {
156 rem = rem.wrapping_mul(10).wrapping_add(rem >> 8) & 0x00ff00ff;
157 rem = rem.wrapping_mul(100).wrapping_add(rem >> 16) & 0x0000ffff;
158 res = res.wrapping_mul(10000).wrapping_add(rem as u64);
159 self.ptr = self.ptr.add(5);
160 } else if (rem & 0xf0f0f0) == 0 {
161 res = res.wrapping_mul(1000).wrapping_add(
162 ((rem & 0xff) as u64)
163 .wrapping_mul(100)
164 .wrapping_add((((rem.wrapping_mul(2561)) & 0xff0000) >> 16) as u64),
165 );
166 self.ptr = self.ptr.add(4);
167 } else if (rem & 0xf0f0) == 0 {
168 res = res.wrapping_mul(100).wrapping_add(
169 (((rem >> 8).wrapping_add(rem.wrapping_mul(10))) & 0xff) as u64,
170 );
171 self.ptr = self.ptr.add(3);
172 } else if (rem & 0xf0) == 0 {
173 res = res.wrapping_mul(10).wrapping_add((rem & 0x0000000f) as u64);
174 self.ptr = self.ptr.add(2);
175 } else {
176 self.ptr = self.ptr.add(1);
177 }
178 } else {
179 let mut x = (y & 0xffffffff) as u32;
180 if (x & 0xf0f0f0f0) == 0 {
181 y >>= 32;
182 x = x.wrapping_mul(10).wrapping_add(x >> 8) & 0x00ff00ff;
183 x = x.wrapping_mul(100).wrapping_add(x >> 16) & 0x0000ffff;
184 res = res.wrapping_mul(10000).wrapping_add(x as u64);
185 self.ptr = self.ptr.add(4);
186 }
187 let mut x = (y & 0xffff) as u16;
188 if (x & 0xf0f0) == 0 {
189 y >>= 16;
190 x = x.wrapping_mul(10).wrapping_add(x >> 8) & 0x00ff;
191 res = res.wrapping_mul(100).wrapping_add(x as u64);
192 self.ptr = self.ptr.add(2);
193 }
194 let x = (y & 0xf0) == 0;
195 if x {
196 res = res.wrapping_mul(10).wrapping_add(y & 0xff);
197 }
198 self.ptr = self.ptr.add(x as usize + 1);
199 }
200 } else {
201 let tmp = (x & 0xf0f0f0f0f0f0f0f0).trailing_zeros() >> 3;
202 x = x.wrapping_shl(64 - (tmp << 3));
203 x = x.wrapping_mul(10).wrapping_add(x >> 8) & 0x00ff00ff00ff00ff;
204 x = x.wrapping_mul(100).wrapping_add(x >> 16) & 0x0000ffff0000ffff;
205 x = x.wrapping_mul(10000).wrapping_add(x >> 32) & 0x00000000ffffffff;
206 res = x;
207 self.ptr = self.ptr.add((tmp + 1) as usize);
208 }
209 res
210 }
211 }
212
213 pub unsafe fn u128(&mut self) -> u128 {
214 unsafe {
215 let mut res = 0u128;
216 for i in 0..4 {
217 let mut x = ptr::read_unaligned(self.ptr as *const u64);
218 x ^= 0x3030303030303030;
219 if (x & 0xf0f0f0f0f0f0f0f0) != 0 {
220 break;
221 }
222 x = x.wrapping_mul(10).wrapping_add(x >> 8) & 0x00ff00ff00ff00ff;
223 x = x.wrapping_mul(100).wrapping_add(x >> 16) & 0x0000ffff0000ffff;
224 x = x.wrapping_mul(10000).wrapping_add(x >> 32) & 0x00000000ffffffff;
225 if i == 0 {
226 res = x as u128;
227 } else {
228 res = res.wrapping_mul(100000000).wrapping_add(x as u128);
229 }
230 self.ptr = self.ptr.add(8);
231 }
232 let mut res2 = 0u64;
233 let mut pow = 1u64;
234 let mut x = ptr::read_unaligned(self.ptr as *const u64);
235 x ^= 0x3030303030303030;
236 let mut rem = x;
237 if (x & 0xf0f0f0f0) == 0 {
238 rem >>= 32;
239 x = x.wrapping_mul(10).wrapping_add(x >> 8) & 0x00ff00ff;
240 x = x.wrapping_mul(100).wrapping_add(x >> 16) & 0x0000ffff;
241 res2 = x;
242 pow = 10000;
243 self.ptr = self.ptr.add(4);
244 }
245 {
246 let mut x = (rem & 0xffff) as u16;
247 if (x & 0xf0f0) == 0 {
248 rem >>= 16;
249 x = x.wrapping_mul(10).wrapping_add(x >> 8) & 0x00ff;
250 res2 = res2.wrapping_mul(100).wrapping_add(x as u64);
251 pow = pow.wrapping_mul(100);
252 self.ptr = self.ptr.add(2);
253 }
254 }
255 {
256 let x = (rem & 0xf0) == 0;
257 if x {
258 res2 = res2.wrapping_mul(10).wrapping_add(rem & 0xff);
259 pow = pow.wrapping_mul(10);
260 }
261 self.ptr = self.ptr.add(x as usize + 1);
262 }
263 res = res.wrapping_mul(pow as u128).wrapping_add(res2 as u128);
264 res
265 }
266 }
267
268 pub unsafe fn usize(&mut self) -> usize {
269 unsafe { self.u64() as usize }
270 }
271
272 pub unsafe fn i8(&mut self) -> i8 {
273 unsafe {
274 let b = *self.ptr == b'-';
275 self.ptr = self.ptr.add(b as usize);
276 let mut x = self.u8() as i8;
277 if b {
278 x = x.wrapping_neg();
279 }
280 x
281 }
282 }
283
284 pub unsafe fn i16(&mut self) -> i16 {
285 unsafe {
286 let b = *self.ptr == b'-';
287 self.ptr = self.ptr.add(b as usize);
288 let mut x = self.u16() as i16;
289 if b {
290 x = x.wrapping_neg();
291 }
292 x
293 }
294 }
295
296 pub unsafe fn i32(&mut self) -> i32 {
297 unsafe {
298 let b = *self.ptr == b'-';
299 self.ptr = self.ptr.add(b as usize);
300 let mut x = self.u32() as i32;
301 if b {
302 x = x.wrapping_neg();
303 }
304 x
305 }
306 }
307
308 pub unsafe fn i64(&mut self) -> i64 {
309 unsafe {
310 let b = *self.ptr == b'-';
311 self.ptr = self.ptr.add(b as usize);
312 let mut x = self.u64() as i64;
313 if b {
314 x = x.wrapping_neg();
315 }
316 x
317 }
318 }
319
320 pub unsafe fn i128(&mut self) -> i128 {
321 unsafe {
322 let b = *self.ptr == b'-';
323 self.ptr = self.ptr.add(b as usize);
324 let mut x = self.u128() as i128;
325 if b {
326 x = x.wrapping_neg();
327 }
328 x
329 }
330 }
331
332 pub unsafe fn isize(&mut self) -> isize {
333 unsafe { self.i64() as isize }
334 }
335
336 pub unsafe fn byte(&mut self) -> u8 {
337 unsafe {
338 let c = *self.ptr;
339 self.ptr = self.ptr.add(2);
340 c
341 }
342 }
343
344 pub unsafe fn bytes<'a>(&mut self) -> &'a [u8] {
345 unsafe {
346 let start = self.ptr;
347 while !(*self.ptr).is_ascii_whitespace() {
348 self.ptr = self.ptr.add(1);
349 }
350 let len = self.ptr.offset_from(start) as usize;
351 self.ptr = self.ptr.add(1);
352 std::slice::from_raw_parts(start, len)
353 }
354 }
355
356 pub unsafe fn parse<T>(&mut self) -> T
357 where
358 T: FromStr,
359 {
360 unsafe {
361 let s = std::str::from_utf8_unchecked(self.bytes());
362 s.parse().ok().unwrap()
363 }
364 }
365}
366
367static DIGIT4: [[u8; 4]; 10000] = const {
368 let mut arr = [[b' '; 4]; 10000];
369 let mut i = 0;
370 while i < 10000 {
371 let mut x = i;
372 let mut j = 4;
373 while j > 0 {
374 j -= 1;
375 arr[i][j] = b'0' + (x % 10) as u8;
376 x /= 10;
377 }
378 i += 1;
379 }
380 arr
381};
382
383pub struct FastOutput<W>
384where
385 W: Write,
386{
387 buf: BufWriter<W>,
388}
389
390impl FastOutput<StdoutLock<'static>> {
391 pub fn stdout() -> Self {
392 Self::with_capacity(1 << 12, stdout().lock())
393 }
394}
395
396impl<W> FastOutput<W>
397where
398 W: Write,
399{
400 pub fn new(writer: W) -> Self {
401 FastOutput {
402 buf: BufWriter::new(writer),
403 }
404 }
405
406 pub fn with_capacity(capacity: usize, writer: W) -> Self {
407 FastOutput {
408 buf: BufWriter::with_capacity(capacity, writer),
409 }
410 }
411
412 pub fn flush(&mut self) {
413 self.buf.flush().unwrap();
414 }
415
416 fn write_digit4(&mut self, x: usize) {
417 debug_assert!(x < 10000);
418 self.buf.write_all(&DIGIT4[x]).unwrap();
419 }
420
421 fn write_digit4_trimmed(&mut self, x: usize) {
422 debug_assert!(x < 10000);
423 let off = (x < 10) as u8 + (x < 100) as u8 + (x < 1000) as u8;
424 self.buf.write_all(&DIGIT4[x][off as usize..]).unwrap();
425 }
426
427 pub fn u8(&mut self, x: u8) {
428 let off = (x < 10) as u8 + (x < 100) as u8 + 1;
429 self.buf
430 .write_all(&DIGIT4[x as usize][off as usize..])
431 .unwrap();
432 }
433
434 pub fn u16(&mut self, x: u16) {
435 if x >= 10000 {
436 self.write_digit4_trimmed((x / 10000) as usize);
437 self.write_digit4((x % 10000) as usize);
438 } else {
439 self.write_digit4_trimmed(x as usize);
440 }
441 }
442
443 pub fn u32(&mut self, x: u32) {
444 if x >= 1_0000_0000 {
445 let b = x / 10000;
446 let a = b / 10000;
447 self.write_digit4_trimmed(a as usize);
448 self.write_digit4((b % 10000) as usize);
449 self.write_digit4((x % 10000) as usize);
450 } else if x >= 10000 {
451 self.write_digit4_trimmed((x / 10000) as usize);
452 self.write_digit4((x % 10000) as usize);
453 } else {
454 self.write_digit4_trimmed(x as usize);
455 }
456 }
457
458 pub fn u64(&mut self, x: u64) {
459 if x >= 1_0000_0000_0000_0000 {
460 let d = x / 10000;
461 let c = d / 10000;
462 let b = c / 10000;
463 let a = b / 10000;
464 self.write_digit4_trimmed(a as usize);
465 self.write_digit4((b % 10000) as usize);
466 self.write_digit4((c % 10000) as usize);
467 self.write_digit4((d % 10000) as usize);
468 self.write_digit4((x % 10000) as usize);
469 } else if x >= 1_0000_0000_0000 {
470 let c = x / 10000;
471 let b = c / 10000;
472 let a = b / 10000;
473 self.write_digit4_trimmed(a as usize);
474 self.write_digit4((b % 10000) as usize);
475 self.write_digit4((c % 10000) as usize);
476 self.write_digit4((x % 10000) as usize);
477 } else if x >= 1_0000_0000 {
478 let b = x / 10000;
479 let a = b / 10000;
480 self.write_digit4_trimmed(a as usize);
481 self.write_digit4((b % 10000) as usize);
482 self.write_digit4((x % 10000) as usize);
483 } else if x >= 10000 {
484 self.write_digit4_trimmed((x / 10000) as usize);
485 self.write_digit4((x % 10000) as usize);
486 } else {
487 self.write_digit4_trimmed(x as usize);
488 }
489 }
490
491 pub fn i8(&mut self, x: i8) {
492 if x < 0 {
493 self.buf.write_all(b"-").unwrap();
494 self.u8(x.wrapping_neg() as u8);
495 } else {
496 self.u8(x as u8);
497 }
498 }
499
500 pub fn i16(&mut self, x: i16) {
501 if x < 0 {
502 self.buf.write_all(b"-").unwrap();
503 self.u16(x.wrapping_neg() as u16);
504 } else {
505 self.u16(x as u16);
506 }
507 }
508
509 pub fn i32(&mut self, x: i32) {
510 if x < 0 {
511 self.buf.write_all(b"-").unwrap();
512 self.u32(x.wrapping_neg() as u32);
513 } else {
514 self.u32(x as u32);
515 }
516 }
517
518 pub fn i64(&mut self, x: i64) {
519 if x < 0 {
520 self.buf.write_all(b"-").unwrap();
521 self.u64(x.wrapping_neg() as u64);
522 } else {
523 self.u64(x as u64);
524 }
525 }
526
527 pub fn byte(&mut self, b: u8) {
528 self.buf.write_all(&[b]).unwrap();
529 }
530
531 pub fn bytes(&mut self, s: &[u8]) {
532 self.buf.write_all(s).unwrap();
533 }
534}
535
536#[cfg(test)]
537mod tests {
538 use super::*;
539 use crate::tools::Xorshift;
540
541 #[test]
542 fn test_past_input_u8() {
543 let mut a = vec![];
544 let mut s = String::new();
545 for i in 0..=u8::MAX {
546 a.push(i);
547 s.push_str(&format!("{}\n", i));
548 }
549 let mut fi = unsafe { FastInput::from_slice(s.as_bytes()) };
550 for a in a {
551 let x = unsafe { fi.u8() };
552 assert_eq!(x, a);
553 }
554 }
555
556 #[test]
557 fn test_past_input_u16() {
558 let mut a = vec![];
559 let mut s = String::new();
560 for i in 0..=u16::MAX {
561 a.push(i);
562 s.push_str(&format!("{}\n", i));
563 }
564 let mut fi = unsafe { FastInput::from_slice(s.as_bytes()) };
565 for a in a {
566 let x = unsafe { fi.u16() };
567 assert_eq!(x, a);
568 }
569 }
570
571 #[test]
572 fn test_past_input_u32() {
573 let mut rng = Xorshift::default();
574 let mut a = vec![];
575 let mut s = String::new();
576 for _ in 0..100_000 {
577 let k = rng.random(0..=u32::BITS);
578 let i = rng.random(0..=u32::MAX.wrapping_shr(u32::BITS - k));
579 a.push(i);
580 s.push_str(&format!("{}\n", i));
581 }
582 let mut fi = unsafe { FastInput::from_slice(s.as_bytes()) };
583 for a in a {
584 let x = unsafe { fi.u32() };
585 assert_eq!(x, a);
586 }
587 }
588
589 #[test]
590 fn test_past_input_u64() {
591 let mut rng = Xorshift::default();
592 let mut a = vec![];
593 let mut s = String::new();
594 for _ in 0..100_000 {
595 let k = rng.random(0..=u64::BITS);
596 let i = rng.random(0..=u64::MAX.wrapping_shr(u64::BITS - k));
597 a.push(i);
598 s.push_str(&format!("{}\n", i));
599 }
600 let mut fi = unsafe { FastInput::from_slice(s.as_bytes()) };
601 for a in a {
602 let x = unsafe { fi.u64() };
603 assert_eq!(x, a);
604 }
605 }
606
607 #[test]
608 fn test_past_input_u128() {
609 let mut rng = Xorshift::default();
610 let mut a = vec![];
611 let mut s = String::new();
612 for _ in 0..100_000 {
613 let k = rng.random(0..=u128::BITS);
614 let i = rng.random(0..=u128::MAX.wrapping_shr(u128::BITS - k));
615 a.push(i);
616 s.push_str(&format!("{}\n", i));
617 }
618 let mut fi = unsafe { FastInput::from_slice(s.as_bytes()) };
619 for a in a {
620 let x = unsafe { fi.u128() };
621 assert_eq!(x, a);
622 }
623 }
624
625 #[test]
626 fn test_past_input_i8() {
627 let mut a = vec![];
628 let mut s = String::new();
629 for i in i8::MIN..=i8::MAX {
630 a.push(i);
631 s.push_str(&format!("{}\n", i));
632 }
633 let mut fi = unsafe { FastInput::from_slice(s.as_bytes()) };
634 for a in a {
635 let x = unsafe { fi.i8() };
636 assert_eq!(x, a);
637 }
638 }
639
640 #[test]
641 fn test_past_input_i16() {
642 let mut a = vec![];
643 let mut s = String::new();
644 for i in i16::MIN..=i16::MAX {
645 a.push(i);
646 s.push_str(&format!("{}\n", i));
647 }
648 let mut fi = unsafe { FastInput::from_slice(s.as_bytes()) };
649 for a in a {
650 let x = unsafe { fi.i16() };
651 assert_eq!(x, a);
652 }
653 }
654
655 #[test]
656 fn test_past_input_i32() {
657 let mut rng = Xorshift::default();
658 let mut a = vec![];
659 let mut s = String::new();
660 for _ in 0..100_000 {
661 let k = rng.random(0..=u32::BITS);
662 let i = rng
663 .random(0..=u32::MAX.wrapping_shr(u32::BITS - k))
664 .cast_signed();
665 a.push(i);
666 s.push_str(&format!("{}\n", i));
667 }
668 let mut fi = unsafe { FastInput::from_slice(s.as_bytes()) };
669 for a in a {
670 let x = unsafe { fi.i32() };
671 assert_eq!(x, a);
672 }
673 }
674
675 #[test]
676 fn test_past_input_i64() {
677 let mut rng = Xorshift::default();
678 let mut a = vec![];
679 let mut s = String::new();
680 for _ in 0..100_000 {
681 let k = rng.random(0..=u64::BITS);
682 let i = rng
683 .random(0..=u64::MAX.wrapping_shr(u64::BITS - k))
684 .cast_signed();
685 a.push(i);
686 s.push_str(&format!("{}\n", i));
687 }
688 let mut fi = unsafe { FastInput::from_slice(s.as_bytes()) };
689 for a in a {
690 let x = unsafe { fi.i64() };
691 assert_eq!(x, a);
692 }
693 }
694
695 #[test]
696 fn test_past_input_i128() {
697 let mut rng = Xorshift::default();
698 let mut a = vec![];
699 let mut s = String::new();
700 for _ in 0..100_000 {
701 let k = rng.random(0..=u128::BITS);
702 let i = rng
703 .random(0..=u128::MAX.wrapping_shr(u128::BITS - k))
704 .cast_signed();
705 a.push(i);
706 s.push_str(&format!("{}\n", i));
707 }
708 let mut fi = unsafe { FastInput::from_slice(s.as_bytes()) };
709 for a in a {
710 let x = unsafe { fi.i128() };
711 assert_eq!(x, a);
712 }
713 }
714
715 #[test]
716 fn test_fast_output_u8() {
717 let mut fo = FastOutput::new(Vec::new());
718 for i in 0..=u8::MAX {
719 fo.u8(i);
720 fo.byte(b'\n');
721 }
722 let buf = fo.buf.into_inner().unwrap();
723 let s = String::from_utf8(buf).unwrap();
724 let mut lines = s.lines();
725 for i in 0..=u8::MAX {
726 let line = lines.next().unwrap();
727 assert_eq!(line, i.to_string());
728 }
729 }
730
731 #[test]
732 fn test_fast_output_u16() {
733 let mut fo = FastOutput::new(Vec::new());
734 for i in 0..=u16::MAX {
735 fo.u16(i);
736 fo.byte(b'\n');
737 }
738 let buf = fo.buf.into_inner().unwrap();
739 let s = String::from_utf8(buf).unwrap();
740 let mut lines = s.lines();
741 for i in 0..=u16::MAX {
742 let line = lines.next().unwrap();
743 assert_eq!(line, i.to_string());
744 }
745 }
746
747 #[test]
748 fn test_fast_output_u32() {
749 let mut rng = Xorshift::default();
750 let mut fo = FastOutput::new(Vec::new());
751 let mut a = vec![];
752 for _ in 0..100_000 {
753 let k = rng.random(0..=u32::BITS);
754 let i = rng.random(0..=u32::MAX.wrapping_shr(u32::BITS - k));
755 a.push(i);
756 fo.u32(i);
757 fo.byte(b'\n');
758 }
759 let buf = fo.buf.into_inner().unwrap();
760 let s = String::from_utf8(buf).unwrap();
761 let mut lines = s.lines();
762 for &a in &a {
763 let line = lines.next().unwrap();
764 assert_eq!(line, a.to_string());
765 }
766 }
767
768 #[test]
769 fn test_fast_output_u64() {
770 let mut rng = Xorshift::default();
771 let mut fo = FastOutput::new(Vec::new());
772 let mut a = vec![];
773 for _ in 0..100_000 {
774 let k = rng.random(0..=u64::BITS);
775 let i = rng.random(0..=u64::MAX.wrapping_shr(u64::BITS - k));
776 a.push(i);
777 fo.u64(i);
778 fo.byte(b'\n');
779 }
780 let buf = fo.buf.into_inner().unwrap();
781 let s = String::from_utf8(buf).unwrap();
782 let mut lines = s.lines();
783 for &a in &a {
784 let line = lines.next().unwrap();
785 assert_eq!(line, a.to_string());
786 }
787 }
788
789 #[test]
790 fn test_fast_output_i8() {
791 let mut fo = FastOutput::new(Vec::new());
792 for i in i8::MIN..=i8::MAX {
793 fo.i8(i);
794 fo.byte(b'\n');
795 }
796 let buf = fo.buf.into_inner().unwrap();
797 let s = String::from_utf8(buf).unwrap();
798 let mut lines = s.lines();
799 for i in i8::MIN..=i8::MAX {
800 let line = lines.next().unwrap();
801 assert_eq!(line, i.to_string());
802 }
803 }
804
805 #[test]
806 fn test_fast_output_i16() {
807 let mut fo = FastOutput::new(Vec::new());
808 for i in i16::MIN..=i16::MAX {
809 fo.i16(i);
810 fo.byte(b'\n');
811 }
812 let buf = fo.buf.into_inner().unwrap();
813 let s = String::from_utf8(buf).unwrap();
814 let mut lines = s.lines();
815 for i in i16::MIN..=i16::MAX {
816 let line = lines.next().unwrap();
817 assert_eq!(line, i.to_string());
818 }
819 }
820
821 #[test]
822 fn test_fast_output_i32() {
823 let mut rng = Xorshift::default();
824 let mut fo = FastOutput::new(Vec::new());
825 let mut a = vec![];
826 for _ in 0..100_000 {
827 let k = rng.random(0..=u32::BITS);
828 let i = rng
829 .random(0..=u32::MAX.wrapping_shr(u32::BITS - k))
830 .cast_signed();
831 a.push(i);
832 fo.i32(i);
833 fo.byte(b'\n');
834 }
835 let buf = fo.buf.into_inner().unwrap();
836 let s = String::from_utf8(buf).unwrap();
837 let mut lines = s.lines();
838 for &a in &a {
839 let line = lines.next().unwrap();
840 assert_eq!(line, a.to_string());
841 }
842 }
843
844 #[test]
845 fn test_fast_output_i64() {
846 let mut rng = Xorshift::default();
847 let mut fo = FastOutput::new(Vec::new());
848 let mut a = vec![];
849 for _ in 0..100_000 {
850 let k = rng.random(0..=u64::BITS);
851 let i = rng
852 .random(0..=u64::MAX.wrapping_shr(u64::BITS - k))
853 .cast_signed();
854 a.push(i);
855 fo.i64(i);
856 fo.byte(b'\n');
857 }
858 let buf = fo.buf.into_inner().unwrap();
859 let s = String::from_utf8(buf).unwrap();
860 let mut lines = s.lines();
861 for &a in &a {
862 let line = lines.next().unwrap();
863 assert_eq!(line, a.to_string());
864 }
865 }
866}