struct Foo;

impl AsRef<Self> for Foo {
    fn as_ref(&self) -> &Foo {
        self
    }
}

use std::any::Any;

enum Cell<T>
where
    Self: Any,
{
    Nil,
    Cons(T, Box<Self>),
}

static FOO: Foo<'_> = Foo { text: TEXT };
static TEXT: &str = "text";

struct Foo<'a> {
    text: &'a str,
}

pub(crate) fn hello() {
    println!("Hello!");
}

macro_rules! foo {
    ($ty:ty) => {};
}

foo!(A + B + ?Sized);

let point = Point2(1.0, 2.0);
let point = Point2 { 0: 1.0, 1: 2.0 };

struct Point2(f64, f64);

let outcome;
loop {
    do_something();
    if p() {
        outcome = 42;
        break;
    }
}

let outcome = loop {
    do_something();
    if p() {
        break 42;
    }
};

#[allow(clippy::never_loop)]
let _ = 'label: loop {
    loop {
        break 'label 42;
    }
};

let p: bool = unimplemented!();

let _: fn(_) -> _ = if p {
    |x: u32| -> _ { x + 1 }
} else {
    |x: u32| -> _ { 2 * x }
};

let _: &'static i32 = &0;

let _: &'static Foo = &Foo;

struct Foo;

// `Drop`を実装すると駄目
//impl Drop for Foo {
//    fn drop(&mut self) {}
//}

macro_rules! pass_path {
    ($_path:path) => {};
}

pass_path!(Vec::<i32>::new);

let _: i32 = 1 + &1; // `<i32 as Add<&'_ i32>>::add`
let _: i32 = &1 + 1; // `<&'_ i32 as Add<i32>>::add`

const FOO: Foo = Foo;

struct Foo;

impl Drop for Foo {
    fn drop(&mut self) {}
}

// rustfmtはこの量でも縦に引き伸ばす
use std::{
    collections::BinaryHeap,
    io::{self, Read as _},
};

let dir: Direction = unimplemented!();

#[rustfmt::skip]
match dir {
    | Direction::Left
    | Direction::Right => println!("horizontal"),
    | Direction::Down
    | Direction::Up => println!("vertical"),
};

enum Direction {
    Left,
    Right,
    Down,
    Up,
}

use std::{
    iter::{self, FromIterator},
    ops::{Index, IndexMut},
};

/// Counts ASCII characters.
///
/// # Examples
///
/// ```rust
/// use my_competitive_library::counter::AsciiCounter;
///
/// let counter = AsciiCounter::from_bytes("aaabbbccc");
///
/// assert_eq!(counter.elements().collect::<Vec<_>>(), b"aaabbbccc");
/// ```
pub struct AsciiCounter(Box<[usize; 256]>);

impl AsciiCounter {
    pub fn new() -> Self {
        Self(Box::new([0; 256]))
    }

    pub fn from_bytes(bytes: impl AsRef<[u8]>) -> Self {
        bytes.as_ref().iter().copied().collect()
    }

    pub fn elements<'a>(&'a self) -> impl Iterator<Item = u8> + 'a {
        (0u8..=127).flat_map(move |c| iter::repeat(c).take(self[c]))
    }
}

#[rustfmt::skip] impl Default for AsciiCounter { fn default() -> Self { Self::new() } }

#[rustfmt::skip] impl FromIterator<u8> for AsciiCounter { fn from_iter<I: IntoIterator<Item = u8>>(iter: I) -> Self { let mut this = Self::new(); for ch in iter { this[ch] += 1; } this } }

#[rustfmt::skip] impl Index<u8> for AsciiCounter { type Output = usize; fn index(&self, ch: u8) -> &usize { &self.0[usize::from(ch)] } }

#[rustfmt::skip] impl IndexMut<u8> for AsciiCounter { fn index_mut(&mut self, ch: u8) -> &mut usize { &mut self.0[usize::from(ch)] } }

let x: &Option<i32> = unimplemented!();

if let Some(x) = x {
    let _: &i32 = x;
}

#![allow(clippy::unreadable_literal)]

let x = 0u128;
let y = 0i128;

assert_eq!(u128::max_value(), 0xffffffffffffffffffffffffffffffff);
assert_eq!(i128::max_value(), 0x7fffffffffffffffffffffffffffffff);

let xs: Vec<i32> = unimplemented!();

