#686377 (Rust) No.1638 Robot Maze

提出ソース

結果

問題	No.1638 Robot Maze
ユーザー	magurofly
提出日時	2021-08-06 21:45:02
言語	Rust (1.77.0)
結果	AC
実行時間	3 ms / 2,000 ms
コード長	49,759 bytes
コンパイル時間	1,988 ms
コンパイル使用メモリ	198,680 KB
実行使用メモリ	4,348 KB
最終ジャッジ日時	2023-10-17 03:03:30
合計ジャッジ時間	3,389 ms
ジャッジサーバーID （参考情報）	judge13 / judge11

このコードへのチャレンジ（β）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	1 ms 4,348 KB
testcase_01	AC	1 ms 4,348 KB
testcase_02	AC	1 ms 4,348 KB
testcase_03	AC	2 ms 4,348 KB
testcase_04	AC	1 ms 4,348 KB
testcase_05	AC	1 ms 4,348 KB
testcase_06	AC	1 ms 4,348 KB
testcase_07	AC	1 ms 4,348 KB
testcase_08	AC	1 ms 4,348 KB
testcase_09	AC	1 ms 4,348 KB
testcase_10	AC	1 ms 4,348 KB
testcase_11	AC	1 ms 4,348 KB
testcase_12	AC	1 ms 4,348 KB
testcase_13	AC	1 ms 4,348 KB
testcase_14	AC	2 ms 4,348 KB
testcase_15	AC	1 ms 4,348 KB
testcase_16	AC	1 ms 4,348 KB
testcase_17	AC	1 ms 4,348 KB
testcase_18	AC	1 ms 4,348 KB
testcase_19	AC	1 ms 4,348 KB
testcase_20	AC	2 ms 4,348 KB
testcase_21	AC	1 ms 4,348 KB
testcase_22	AC	1 ms 4,348 KB
testcase_23	AC	2 ms 4,348 KB
testcase_24	AC	1 ms 4,348 KB
testcase_25	AC	1 ms 4,348 KB
testcase_26	AC	1 ms 4,348 KB
testcase_27	AC	1 ms 4,348 KB
testcase_28	AC	1 ms 4,348 KB
testcase_29	AC	2 ms 4,348 KB
testcase_30	AC	1 ms 4,348 KB
testcase_31	AC	1 ms 4,348 KB
testcase_32	AC	2 ms 4,348 KB
testcase_33	AC	2 ms 4,348 KB
testcase_34	AC	2 ms 4,348 KB
testcase_35	AC	2 ms 4,348 KB
testcase_36	AC	2 ms 4,348 KB
testcase_37	AC	2 ms 4,348 KB
testcase_38	AC	2 ms 4,348 KB
testcase_39	AC	2 ms 4,348 KB
testcase_40	AC	2 ms 4,348 KB
testcase_41	AC	2 ms 4,348 KB
testcase_42	AC	2 ms 4,348 KB
testcase_43	AC	3 ms 4,348 KB
testcase_44	AC	2 ms 4,348 KB
testcase_45	AC	2 ms 4,348 KB
testcase_46	AC	2 ms 4,348 KB
testcase_47	AC	2 ms 4,348 KB
testcase_48	AC	2 ms 4,348 KB
testcase_49	AC	2 ms 4,348 KB
testcase_50	AC	2 ms 4,348 KB
testcase_51	AC	2 ms 4,348 KB

権限があれば一括ダウンロードができます

コンパイルメッセージ

warning: this attribute can only be applied at the crate level
   --> Main.rs:226:2619
    |
226 | ... the standalone `spin` crate.\n\n"]#![doc(html_root_url="https://docs.rs/lazy_static/1.4.0")]#![no_std]use crate::__cargo_equip::prelu...
    |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #82730 <https://github.com/rust-lang/rust/issues/82730>
    = note: read <https://doc.rust-lang.org/nightly/rustdoc/the-doc-attribute.html#at-the-crate-level> for more information
    = note: `#[warn(invalid_doc_attributes)]` on by default

warning: 1 warning emitted

ソースコード

raw source code

//! # Bundled libraries
//!
//! - `lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)` licensed under `MIT/Apache-2.0`    as `crate::__cargo_equip::crates::lazy_static`
//! - `proconio 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)`    licensed under `MIT OR Apache-2.0` as `crate::__cargo_equip::crates::proconio`
//!
//! # Procedural macros
//!
//! - `proconio-derive 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)` licensed under `MIT OR Apache-2.0`
//!
//! # License and Copyright Notices
//!
//! - `lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)`
//!
//!     ```text
//!     Copyright (c) 2010 The Rust Project Developers
//!
//!     Permission is hereby granted, free of charge, to any
//!     person obtaining a copy of this software and associated
//!     documentation files (the "Software"), to deal in the
//!     Software without restriction, including without
//!     limitation the rights to use, copy, modify, merge,
//!     publish, distribute, sublicense, and/or sell copies of
//!     the Software, and to permit persons to whom the Software
//!     is furnished to do so, subject to the following
//!     conditions:
//!
//!     The above copyright notice and this permission notice
//!     shall be included in all copies or substantial portions
//!     of the Software.
//!
//!     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
//!     ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
//!     TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
//!     PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
//!     SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
//!     CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
//!     OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
//!     IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
//!     DEALINGS IN THE SOFTWARE.
//!     ```
//!
//! - `proconio 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)`
//!
//!     ```text
//!     The MIT License
//!     Copyright 2019 (C) statiolake <statiolake@gmail.com>
//!
//!     Permission is hereby granted, free of charge, to any person obtaining a copy of
//!     this software and associated documentation files (the "Software"), to deal in
//!     the Software without restriction, including without limitation the rights to
//!     use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
//!     the Software, and to permit persons to whom the Software is furnished to do so,
//!     subject to the following conditions:
//!
//!     The above copyright notice and this permission notice shall be included in all
//!     copies or substantial portions of the Software.
//!
//!     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//!     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
//!     FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
//!     COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
//!     IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
//!     CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//!
//!     Copyright for original `input!` macro is held by Hideyuki Tanaka, 2019.  The
//!     original macro is licensed under BSD 3-clause license.
//!
//!     Redistribution and use in source and binary forms, with or without
//!     modification, are permitted provided that the following conditions are met:
//!
//!     1. Redistributions of source code must retain the above copyright notice, this
//!        list of conditions and the following disclaimer.
//!
//!     2. Redistributions in binary form must reproduce the above copyright notice,
//!        this list of conditions and the following disclaimer in the documentation
//!        and/or other materials provided with the distribution.
//!
//!     3. Neither the name of the copyright holder nor the names of its contributors
//!        may be used to endorse or promote products derived from this software
//!        without specific prior written permission.
//!
//!     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//!     ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//!     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//!     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
//!     FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
//!     DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
//!     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
//!     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
//!     OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
//!     OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//!     ```