match *xs {
    [] => todo!(),
    [x] => todo!(),
    [x, y] => todo!(),
    _ => todo!(),
}

fn merge<T: Copy + PartialOrd>(mut left: &[T], mut right: &[T]) -> Vec<T> {
    let mut acc = vec![];
    loop {
        match (left, right) {
            ([..], []) | ([], [..]) => {
                acc.extend(left.iter().chain(right).copied());
                break acc;
            }
            ([x, xs @ ..], [y, ..]) if x <= y => {
                acc.push(*x);
                left = xs;
            }
            ([_, ..], [y, ys @ ..]) => {
                acc.push(*y);
                right = ys;
            }
        }
    }
}

// このような入力を想定
//
// N
// A_1 A_2 ... A_N
// B_1 B_2 ... B_N
// C_1 C_2 ... C_N

static INPUT: &str = r#"5
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
"#;

let mut input = INPUT.split_ascii_whitespace();
macro_rules! read(
    ([$ty:tt; $len:expr]) => ((0..$len).map(|_| read!($ty)).collect::<Vec<_>>());
    ($ty:ty) => (input.next().unwrap().parse::<$ty>().unwrap());
);

let n = read!(usize);
let r#as = read!([u32; n]); // `as`はキーワード
let bs = read!([u32; n]);
let cs = read!([u32; n]);

assert_eq!(n, 5);
assert_eq!(r#as, &[1, 2, 3, 4, 5]);
assert_eq!(bs, &[6, 7, 8, 9, 10]);
assert_eq!(cs, &[11, 12, 13, 14, 15]);

fn main() {
    foo!();
}

mod _macros {
    #[macro_export]
    macro_rules! foo(() => (println!("foo")));
}

let mut store = Store::new();

{
    let item = store.item_mut();
    if p(item) {
        modify(item);
    }
}

store.close();

let mut store = Store::new();

let item = store.item_mut();
if p(item) {
    modify(item);
}

store.close();

struct Foo<'a, T> {
    reference: &'a T,
}

pub mod modint {
    ///! ```
    ///! # use my_competitive_library::decl_modint;
    ///! decl_modint!(Zp, 1_000_000_007);
    ///! ```

    use std::marker::PhantomData;

    #[macro_export]
    macro_rules! decl_modint {
        ($name:ident, $modulus:literal) => {
            #[derive(Clone, Copy, PartialEq, Eq, Debug)]
            enum __Modulus {}

            impl $crate::modint::Modulus for __Modulus {
                const VALUE: u64 = $modulus;
            }

            type $name = $crate::modint::ModInt<__Modulus>;
        };
    }

    pub trait Modulus {
        const VALUE: u64;
    }

    #[derive(Clone, Copy, PartialEq, Eq, Debug)]
    pub struct ModInt<M: Modulus> {
        repr: u64,
        phantom: PhantomData<fn() -> M>,
    }
}

#![deny(rust_2018_idioms)] // `elided-lifetimes-in-paths`を含む

use std::io::{self, BufWriter, StdoutLock, Write as _};

fn buf_print<F: FnOnce(&mut BufWriter<StdoutLock<'_>>)>(f: F) {
    let stdout = io::stdout();
    let mut stdout = BufWriter::new(stdout.lock());
    f(&mut stdout);
    stdout.flush().unwrap();
}

match $expr {
    $pattern => {}
}

match $expr {
    ($pattern) => {}
}

echo!(42);
echo!(42,); // trailing comma

#[macro_export]
macro_rules! echo {
    ($expr:expr $(,)?) => {
        ::std::println!("{}", $expr)
    };
}

use Foo::A;

const FOO: Foo = A;

enum Foo {
    A,
    B,
}

use std::marker::PhantomData;

const PHANTOM: PhantomData<()> = PhantomData;

match PhantomData {
    PHANTOM => {}
}

if let Foo::A(_) | Foo::B(_) = unimplemented!() {
    todo!();
}

enum Foo {
    A(i32),
    B(i32),
    C(i32),
}

#![allow(irrefutable_let_patterns)]

if let () = () {
    todo!();
} else {
    unreachable!();
}

#![allow(irrefutable_let_patterns)]

let mut state: State = unimplemented!();

while let State { count } = &mut state {
    if *count == 0 {
        break;
    }
    *count -= 1;
}

struct State {
    count: usize,
}

use std::rc::Rc;
use std::sync::Arc;

struct Foo;

impl Foo {
    fn method(self: &mut Rc<Arc<Box<&Self>>>) {
        todo!();
    }
}

let p = || -> bool { unimplemented!() };

let f: Box<dyn FnOnce(_) -> _> = if p() {
    Box::new(|x| x + 1)
} else {
    Box::new(|x| 2 * x)
};
let _: i32 = f(42);

const _: () = {
    let _: fn(usize, usize) -> usize = usize::saturating_sub;
};

macro_rules! rec {
    () => {};
    (_ $($rest:tt)*) => {
        rec!($($rest)*);
    }
}

rec!(
    // 127個
    _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
    _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
    _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
    _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
    _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
    _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
    _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
    _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
);

todo!("なんか良い例");

const _: () = {
    struct Foo(i32);

    let _ = { Foo }(42);
};

impl<A, B, C> ForeignTrait<LocalType> for ForeignType<A, B, C> {
    // ...
}

queue.truncate(1);

queue.resize(n, (0, 0));

acc.insert_str(i, s);

assert_eq!(
    "aaa aaa aaa aaa".replacen("aaa", "bbb", 2),
    "bbb bbb aaa aaa",
);

assert_eq!("abc".repeat(2), "abcabc");

assert_eq!([1, 2].repeat(3), vec![1, 2, 1, 2, 1, 2]);
assert_eq!(b"abc".repeat(2), b"abcabc");

let mut xs = vec![3, 2, 4, 0, 5];
xs.dedup_by_key(|&mut x| x % 2);
assert_eq!(xs, &[3, 2, 5]);

let mut left = "abcdef".to_owned();
let right = left.split_off(left.len() / 2);

assert_eq!(left, "abc");
assert_eq!(right, "def");

use std::collections::VecDeque;

let queue: VecDeque<i32> = unimplemented!();
let x: i32 = unimplemented!();
let y: i32 = unimplemented!();
let z: i32 = unimplemented!();

let ans = queue == &[x, y, z];
println!("{}", if ans { "Yes" } else { "No" });

dbg!(queue == &[x, y, z]);

use std::collections::BTreeSet;

macro_rules! btreeset(($($val:expr),* $(,)?) => (vec![$($val),*].into_iter().collect::<BTreeSet<_>>()));

let set = btreeset!(10, 20, 30, 40, 50);

let range = set.range(25..).collect::<Vec<_>>();
assert_eq!(range, &[&30, &40, &50]);

use std::cell::Cell;

let x: i32 = unimplemented!();

let _: i32 = Cell::new(x).into_inner();

use std::cell::Cell;

let x = Cell::new(1);
let y = Cell::new(2);

x.swap(&y);
assert_eq!(x.get(), 2);
assert_eq!(y.get(), 1);

let z = x.replace(3);
assert_eq!(x.get(), 3);
assert_eq!(y.get(), 1);
assert_eq!(z, 2);

let z = x.take();
assert_eq!(x.get(), 0);
assert_eq!(y.get(), 1);
assert_eq!(z, 3);

use std::collections::HashSet;

macro_rules! hashset(($($val:expr),* $(,)?) => (vec![$($val),*].into_iter().collect::<HashSet<_>>()));

let mut set = hashset!(1, 2, 3, 4, 5);
set.retain(|x| x % 2 == 0);
assert_eq!(set, hashset!(2, 4));

use std::cmp::Reverse;

let mut xs = vec![1, 2, 3, 4, 5];
xs.sort_unstable_by_key(|&x| Reverse(x));
assert_eq!(xs, &[5, 4, 3, 2, 1]);

use std::{cmp::Reverse, collections::BinaryHeap};

let mut max_queue = BinaryHeap::from(vec![1, 2]);
assert_eq!(max_queue.pop(), Some(2));
assert_eq!(max_queue.pop(), Some(1));
assert_eq!(max_queue.pop(), None);

let mut min_queue = BinaryHeap::from(vec![Reverse(1), Reverse(2)]);
assert_eq!(min_queue.pop(), Some(Reverse(1)));
assert_eq!(min_queue.pop(), Some(Reverse(2)));
assert_eq!(min_queue.pop(), None);

if p1() {
    unimplemented!("あれをやる");
}
if p2() {
    todo!("これをやる");
}