#![allow(dead_code, unused_imports, unused_macros, non_snake_case)]
/*#[fastout]
fn main() {
  input! {
    H: usize, W: usize,
    U: i64, D: i64, R: i64, L: i64, K: i64, P: i64,
    xs: Usize1, ys: Usize1, xt: Usize1, yt: Usize1,
    C: [Chars; H],
  }

  let mut dist = vec![vec![INF; W]; H];
  dist[xs][ys] = 0;
  let mut pq = BinaryHeap::new();
  pq.push((Reverse(0), xs, ys));
  while let Some((Reverse(c1), i1, j1)) = pq.pop() {
    if dist[i1][j1] != c1 {
      continue;
    }
    let mut go = |i2, j2, mut cost| {
      let row: &Vec<char> = &C[i2];
      if row[j2] == '#' {
        return;
      }
      cost += dist[i1][j1];
      if row[j2] == '@' {
        cost += P;
      }
      let drow: &mut Vec<i64> = &mut dist[i2];
      if drow[j2] > cost {
        drow[j2] = cost;
        pq.push((Reverse(cost), i2, j2));
      }
    };
    if i1 > 0 {
      go(i1 - 1, j1, U);
    }
    if i1 + 1 < H {
      go(i1 + 1, j1, D);
    }
    if j1 > 0 {
      go(i1, j1 - 1, L);
    }
    if j1 + 1 < W {
      go(i1, j1 + 1, R);
    }
  }

  // dbg!(&dist);
  yesno(dist[xt][yt] <= K);
}*/
pub use __cargo_equip::prelude::*;

fn main() {
    let __proconio_stdout = ::std::io::stdout();
    let mut __proconio_stdout = ::std::io::BufWriter::new(__proconio_stdout.lock());
    let __proconio_res = {
        input! {H:usize,W:usize,U:i64,D:i64,R:i64,L:i64,K:i64,P:i64,xs:Usize1,ys:Usize1,xt:Usize1,yt:Usize1,C:[Chars;H],}
        let mut dist = vec![vec![INF; W]; H];
        dist[xs][ys] = 0;
        let mut pq = BinaryHeap::new();
        pq.push((Reverse(0), xs, ys));
        while let Some((Reverse(c1), i1, j1)) = pq.pop() {
            if dist[i1][j1] != c1 {
                continue;
            }
            let mut go = |i2, j2, mut cost| {
                let row: &Vec<char> = &C[i2];
                if row[j2] == '#' {
                    return;
                }
                cost += dist[i1][j1];
                if row[j2] == '@' {
                    cost += P;
                }
                let drow: &mut Vec<i64> = &mut dist[i2];
                if drow[j2] > cost {
                    drow[j2] = cost;
                    pq.push((Reverse(cost), i2, j2));
                }
            };
            if i1 > 0 {
                go(i1 - 1, j1, U);
            }
            if i1 + 1 < H {
                go(i1 + 1, j1, D);
            }
            if j1 > 0 {
                go(i1, j1 - 1, L);
            }
            if j1 + 1 < W {
                go(i1, j1 + 1, R);
            }
        }
        yesno(dist[xt][yt] <= K);
    };
    <::std::io::BufWriter<::std::io::StdoutLock> as ::std::io::Write>::flush(
        &mut __proconio_stdout,
    )
    .unwrap();
    return __proconio_res;
}