let do_something = || unimplemented!();

let mut count: Option<i32> = unimplemented!();

if count.is_none() {
    do_something();
}
*count.get_or_insert(0) += 1;

let input: String = "42\n".to_owned();
let input: Box<str> = input.into_boxed_str();
let input: &'static str = Box::leak(input);

use std::{
    iter::{self, FromIterator},
    marker::PhantomData,
};

let mut wrapper = CollectionWrapper::<(), ()>::new(iter::once(()));
wrapper.push(());

struct CollectionWrapper<T, C> {
    collection: C,
    phantom: PhantomData<fn() -> T>,
}

impl<T, C: FromIterator<T> + Extend<T>> CollectionWrapper<T, C> {
    fn new(iter: impl IntoIterator<Item = T>) -> Self {
        Self {
            collection: iter.into_iter().collect(),
            phantom: PhantomData,
        }
    }

    fn push(&mut self, item: T) {
        self.collection.extend(iter::once(item));
    }
}

use std::{
    io::{self, BufWriter, Read as _, Write},
    str::SplitAsciiWhitespace,
};

fn main() {
    let mut input = "".to_owned();
    io::stdin().read_to_string(&mut input).unwrap();

    let stdout = io::stdout();
    let mut stdout = BufWriter::new(stdout.lock());

    solve(input.split_ascii_whitespace(), &mut stdout);

    stdout.flush().unwrap();
}

fn solve(mut stdin: SplitAsciiWhitespace<'_>, mut stdout: impl Write) {
    macro_rules! read(($ty:ty) => (stdin.next().unwrap().parse::<$ty>().unwrap()));
    macro_rules! println(($($tt:tt)*) => (writeln!(stdout, $($tt)*).unwrap()));

    println!("Hello!");
}

#[cfg(test)]
mod tests {
    use std::{io::Cursor, str};

    #[test]
    fn test1() {
        test(INPUT, OUTPUT);

        static INPUT: &str = "";
        static OUTPUT: &str = "Hello!\n";
    }

    fn test(input: &str, output: &str) {
        let mut stdout = Cursor::new(vec![]);
        super::solve(input.split_ascii_whitespace(), &mut stdout);
        let stdout = str::from_utf8(stdout.get_ref()).unwrap();
        assert_eq!(stdout, output);
    }
}

use std::{
    fmt::Debug,
    io::BufRead,
    str::{FromStr, SplitAsciiWhitespace},
};

pub struct LineScanner<R: BufRead> {
    rdr: R,
    words: SplitAsciiWhitespace<'static>,
}

impl<R: BufRead> LineScanner<R> {
    pub fn new(rdr: R) -> Self {
        Self {
            rdr,
            words: "".split_ascii_whitespace(),
        }
    }

    pub fn next_value<T: FromStr>(&mut self) -> T
    where
        T::Err: Debug,
    {
        loop {
            if let Some(word) = self.words.next() {
                break word.parse().unwrap();
            }
            let mut line = "".to_owned();
            self.rdr.read_line(&mut line).unwrap();
            if line.is_empty() {
                panic!("reached EOF");
            }
            self.words = Box::leak(line.into_boxed_str()).split_ascii_whitespace();
        }
    }
}

let mut xs = Some(vec![1, 2, 3]);
let xs: Option<&mut Vec<i32>> = xs.as_mut();
let _: Option<Vec<i32>> = xs.cloned();

let mut xs = vec![1, 2, 3, 4, 5];
xs.rotate_left(1);
assert_eq!(xs, &[2, 3, 4, 5, 1]);

use std::ops::Add;

let a: i32 = unimplemented!();
let b: i32 = unimplemented!();
let c: i32 = unimplemented!();

let array = [a, b, c];

assert_eq!(array.iter().find(|&&x| x == c), Some(&2));
assert_eq!(array.iter().rfind(|&&x| x == c), Some(&2));

assert_eq!(array.iter().fold(0, Add::add), a + b + c);
assert_eq!(array.iter().rfold(0, Add::add), a + b + c);

assert_eq!(array.iter().nth(2), Some(&c));
assert_eq!(array.iter().nth_back(2), Some(&a));

use std::collections::HashMap;

let mut map: HashMap<Vec<u8>, usize> = unimplemented!();

let _: Option<(&Vec<u8>, &usize)> = map.get_key_value(&b"foo"[..]);
let _: Option<(Vec<u8>, usize)> = map.remove_entry(&b"foo"[..]);

use std::convert::Infallible;

assert_eq!(None::<Infallible>.filter(|_| false), None);
assert_eq!(None::<Infallible>.filter(|_| true), None);

assert_eq!(Some(2).filter(|n| n % 2 == 1), None);
assert_eq!(Some(3).filter(|n| n % 2 == 1), Some(3));
assert_eq!(Some(4).filter(|n| n % 2 == 1), None);

let mut s = "aaaaa#bbbbb#ccccc".to_owned();

if let [i, j] = *(0..s.len())
    .filter(|&i| s.as_bytes()[i] == b'#')
    .collect::<Vec<_>>()
{
    s.replace_range(i..=j, "@");
}

assert_eq!(s, "aaaaa@ccccc");

let s = b"foo|bar|baz"[..].to_owned();

assert_eq!(
    s.split(|&c| c == b'|').collect::<Vec<_>>(),
    &[b"foo", b"bar", b"baz"],
);

assert_eq!(
    s.rsplit(|&c| c == b'|').collect::<Vec<_>>(),
    &[b"baz", b"bar", b"foo"],
);

let mut xs = [1, 2, 3, 0, 0, 0];
let mut ys = [0, 0, 0, 4, 5, 6];

xs[..3].swap_with_slice(&mut ys[..3]);

assert_eq!(xs, [0, 0, 0, 0, 0, 0]);
assert_eq!(ys, [1, 2, 3, 4, 5, 6]);

let mut xs = vec![1, 2, 3, 10, 20, 30];

assert_eq!(xs.len() % 2, 0);

let mid = xs.len() / 2;
let (left, right) = xs.split_at_mut(mid);
left.swap_with_slice(right);

assert_eq!(xs, &[10, 20, 30, 1, 2, 3]);

todo!("なんか良い例");

let mut x = Some(1);
assert_eq!(x.replace(2), Some(1));
assert_eq!(x, Some(2));

let mut x = None;
assert_eq!(x.replace(1), None);
assert_eq!(x, Some(1));

let xs = vec![1, 2, 3];
dbg!(&xs);

use std::{convert::Infallible, marker::PhantomData};

struct Marker<T>(Infallible, PhantomData<fn() -> T>);

use std::{convert::Infallible, str::FromStr};

enum Enum {
    A,
    B,
    Other(String),
}

impl FromStr for Enum {
    type Err = Infallible;

    fn from_str(s: &str) -> Result<Self, Infallible> {
        match s {
            "a" => Ok(Self::A),
            "b" => Ok(Self::B),
            s => Ok(Self::Other(s.to_owned())),
        }
    }
}

use std::{
    convert::{TryFrom, TryInto},
    fmt,
};

fn f<T: TryFrom<i128> + TryInto<i128>>(x: T, y: T) -> T
where
    <T as TryFrom<i128>>::Error: fmt::Debug,
    <T as TryInto<i128>>::Error: fmt::Debug,
{
    let x = x.try_into().unwrap();
    let y = y.try_into().unwrap();
    return f(x, y).try_into().unwrap();

    fn f(x: i128, y: i128) -> i128 {
        unimplemented!();
    }
}

todo!("なんか良い例");

todo!("なんか良い例");

let a: u64 = unimplemented!();
let r: u64 = unimplemented!();
let n: u32 = unimplemented!();

let x = a.saturating_mul(r.saturating_pow(n - 1));
if x > 10u64.pow(9) {
    println!("large");
} else {
    println!("{}", x);
}

use std::cell::{Ref, RefCell};

let s = RefCell::new(b"user@pass"[..].to_owned());
let (user, pass) = Ref::map_split(s.borrow(), |s| {
    let words = s.splitn(2, |&c| c == b'@').collect::<Vec<_>>();
    (words[0], words[1])
});

use std::cell::Cell;

let mut x: i32 = unimplemented!();

let x_ref1 = Cell::from_mut(&mut x);
let x_ref2 = x_ref1.clone();

use std::cell::Cell;

let x: i32 = unimplemented!();
let y: i32 = unimplemented!();
let z: i32 = unimplemented!();

let slice = &mut [x, y, z][..];
let slice = Cell::from_mut(slice).as_slice_of_cells();
let _: &[Cell<i32>] = slice;