type Int = i64;
const MOD: Int = 1_000_000_007;
const INF: Int = 1_000_000_000_000_000_000;
const YESNO: [&'static str; 2] = ["No", "Yes"];

#[allow(unused_imports)]
use proconio::fastout;
use proconio::{
    input,
    /*fastout,*/ marker::{Bytes, Chars, Usize1},
};
use std::cmp::{self, Reverse};
use std::collections::*;

fn yesno(c: bool) {
    println!("{}", YESNO[c as usize]);
}
fn yes() {
    yesno(true);
}
fn no() {
    yesno(false);
}

// The following code was expanded by `cargo-equip`.

#[rustfmt::skip]
#[allow(unused)]
mod __cargo_equip {
    pub(crate) mod crates {
        pub mod lazy_static {#![doc="\nA macro for declaring lazily evaluated statics.\n\nUsing this macro, it is possible to have `static`s that require code to be\nexecuted at runtime in order to be initialized.\nThis includes anything requiring heap allocations, like vectors or hash maps,\nas well as anything that requires function calls to be computed.\n\n# Syntax\n\n```ignore\nlazy_static! {\n    [pub] static ref NAME_1: TYPE_1 = EXPR_1;\n    [pub] static ref NAME_2: TYPE_2 = EXPR_2;\n    ...\n    [pub] static ref NAME_N: TYPE_N = EXPR_N;\n}\n```\n\nAttributes (including doc comments) are supported as well:\n\n```rust\n# #[macro_use]\n# extern crate lazy_static;\n# fn main() {\nlazy_static! {\n    /// This is an example for using doc comment attributes\n    static ref EXAMPLE: u8 = 42;\n}\n# }\n```\n\n# Semantics\n\nFor a given `static ref NAME: TYPE = EXPR;`, the macro generates a unique type that\nimplements `Deref<TYPE>` and stores it in a static with name `NAME`. (Attributes end up\nattaching to this type.)\n\nOn first deref, `EXPR` gets evaluated and stored internally, such that all further derefs\ncan return a reference to the same object. Note that this can lead to deadlocks\nif you have multiple lazy statics that depend on each other in their initialization.\n\nApart from the lazy initialization, the resulting \"static ref\" variables\nhave generally the same properties as regular \"static\" variables:\n\n- Any type in them needs to fulfill the `Sync` trait.\n- If the type has a destructor, then it will not run when the process exits.\n\n# Example\n\nUsing the macro:\n\n```rust\n#[macro_use]\nextern crate lazy_static;\n\nuse std::collections::HashMap;\n\nlazy_static! {\n    static ref HASHMAP: HashMap<u32, &'static str> = {\n        let mut m = HashMap::new();\n        m.insert(0, \"foo\");\n        m.insert(1, \"bar\");\n        m.insert(2, \"baz\");\n        m\n    };\n    static ref COUNT: usize = HASHMAP.len();\n    static ref NUMBER: u32 = times_two(21);\n}\n\nfn times_two(n: u32) -> u32 { n * 2 }\n\nfn main() {\n    println!(\"The map has {} entries.\", *COUNT);\n    println!(\"The entry for `0` is \\\"{}\\\".\", HASHMAP.get(&0).unwrap());\n    println!(\"A expensive calculation on a static results in: {}.\", *NUMBER);\n}\n```\n\n# Implementation details\n\nThe `Deref` implementation uses a hidden static variable that is guarded by an atomic check on each access.\n\n# Cargo features\n\nThis crate provides one cargo feature:\n\n- `spin_no_std`: This allows using this crate in a no-std environment, by depending on the standalone `spin` crate.\n\n"]#![doc(html_root_url="https://docs.rs/lazy_static/1.4.0")]#![no_std]use crate::__cargo_equip::preludes::lazy_static::*;pub use crate::__cargo_equip::macros::lazy_static::*;#[path="inline_lazy.rs"]#[doc(hidden)]pub mod lazy{use crate::__cargo_equip::preludes::lazy_static::*;extern crate core;extern crate std;use self::std::prelude::v1::*;use self::std::cell::Cell;use self::std::hint::unreachable_unchecked;use self::std::sync::Once;#[allow(deprecated)]pub use self::std::sync::ONCE_INIT;pub struct Lazy<T:Sync>(Cell<Option<T> >,Once);impl<T:Sync>Lazy<T>{#[allow(deprecated)]pub const INIT:Self=Lazy(Cell::new(None),ONCE_INIT);#[inline(always)]pub fn get<F>(&'static self,f:F)->&T where F:FnOnce()->T,{self.1.call_once(| |{self.0.set(Some(f()));});unsafe{match*self.0.as_ptr(){Some(ref x)=>x,None=>{debug_assert!(false,"attempted to derefence an uninitialized lazy static. This is a bug");unreachable_unchecked()},}}}}unsafe impl<T:Sync>Sync for Lazy<T>{}}#[doc(hidden)]pub use core::ops::Deref as __Deref;#[doc=" Support trait for enabling a few common operation on lazy static values."]#[doc=""]#[doc=" This is implemented by each defined lazy static, and"]#[doc=" used by the free functions in this crate."]pub trait LazyStatic{#[doc(hidden)]fn initialize(lazy:&Self);}#[doc=" Takes a shared reference to a lazy static and initializes"]#[doc=" it if it has not been already."]#[doc=""]#[doc=" This can be used to control the initialization point of a lazy static."]#[doc=""]#[doc=" Example:"]#[doc=""]#[doc=" ```rust"]#[doc=" #[macro_use]"]#[doc=" extern crate lazy_static;"]#[doc=""]#[doc=" lazy_static! {"]#[doc="     static ref BUFFER: Vec<u8> = (0..255).collect();"]#[doc=" }"]#[doc=""]#[doc=" fn main() {"]#[doc="     lazy_static::initialize(&BUFFER);"]#[doc=""]#[doc="     // ..."]#[doc="     work_with_initialized_data(&BUFFER);"]#[doc=" }"]#[doc=" # fn work_with_initialized_data(_: &[u8]) {}"]#[doc=" ```"]pub fn initialize<T:LazyStatic>(lazy:&T){LazyStatic::initialize(lazy);}}
        pub mod proconio {#![allow(clippy::needless_doctest_main,clippy::print_literal)]#![doc=" Easy IO library for competitive programming."]#![doc=""]#![doc=" `proconio` provides an easy way to read values from stdin (or other source).  The main is"]#![doc=" `input!` macro."]#![doc=""]#![doc=" # Examples"]#![doc=""]#![doc=" The macro's user interface is basically the same with [tanakh's input"]#![doc=" macro](https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8)."]#![doc=""]#![doc=" ```"]#![doc=" # extern crate proconio;"]#![doc=" # use proconio::source::auto::AutoSource;"]#![doc=" use proconio::input;"]#![doc=" # let source = AutoSource::from(\"32 54 -23\");"]#![doc=""]#![doc=" input! {"]#![doc=" #   from source,"]#![doc="     n: u8,"]#![doc="     m: u32,"]#![doc="     l: i32,"]#![doc=" }"]#![doc=""]#![doc=" // now you can use n, m and l as variable."]#![doc=" println!(\"{} {} {}\", n, m, l);"]#![doc=" # assert_eq!(n, 32);"]#![doc=" # assert_eq!(m, 54);"]#![doc=" # assert_eq!(l, -23);"]#![doc=" ```"]#![doc=""]#![doc=" In above code, variables n, m and l are declared and stored values are read from stdin."]#![doc=""]#![doc=" You can declare mutable variables like below:"]#![doc=""]#![doc=" ```"]#![doc=" # extern crate proconio;"]#![doc=" # use proconio::source::auto::AutoSource;"]#![doc=" use proconio::input;"]#![doc=" # let source = AutoSource::from(\"32 54\");"]#![doc=""]#![doc=" input! {"]#![doc=" #   from source,"]#![doc="     n: u32,"]#![doc="     mut m: u32,"]#![doc=" }"]#![doc=""]#![doc=" m += n; // OK: m is mutable"]#![doc=" # assert_eq!(n, 32);"]#![doc=" # assert_eq!(m, 86);"]#![doc=" ```"]#![doc=""]#![doc=" You can read an array or a matrix like this:"]#![doc=""]#![doc=" ```"]#![doc=" # extern crate proconio;"]#![doc=" # use proconio::source::auto::AutoSource;"]#![doc=" use proconio::input;"]#![doc=" # let source = AutoSource::from(\"5 4 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5\");"]#![doc=""]#![doc=" input! {"]#![doc=" #    from source,"]#![doc="     n: usize,"]#![doc="     m: usize,"]#![doc="     a: [[i32; n]; m] // `a` is Vec<Vec<i32>>, (m, n)-matrix."]#![doc=" }"]#![doc=" # assert_eq!("]#![doc=" #     a,"]#![doc=" #     ["]#![doc=" #         [1, 2, 3, 4, 5],"]#![doc=" #         [1, 2, 3, 4, 5],"]#![doc=" #         [1, 2, 3, 4, 5],"]#![doc=" #         [1, 2, 3, 4, 5]"]#![doc=" #     ]"]#![doc=" # );"]#![doc=" ```"]#![doc=""]#![doc=" If the first input is the length of the array, you can omit the length.  This is the only way"]#![doc=" to read jagged array (an array of arrays of which the member arrays can be of different sizes)"]#![doc=" at once.  (Of course you can use `input!` multiple times in for-loop to read such an array"]#![doc=" since `input!` can be used multiple times.)"]#![doc=""]#![doc=" ```"]#![doc=" # extern crate proconio;"]#![doc=" # use proconio::source::auto::AutoSource;"]#![doc=" use proconio::input;"]#![doc=" # let source = AutoSource::from(\"3 3 1 2 3 0 2 1 2\");"]#![doc=""]#![doc=" input! {"]#![doc=" #   from source,"]#![doc="     n: usize,"]#![doc="     a: [[i32]; n],"]#![doc=" }"]#![doc=""]#![doc=" // if you enter \"3  3 1 2 3  0  2 1 2\" to the stdin, the result is as follows."]#![doc=" assert_eq!("]#![doc="     a,"]#![doc="     vec!["]#![doc="         vec![1, 2, 3],"]#![doc="         vec![],"]#![doc="         vec![1, 2],"]#![doc="     ]"]#![doc=" );"]#![doc=" ```"]#![doc=""]#![doc=" Strings can be read as `Vec<u8>` or `Vec<char>`.  Use `Bytes` and `Chars` to do so:"]#![doc=""]#![doc=" ```"]#![doc=" # extern crate proconio;"]#![doc=" # use proconio::source::auto::AutoSource;"]#![doc=" use proconio::input;"]#![doc=" use proconio::marker::{Bytes, Chars};"]#![doc=" # let source = AutoSource::from(\"  string   chars\\nbytes\");"]#![doc=""]#![doc=" input! {"]#![doc=" #     from source,"]#![doc="     string: String, // read as String"]#![doc="     chars: Chars,   // read as Vec<char>"]#![doc="     bytes: Bytes,   // read as Vec<u8>"]#![doc=" }"]#![doc=""]#![doc=" // if you enter \"string chars bytes\" to the stdin, they are like this."]#![doc=" assert_eq!(string, \"string\");"]#![doc=" assert_eq!(chars, ['c', 'h', 'a', 'r', 's']);"]#![doc=" assert_eq!(bytes, b\"bytes\");"]#![doc=" ```"]#![doc=""]#![doc=" You can read tuples:"]#![doc=""]#![doc=" ```"]#![doc=" # extern crate proconio;"]#![doc=" # use proconio::source::auto::AutoSource;"]#![doc=" use proconio::input;"]#![doc=" # let source = AutoSource::from(\"1 2 3 4 5\");"]#![doc=""]#![doc=" input! {"]#![doc=" #   from source,"]#![doc="     t: (i32, i32, i32, i32, i32),"]#![doc=" }"]#![doc=""]#![doc=" // if you enter \"1 2 3 4 5\" to the stdin, `t` is like this."]#![doc=" assert_eq!(t, (1, 2, 3, 4, 5));"]#![doc=" ```"]#![doc=""]#![doc=" And you can freely combine these types."]#![doc=""]#![doc=" ```"]#![doc=" # extern crate proconio;"]#![doc=" # use proconio::source::auto::AutoSource;"]#![doc=" use proconio::input;"]#![doc=" # let source = AutoSource::from(\"4 3 1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 4 5 5 5 5\");"]#![doc=""]#![doc=" input! {"]#![doc=" #   from source,"]#![doc="     n: usize,"]#![doc="     m: usize,"]#![doc="     t: [([u32; m], i32); n],"]#![doc=" }"]#![doc=" # assert_eq!("]#![doc=" #     t,"]#![doc=" #     ["]#![doc=" #         (vec![1,1,1],1),"]#![doc=" #         (vec![2,2,2],2),"]#![doc=" #         (vec![3,3,3],3),"]#![doc=" #         (vec![4,4,4],4),"]#![doc=" #     ]"]#![doc=" # );"]#![doc=" ```"]#![doc=""]#![doc=" You can use `input!` macro multiple times.  For the second time, `input!` macro reads rest of"]#![doc=" input.  It works even if the first input stops at the middle of a line.  The subsequent reads"]#![doc=" will be started at the rest of the line.  This may be helpful for problems where multiple"]#![doc=" datasets are given once."]#![doc=""]#![doc=" ```"]#![doc=" # extern crate proconio;"]#![doc=" # use proconio::source::auto::AutoSource;"]#![doc=" use proconio::input;"]#![doc=" # let mut source = AutoSource::from(\"4 2 1 2 2 3 4 2 1 2 2 3 4\");"]#![doc=""]#![doc=" input! {"]#![doc=" #   from &mut source,"]#![doc="     n: usize,"]#![doc=" }"]#![doc=""]#![doc=" for i in 0..n {"]#![doc="     input! {"]#![doc=" #       from &mut source,"]#![doc="         m: usize,"]#![doc="         a: [i32; m],"]#![doc="     }"]#![doc=" #   assert_eq!(a[0], if i % 2 == 0 { 1 } else { 3 });"]#![doc=" #   assert_eq!(a[1], if i % 2 == 0 { 2 } else { 4 });"]#![doc=" }"]#![doc=" ```"]#![doc=""]#![doc=" In addition to `Chars` and `Bytes`, `Usize1` and `Isize1` are also special types.  They are"]#![doc=" read as `usize` and `isize` respectively, but the read value is decremented.  It enables us to"]#![doc=" automatically convert 1-indexed vertices numbers to 0-indexed array indices."]#![doc=""]#![doc=" ```"]#![doc=" # extern crate proconio;"]#![doc=" # use proconio::source::auto::AutoSource;"]#![doc=" use proconio::input;"]#![doc=" use proconio::marker::Usize1;"]#![doc=" # let mut source = AutoSource::from(\"4   1 3   3 4   6 1   5 3\");"]#![doc=""]#![doc=" input! {"]#![doc=" #   from &mut source,"]#![doc="     n: usize,"]#![doc="     edges: [(Usize1, Usize1); n],"]#![doc=" }"]#![doc=""]#![doc=" // if you enter \"4   1 3   3 4   6 1   5 3\", the decremented value is stored."]#![doc=" assert_eq!(edges[0], (0, 2));"]#![doc=" assert_eq!(edges[1], (2, 3));"]#![doc=" assert_eq!(edges[2], (5, 0));"]#![doc=" assert_eq!(edges[3], (4, 2));"]#![doc=" ```"]#![doc=""]#![doc=" `Usize1` and `Isize1` doesn't hold actual value, so you cannot have value of the type.  Thus,"]#![doc=" they are only useful inside `input!` or `#[derive_readable]`.  You can think the reason these"]#![doc=" types exist is to tell \"how to read the value\".  This how-to can be defined through `Readable`"]#![doc=" trait.  This trait doesn't require the output type to be the same with the implementor."]#![doc=" `Usize1` is implementing `Readable` trait, and there the type of read value is defined as"]#![doc=" `usize`.  You can implement `Readable` for your own type to read values in customized way."]#![doc=""]#![doc=" Finally, you can make your own types `Readable` using `#[derive_readable]` attribute.  Types"]#![doc=" used in the struct are automatically translated to their output types, so a member declared as"]#![doc=" `Usize1` has type `usize` as real struct."]#![doc=""]#![doc=" **Note:** Using `#[derive_readable]` requires `derive` feature enabled.  To do so, open your"]#![doc=" Cargo.toml and modify the line of proconio from:"]#![doc=""]#![doc=" ```toml"]#![doc=" proconio = \"=(version)\""]#![doc=" ```"]#![doc=""]#![doc=" to:"]#![doc=""]#![doc=" ```toml"]#![doc=" proconio = { version = \"=(version)\", features = [\"derive\"] }"]#![doc=" ```"]#![doc=""]#![doc=" Example of `#[derive_readable]`:"]#![doc=""]#![doc=" ```"]#![doc=" # #[cfg(feature = \"derive\")]"]#![doc=" # {"]#![doc=" # extern crate proconio;"]#![doc=" use proconio::input;"]#![doc=" # use proconio::source::auto::AutoSource;"]#![doc=" use proconio::derive_readable;"]#![doc=""]#![doc=" // Unit struct can derive readable.  This generates a no-op for the reading.  Not ignoring"]#![doc=" // the read value, but simply skip reading process.  You cannot use it to discard the input."]#![doc=" #[derive_readable]"]#![doc=" #[derive(PartialEq, Debug)]"]#![doc=" struct Weight;"]#![doc=""]#![doc=" #[derive_readable]"]#![doc=" #[derive(PartialEq, Debug)]"]#![doc=" struct Cost(i32);"]#![doc=""]#![doc=" #[derive_readable]"]#![doc=" #[derive(Debug)]"]#![doc=" struct Edge {"]#![doc="     from: usize,"]#![doc="     to: proconio::marker::Usize1, // The real Edge::to has type usize."]#![doc="     weight: Weight,"]#![doc="     cost: Cost,"]#![doc=" }"]#![doc=""]#![doc=" fn main() {"]#![doc=" #   let source = AutoSource::from(\"12 32 35\");"]#![doc="     input! {"]#![doc=" #       from source,"]#![doc="         edge: Edge,"]#![doc="     }"]#![doc=""]#![doc="     // if you enter \"12 32 35\" to the stdin, the values are as follows."]#![doc="     assert_eq!(edge.from, 12);"]#![doc="     assert_eq!(edge.to, 31);"]#![doc="     assert_eq!(edge.weight, Weight);"]#![doc="     assert_eq!(edge.cost, Cost(35));"]#![doc=" }"]#![doc=" # }"]#![doc=" ```"]#![doc=""]#![doc=" # `#[fastout]`"]#![doc=""]#![doc=" If you import `proconio::fastout`, you can use `#[fastout]` attribute.  Adding this attribute"]#![doc=" to your `main()`, your `print!` and `println!` become faster."]#![doc=""]#![doc=" **Note:** Using `#[proconio::fastout]` requires `derive` feature enabled.  To do so, open your"]#![doc=" Cargo.toml and modify the line of proconio from:"]#![doc=""]#![doc=" ```toml"]#![doc=" proconio = \"=(version)\""]#![doc=" ```"]#![doc=""]#![doc=" to:"]#![doc=""]#![doc=" ```toml"]#![doc=" proconio = { version = \"=(version)\", features = [\"derive\"] }"]#![doc=" ```"]#![doc=""]#![doc=" Example of `#[fastout]`:"]#![doc=""]#![doc=" ```"]#![doc=" # #[cfg(feature = \"derive\")]"]#![doc=" # {"]#![doc=" # extern crate proconio;"]#![doc=" use proconio::fastout;"]#![doc=""]#![doc=" #[fastout]"]#![doc=" fn main() {"]#![doc="     print!(\"{}{}, \", 'h', \"ello\"); // \"hello\"       (no newline)"]#![doc="     println!(\"{}!\", \"world\");      // \"world!\\n\""]#![doc="     println!(\"{}\", 123456789);     // \"123456789\\n\""]#![doc=" }"]#![doc=" # }"]#![doc=" ```"]#![doc=""]#![doc=" ## Closures having `print!` or `println!` in `#[fastout]` function"]#![doc=""]#![doc=" You cannot create a closure containing `print!` or `println!` in `#[fastout]` function.  This"]#![doc=" is because the closure becomes thread-unsafe since the closure refers the unlocked stdout"]#![doc=" introduced by `#[fastout]` attribute.  If this were not prohibited, an invalid usage of such a"]#![doc=" closure would produce a very complex error messages.  For example, `std::thread::spawn()`,"]#![doc=" which requires its argument closure to be thread-safe, causes a confusing error."]#![doc=""]#![doc=" Yes, it is too conservative to make all of such closures compilation error because it is"]#![doc=" actually no problem to use such a closure only inside a single thread.  This is related to a"]#![doc=" limitation in `#[fastout]` implementation."]#![doc=""]#![doc=" For more technical details, see documentation for `#[fastout]` in `proconio-derive`."]#![doc=""]#![doc=" ### How to resolve this error"]#![doc=""]#![doc=" Consider you want to run this code:"]#![doc=""]#![doc=" ```compile_fail"]#![doc=" use proconio::fastout;"]#![doc=""]#![doc=" #[fastout]"]#![doc=" fn main() {"]#![doc="     let thread = std::thread::spawn(|| {"]#![doc="         let x = 3;"]#![doc="         let y = x * x;"]#![doc="         println!(\"{}\", y);"]#![doc="     });"]#![doc=""]#![doc="     thread.join().unwrap();"]#![doc=" }"]#![doc=" ```"]#![doc=""]#![doc=" You will get an error like below."]#![doc=""]#![doc=" ```text"]#![doc=" error: Closures in a #[fastout] function cannot contain `print!` or `println!` macro"]#![doc=""]#![doc=" note: If you want to run your entire logic in a thread having extended size of stack, you can"]#![doc=" define a new function instead.  See documentation (https://.....) for more details."]#![doc=""]#![doc=" note: This is because if you use this closure with `std::thread::spawn()` or any other"]#![doc=" functions requiring `Send` for an argument closure, the compiler emits an error about thread"]#![doc=" unsafety for our internal implementations.  If you are using the closure just in a single"]#![doc=" thread, it's actually no problem, but we cannot check the trait bounds at the macro-expansion"]#![doc=" time.  So for now, all closures having `print!` or `println!` is prohibited regardless of the"]#![doc=" `Send` requirements."]#![doc="  --> src/test.rs:10:9"]#![doc="    |"]#![doc=" 10 |         println!(\"{}\", y);"]#![doc="    |         ^^^^^^^"]#![doc=" ```"]#![doc=""]#![doc=" If your `print!` is relying on the calculation in the thread, you can instead return the result"]#![doc=" from the thread."]#![doc=""]#![doc=" ```"]#![doc=" # #[cfg(feature = \"derive\")]"]#![doc=" # {"]#![doc=" use proconio::fastout;"]#![doc=""]#![doc=" #[fastout]"]#![doc=" fn main() {"]#![doc="     let thread = std::thread::spawn(|| {"]#![doc="         let x = 3;"]#![doc="         x * x"]#![doc="     });"]#![doc=""]#![doc="     let y = thread.join().unwrap();"]#![doc=" #   assert_eq!(y, 9);"]#![doc="     println!(\"{}\", y);"]#![doc=" }"]#![doc=" # }"]#![doc=" ```"]#![doc=""]#![doc=" If you are doing so complex job that it's too difficult to returning the results from your"]#![doc=" closure..."]#![doc=""]#![doc=" ```compile_fail"]#![doc=" use proconio::fastout;"]#![doc=""]#![doc=" # fn some_function(_: String) -> impl Iterator<Item = String> { vec![\"hello\".to_string(), \"world\".to_string()].into_iter() }"]#![doc=" # fn some_proc(x: &str) -> &str { x }"]#![doc=""]#![doc=" #[fastout]"]#![doc=" fn main() {"]#![doc="     let context = \"some context\".to_string();"]#![doc="     let thread = std::thread::spawn(move || {"]#![doc="         // Use many println! and the order is very important"]#![doc="         // It's possible to aggregate the result and print it later, but it's not easy to read"]#![doc="         // and seems ugly."]#![doc="         println!(\"this is header.\");"]#![doc="         for (i, item) in some_function(context).enumerate() {"]#![doc="             print!(\"Item #{}: \", i);"]#![doc="             print!(\"{}\", some_proc(&item));"]#![doc="             println!(\"({})\", item);"]#![doc="         }"]#![doc="     });"]#![doc=""]#![doc="     thread.join().unwrap();"]#![doc=" }"]#![doc=" ```"]#![doc=""]#![doc=" ...you can use a function instead."]#![doc=""]#![doc=" ```"]#![doc=" # #[cfg(feature = \"derive\")]"]#![doc=" # {"]#![doc=" use proconio::fastout;"]#![doc=""]#![doc=" # fn some_function(_: String) -> impl Iterator<Item = String> { vec![\"hello\".to_string(), \"world\".to_string()].into_iter() }"]#![doc=" # fn some_proc(x: &str) -> &str { x }"]#![doc=""]#![doc=" // You can add #[fastout] here"]#![doc=" #[fastout]"]#![doc=" fn process(context: String) {"]#![doc="     // It's completely OK since this #[fastout] is a thing inside `process()`"]#![doc="     println!(\"this is header.\");"]#![doc="     for (i, item) in some_function(context).enumerate() {"]#![doc="         print!(\"Item #{}: \", i);"]#![doc="         print!(\"{}\", some_proc(&item));"]#![doc="         println!(\"({})\", item);"]#![doc="     }"]#![doc=" }"]#![doc=""]#![doc=" // You must not add #[fastout] here!  It causes deadlock."]#![doc=" // #[fastout]"]#![doc=" fn main() {"]#![doc="     let context = \"some context\".to_string();"]#![doc="     let thread = std::thread::spawn(move || process(context));"]#![doc="     thread.join().unwrap();"]#![doc=" }"]#![doc=" # }"]#![doc=" ```"]#![doc=""]#![doc=" **Important Note:** If you *spawn a new thread* which runs another function annotated with"]#![doc=" `#[fastout]`, you must not add `#[fastout]` to the caller.  If you add `#[fastout]` in caller"]#![doc=" too, then the caller has the lock for the stdout, and so callee cannot acquire the lock forever"]#![doc=" --- deadlock.  This is not the case when the caller and callee is executed in the same thread,"]#![doc=" since the lock of stdout is reentrant.  We cannot warn about this kind of deadlock since we"]#![doc=" don't know annotations attached to the function to be called.  (In the above example, we can't"]#![doc=" know whether the function `process()` has `#[fastout]` attribute or not.)"]#![doc=""]#![doc=" If your code is so complex that you cannot avoid deadlock, you should give up using"]#![doc=" `#[fastout]` and simply use `println!` or manually handle your stdout in usual Rust way."]#![doc=""]#![doc=" ## Issues of printing order"]#![doc=""]#![doc=" `#[fastout]` enables buffering to stdout, so if you print something in other functions between"]#![doc=" two prints in main, the order of printing may differ.  In other words, the below example"]#![doc=""]#![doc=" ```"]#![doc=" # #[cfg(feature = \"derive\")]"]#![doc=" # {"]#![doc=" # use proconio::fastout;"]#![doc=" fn foo() { println!(\"between\"); }"]#![doc=" #[fastout]"]#![doc=" fn main() {"]#![doc="     println!(\"hello\");"]#![doc="     foo();"]#![doc="     println!(\"world\");"]#![doc=" }"]#![doc=" # }"]#![doc=" ```"]#![doc=""]#![doc=" *likely* prints like"]#![doc=""]#![doc=" ```text"]#![doc=" between"]#![doc=" hello"]#![doc=" world"]#![doc=" ```"]#![doc=""]#![doc=" If you don't like this behavior, you can remove #[fastout] from your `main()`."]#![doc=""]use crate::__cargo_equip::preludes::proconio::*;pub use crate::__cargo_equip::macros::proconio::*;pub use proconio_derive::*;pub mod marker{#![doc=" Declares special marker types."]use crate::__cargo_equip::preludes::proconio::*;#[doc=" Chars: read a string as array of chars."]pub enum Chars{}#[doc=" Bytes: read a string as array of bytes."]pub enum Bytes{}#[doc=" Usize1: 1-indexed usize.  Output of reading has type usize."]pub enum Usize1{}#[doc=" Isize1: 1-indexed isize.  Output of reading has type isize."]pub enum Isize1{}}pub mod read{#![doc=" Implements readable to the primitives and other special types (such as Chars, Bytes, ...)."]#![doc=""]#![doc=" Nothing to document."]use crate::__cargo_equip::preludes::proconio::*;use crate::__cargo_equip::crates::proconio::marker::{Bytes,Chars,Isize1,Usize1};use crate::__cargo_equip::crates::proconio::source::{Readable,Source};use std::any::type_name;use std::fmt::Debug;use std::io::BufRead;use std::str::FromStr;impl<T:FromStr>Readable for T where T::Err:Debug,{type Output=T;fn read<R:BufRead,S:Source<R> >(source:&mut S)->T{let token=source.next_token_unwrap();match token.parse(){Ok(v)=>v,Err(e)=>panic!(concat!("failed to parse the input `{input}` ","to the value of type `{ty}`: {err:?}; ","ensure that the input format is collectly specified ","and that the input value must handle specified type.",),input=token,ty=type_name::<T>(),err=e,),}}}impl Readable for Chars{type Output=Vec<char>;fn read<R:BufRead,S:Source<R> >(source:&mut S)->Vec<char>{source.next_token_unwrap().chars().collect()}}impl Readable for Bytes{type Output=Vec<u8>;fn read<R:BufRead,S:Source<R> >(source:&mut S)->Vec<u8>{source.next_token_unwrap().bytes().collect()}}impl Readable for Usize1{type Output=usize;fn read<R:BufRead,S:Source<R> >(source:&mut S)->usize{usize::read(source)-1}}impl Readable for Isize1{type Output=isize;fn read<R:BufRead,S:Source<R> >(source:&mut S)->isize{isize::read(source)-1}}}pub mod source{#![doc=" Defines whitespace-splitted token stream wrapping actual stream like stdin."]#![doc=""]#![doc=" The main is trait `Source`.  This is implemented to the following two type of source:"]#![doc=""]#![doc=" 1. Read entire source at once.  (`once::OnceSource`)"]#![doc=" 1. Read source line by line.  (`line::LineSource`)"]#![doc=""]#![doc=" `OnceSource` is very fast, while `LineSource` is handy for local debugging. `OnceSource` must"]#![doc=" read entire input before any other work and you must put EOF (Ctrl-D on Unix or Ctrl-Z on"]#![doc=" Windows) after input.  LineSource reads source one by one.  Simply press enter to input."]#![doc=""]#![doc=" There is another source named `auto::AutoSource`.  `AutoSource` is `OnceSource` in release"]#![doc=" build, is `LineSource` in debug build.  If you use debug build in local testing, `LineSource`,"]#![doc=" convenience version is used.  In judge server it is compiled in release mode, so `OnceSource`,"]#![doc=" faster version is used.  This is usually no problem in judging (except interactive problem?)."]#![doc=""]#![doc=" You can specify the source to be used in `input!` as follows:"]#![doc=""]#![doc=" ```"]#![doc=" # extern crate proconio;"]#![doc=" use proconio::source::auto::AutoSource;"]#![doc=" use proconio::input;"]#![doc=""]#![doc=" let source = AutoSource::from(\"32 54 -23\");"]#![doc=" input! {"]#![doc="     from source,"]#![doc="     n: u8,"]#![doc="     m: u32,"]#![doc="     l: i32,"]#![doc=" }"]#![doc=""]#![doc=" println!(\"{} {} {}\", n, m, l);"]#![doc=" assert_eq!(n, 32);"]#![doc=" assert_eq!(m, 54);"]#![doc=" assert_eq!(l, -23);"]#![doc=" ```"]#![doc=""]#![doc=" In above example, `OnceSource<BufReader<&[u8]>>` and `LineSource<BufReader<&[u8]>>` implements"]#![doc=" `From<&str>`, so you can create the source from a string literal.  You can create an instance"]#![doc=" directly from the value of type implementing `BufRead` by using `OnceSource::new()` and"]#![doc=" `LineSource::new()`."]#![doc=""]#![doc=" If you use `input!` macro with no source specified then it uses `AutoSource` with stdin.  So,"]#![doc=" locally `LineSource` are used, in the server `OnceSource` are used.  `OnceSource` and"]#![doc=" `LineSource` behaves samely in point of the read result, but, unintentionally, it may differ in"]#![doc=" a bare possibility. If it should differ, you can manually specify `LineSource` as `source` of"]#![doc=" `input!`."]use crate::__cargo_equip::preludes::proconio::*;use std::io::BufRead;pub mod line{use crate::__cargo_equip::preludes::proconio::*;use super::Source;use std::io::BufRead;use std::iter::Peekable;use std::str::SplitWhitespace;#[doc=" Source reading stream line by line."]#[doc=""]#[doc=" It is a wrapper for `BufRead`.  You can create `LineSource` from any type implementing"]#[doc=" `BufRead`."]pub struct LineSource<R:BufRead>{tokens:Peekable<SplitWhitespace<'static> >,current_context:Box<str>,reader:R,}impl<R:BufRead>LineSource<R>{#[doc=" Creates a `LineSource` by specified `BufRead`."]pub fn new(reader:R)->LineSource<R>{LineSource{current_context:"".to_string().into_boxed_str(),tokens:"".split_whitespace().peekable(),reader,}}fn prepare(&mut self){while self.tokens.peek().is_none(){let mut line=String::new();let num_bytes=self.reader.read_line(&mut line).expect("failed to get linel maybe an IO error.");if num_bytes==0{return;}self.current_context=line.into_boxed_str();self.tokens=unsafe{std::mem::transmute::<_,&'static str>(&*self.current_context)}.split_whitespace().peekable();}}}impl<R:BufRead>Source<R>for LineSource<R>{#[doc=" Gets a next token."]fn next_token(&mut self)->Option<&str>{self.prepare();self.tokens.next()}#[doc=" Check if tokens are empty"]fn is_empty(&mut self)->bool{self.prepare();self.tokens.peek().is_none()}}use std::io::BufReader;#[doc=" You can create `LineSource` from `&str`.  Since `&[u8]` is a `Read`, `BufRead` can be easily"]#[doc=" created by wrapping using `BufReader`."]impl<'a>From<&'a str>for LineSource<BufReader<&'a[u8]> >{fn from(s:&'a str)->LineSource<BufReader<&'a[u8]> >{LineSource::new(BufReader::new(s.as_bytes()))}}}pub mod once{use crate::__cargo_equip::preludes::proconio::*;use super::Source;use std::io::BufRead;use std::iter::Peekable;use std::marker::PhantomData;use std::str::SplitWhitespace;#[doc=" Source reading entire content for the first time."]#[doc=""]#[doc=" It is a wrapper for `BufRead`.  You can create `OnceSource` from any type implementing"]#[doc=" `BufRead`."]pub struct OnceSource<R:BufRead>{tokens:Peekable<SplitWhitespace<'static> >,context:Box<str>,_read:PhantomData<R>,}impl<R:BufRead>OnceSource<R>{#[doc=" Creates `Source` using specified reader of `BufRead`."]pub fn new(mut source:R)->OnceSource<R>{let mut context=String::new();source.read_to_string(&mut context).expect("failed to read from source; maybe an IO error.");let context=context.into_boxed_str();let mut res=OnceSource{context,tokens:"".split_whitespace().peekable(),_read:PhantomData,};use std::mem;let context:&'static str=unsafe{mem::transmute(&*res.context)};res.tokens=context.split_whitespace().peekable();res}}impl<R:BufRead>Source<R>for OnceSource<R>{#[doc=" Gets a next token."]fn next_token(&mut self)->Option<&str>{self.tokens.next()}#[doc=" Check if tokens are empty"]fn is_empty(&mut self)->bool{self.tokens.peek().is_none()}}use std::io::BufReader;#[doc=" You can create `LineSource` from `&str`.  Since `&[u8]` is a `Read`, `BufRead` can be easily"]#[doc=" created by wrapping using `BufReader`."]impl<'a>From<&'a str>for OnceSource<BufReader<&'a[u8]> >{fn from(s:&'a str)->OnceSource<BufReader<&'a[u8]> >{OnceSource::new(BufReader::new(s.as_bytes()))}}}pub mod auto{#![doc=" Defines `AutoSource`."]#![doc=""]#![doc=" It is `LineSource` for debug build, `OnceSource` for release build."]use crate::__cargo_equip::preludes::proconio::*;#[cfg(debug_assertions)]pub use super::line::LineSource as AutoSource;#[cfg(not(debug_assertions))]pub use super::once::OnceSource as AutoSource;}#[doc=" The main trait. Types implementing this trait can be used for source of `input!` macro."]pub trait Source<R:BufRead>{#[doc=" Gets a whitespace-splitted next token."]fn next_token(&mut self)->Option<&str>;#[doc=" Check if tokens are empty"]fn is_empty(&mut self)->bool;#[doc=" Force gets a whitespace-splitted next token."]fn next_token_unwrap(&mut self)->&str{self.next_token().expect(concat!("failed to get the next token; ","maybe reader reached an end of input. ","ensure that arguments for `input!` macro is correctly ","specified to match the problem input."))}}impl<R:BufRead,S:Source<R> >Source<R>for&'_ mut S{fn next_token(&mut self)->Option<&str>{(*self).next_token()}fn is_empty(&mut self)->bool{(*self).is_empty()}}#[doc=" A trait representing which type can be read from `Source`."]#[doc=""]#[doc=" If you want to read your own type using `input!`, you can implement this trait for your type."]#[doc=" Alternatively, you can add `#[derive_readable]` if you put `use"]#[doc=" proconio_derive::derive_readable` in your source.  It automatically implements `Readable` if"]#[doc=" all members of your type are `Readable`."]pub trait Readable{type Output;fn read<R:BufRead,S:Source<R> >(source:&mut S)->Self::Output;}}use crate::__cargo_equip::crates::proconio::source::auto::AutoSource;use lazy_static::lazy_static;use std::io;use std::io::{BufReader,Stdin};use std::sync::Mutex;lazy_static!{#[doc(hidden)]pub static ref STDIN_SOURCE:Mutex<AutoSource<BufReader<Stdin>>>=Mutex::new(AutoSource::new(BufReader::new(io::stdin())));}#[doc=" Checks if some of tokens are left on stdin."]#[doc=""]#[doc=" This is useful when the number of test cases is not specified like ICPC problems."]#[doc=""]#[doc=" ```text"]#[doc=" loop {"]#[doc="     if is_stdin_empty() {"]#[doc="         break;"]#[doc="     }"]#[doc=""]#[doc="     // do the normal logic"]#[doc="     input! { ... }"]#[doc=" }"]#[doc=" ```"]pub fn is_stdin_empty()->bool{use crate::__cargo_equip::crates::proconio::source::Source;let mut lock=STDIN_SOURCE.lock().expect(concat!("failed to lock the stdin; please re-run this program.  ","If this issue repeatedly occur, this is a bug in `proconio`.  ","Please report this issue from ","<https://github.com/statiolake/proconio-rs/issues>."));lock.is_empty()}}
        pub mod __proconio_derive_0_1_6 {pub use crate::__cargo_equip::macros::__proconio_derive_0_1_6::*;}
    }

    pub(crate) mod macros {
        pub mod lazy_static {pub use crate::{__macro_def_lazy_static___lazy_static_create as __lazy_static_create,__macro_def_lazy_static___lazy_static_internal as __lazy_static_internal,__macro_def_lazy_static_lazy_static as lazy_static};}
        pub mod proconio {pub use crate::{__macro_def_proconio_input as input,__macro_def_proconio_read_value as read_value};}
        pub mod __proconio_derive_0_1_6 {pub use crate::{__macro_def___proconio_derive_0_1_6_derive_readable as derive_readable,__macro_def___proconio_derive_0_1_6_fastout as fastout};}
    }

    pub(crate) mod prelude {pub use crate::__cargo_equip::{crates::*,macros::lazy_static::*};}

    mod preludes {
        pub mod lazy_static {pub(in crate::__cargo_equip)use crate::__cargo_equip::macros::lazy_static::*;}
        pub mod proconio {pub(in crate::__cargo_equip)use crate::__cargo_equip::macros::lazy_static::*;pub(in crate::__cargo_equip)use crate::__cargo_equip::crates::{lazy_static,__proconio_derive_0_1_6 as proconio_derive};}
        pub mod __proconio_derive_0_1_6 {}
    }
}

#[cfg_attr(any(), rustfmt::skip)]
const _: () = {
    #[macro_export] macro_rules! __macro_def___proconio_derive_0_1_6_derive_readable(($(_:tt)*)=>(::std::compile_error!("`derive_readable` from `proconio-derive 0.1.6` should have been expanded");));
    #[macro_export] macro_rules! __macro_def___proconio_derive_0_1_6_fastout(($(_:tt)*)=>(::std::compile_error!("`fastout` from `proconio-derive 0.1.6` should have been expanded");));
    #[macro_export]#[doc(hidden)] macro_rules! __macro_def_lazy_static___lazy_static_create(($NAME:ident,$T:ty)=>{static$NAME:$crate::__cargo_equip::crates::lazy_static::lazy::Lazy<$T> =$crate::__cargo_equip::crates::lazy_static::lazy::Lazy::INIT;});
    #[macro_export]#[doc(hidden)] macro_rules! __macro_def_lazy_static___lazy_static_internal(($(#[$attr:meta])*($($vis:tt)*)static ref$N:ident:$T:ty=$e:expr;$($t:tt)*)=>{__lazy_static_internal!(@MAKE TY,$(#[$attr])*,($($vis)*),$N);__lazy_static_internal!(@TAIL,$N:$T=$e);lazy_static!($($t)*);};(@TAIL,$N:ident:$T:ty=$e:expr)=>{impl$crate::__cargo_equip::crates::lazy_static::__Deref for$N{type Target=$T;fn deref(&self)->&$T{#[inline(always)]fn __static_ref_initialize()->$T{$e}#[inline(always)]fn __stability()->&'static$T{__lazy_static_create!(LAZY,$T);LAZY.get(__static_ref_initialize)}__stability()}}impl$crate::__cargo_equip::crates::lazy_static::LazyStatic for$N{fn initialize(lazy:&Self){let _=&**lazy;}}};(@MAKE TY,$(#[$attr:meta])*,($($vis:tt)*),$N:ident)=>{#[allow(missing_copy_implementations)]#[allow(non_camel_case_types)]#[allow(dead_code)]$(#[$attr])*$($vis)*struct$N{__private_field:()}#[doc(hidden)]$($vis)*static$N:$N=$N{__private_field:()};};()=>());
    #[macro_export] macro_rules! __macro_def_lazy_static_lazy_static(($(#[$attr:meta])*static ref$N:ident:$T:ty=$e:expr;$($t:tt)*)=>{__lazy_static_internal!($(#[$attr])*()static ref$N:$T=$e;$($t)*);};($(#[$attr:meta])*pub static ref$N:ident:$T:ty=$e:expr;$($t:tt)*)=>{__lazy_static_internal!($(#[$attr])*(pub)static ref$N:$T=$e;$($t)*);};($(#[$attr:meta])*pub($($vis:tt)+)static ref$N:ident:$T:ty=$e:expr;$($t:tt)*)=>{__lazy_static_internal!($(#[$attr])*(pub($($vis)+))static ref$N:$T=$e;$($t)*);};()=>());
    #[doc=" read input from stdin."]#[doc=""]#[doc=" basic syntax is:"]#[doc=" ```text"]#[doc=" input! {"]#[doc="     from source,          // optional: if you omitted, stdin is used by default."]#[doc="     (mut) variable: type, // mut is optional: mut makes the variable mutable."]#[doc="     ..."]#[doc=" }"]#[doc=" ```"]#[doc=" the trailing comma is optional.  `source` can be anything implementing `Source`.  This macro"]#[doc=" moves out the specified source.  If you want to prevent moving, you can use `&mut source` since"]#[doc=" `&mut S` where `S: Source` also implements `Source`."]#[macro_export] macro_rules! __macro_def_proconio_input((@from[$source:expr]@rest)=>{};(@from[$source:expr]@rest mut$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::input!{@from[$source]@mut[mut]@rest$($rest)*}};(@from[$source:expr]@rest$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::input!{@from[$source]@mut[]@rest$($rest)*}};(@from[$source:expr]@mut[$($mut:tt)?]@rest$var:tt:$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::input!{@from[$source]@mut[$($mut)*]@var$var@kind[]@rest$($rest)*}};(@from[$source:expr]@mut[$($mut:tt)?]@var$var:tt@kind[$($kind:tt)*]@rest)=>{let$($mut)*$var=$crate::__cargo_equip::crates::proconio::read_value!(@source[$source]@kind[$($kind)*]);};(@from[$source:expr]@mut[$($mut:tt)?]@var$var:tt@kind[$($kind:tt)*]@rest,$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::input!(@from[$source]@mut[$($mut)*]@var$var@kind[$($kind)*]@rest);$crate::__cargo_equip::crates::proconio::input!(@from[$source]@rest$($rest)*);};(@from[$source:expr]@mut[$($mut:tt)?]@var$var:tt@kind[$($kind:tt)*]@rest$tt:tt$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::input!(@from[$source]@mut[$($mut)*]@var$var@kind[$($kind)*$tt]@rest$($rest)*);};(from$source:expr,$($rest:tt)*)=>{#[allow(unused_variables,unused_mut)]let mut s=$source;$crate::__cargo_equip::crates::proconio::input!{@from[&mut s]@rest$($rest)*}};($($rest:tt)*)=>{let mut locked_stdin=$crate::__cargo_equip::crates::proconio::STDIN_SOURCE.lock().expect(concat!("failed to lock the stdin; please re-run this program.  ","If this issue repeatedly occur, this is a bug in `proconio`.  ","Please report this issue from ","<https://github.com/statiolake/proconio-rs/issues>."));$crate::__cargo_equip::crates::proconio::input!{@from[&mut*locked_stdin]@rest$($rest)*}drop(locked_stdin);};);
    #[doc(hidden)]#[macro_export] macro_rules! __macro_def_proconio_read_value((@source[$source:expr]@kind[[$($kind:tt)*]])=>{$crate::__cargo_equip::crates::proconio::read_value!(@array@source[$source]@kind[]@rest$($kind)*)};(@array@source[$source:expr]@kind[$($kind:tt)*]@rest)=>{{let len=<usize as$crate::__cargo_equip::crates::proconio::source::Readable>::read($source);$crate::__cargo_equip::crates::proconio::read_value!(@source[$source]@kind[[$($kind)*;len]])}};(@array@source[$source:expr]@kind[$($kind:tt)*]@rest;$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::read_value!(@array@source[$source]@kind[$($kind)*]@len[$($rest)*])};(@array@source[$source:expr]@kind[$($kind:tt)*]@rest$tt:tt$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::read_value!(@array@source[$source]@kind[$($kind)*$tt]@rest$($rest)*)};(@array@source[$source:expr]@kind[$($kind:tt)*]@len[$($len:tt)*])=>{{let len=$($len)*;(0..len).map(|_|$crate::__cargo_equip::crates::proconio::read_value!(@source[$source]@kind[$($kind)*])).collect::<Vec<_>>()}};(@source[$source:expr]@kind[($($kinds:tt)*)])=>{$crate::__cargo_equip::crates::proconio::read_value!(@tuple@source[$source]@kinds[]@current[]@rest$($kinds)*)};(@tuple@source[$source:expr]@kinds[$([$($kind:tt)*])*]@current[]@rest)=>{($($crate::__cargo_equip::crates::proconio::read_value!(@source[$source]@kind[$($kind)*]),)*)};(@tuple@source[$source:expr]@kinds[$($kinds:tt)*]@current[$($curr:tt)*]@rest)=>{$crate::__cargo_equip::crates::proconio::read_value!(@tuple@source[$source]@kinds[$($kinds)*[$($curr)*]]@current[]@rest)};(@tuple@source[$source:expr]@kinds[$($kinds:tt)*]@current[$($curr:tt)*]@rest,$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::read_value!(@tuple@source[$source]@kinds[$($kinds)*[$($curr)*]]@current[]@rest$($rest)*)};(@tuple@source[$source:expr]@kinds[$($kinds:tt)*]@current[$($curr:tt)*]@rest$tt:tt$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::read_value!(@tuple@source[$source]@kinds[$($kinds)*]@current[$($curr)*$tt]@rest$($rest)*)};(@source[$source:expr]@kind[])=>{compile_error!(concat!("Reached unreachable statement while parsing macro input.  ","This is a bug in `proconio`.  ","Please report this issue from ","<https://github.com/statiolake/proconio-rs/issues>."));};(@source[$source:expr]@kind[$kind:ty])=>{<$kind as$crate::__cargo_equip::crates::proconio::source::Readable>::read($source)});
};

yukicoder

結果

テストケース

コンパイルメッセージ

ソースコード