Problem:
﻿Score: 100 points

Problem Statement

In 2020, AtCoder Inc. with an annual sales of more than one billion yen (the currency of Japan) has started a business in programming education.

One day, there was an exam where a one-year-old child must write a program that prints Hello World, and a two-year-old child must write a program that receives integers A, B and prints A+B.

Takahashi, who is taking this exam, suddenly forgets his age.

He decides to write a program that first receives his age N (1 or 2) as input, then prints Hello World if N=1, and additionally receives integers A, B and prints A+B if N=2.

Write this program for him.

Constraints

N is 1 or 2.

A is an integer between 1 and 9 (inclusive).

B is an integer between 1 and 9 (inclusive).

Input

Input is given from Standard Input in one of the following formats:

1

2
A
B

Output

If N=1, print Hello World; if N=2, print A+B.

Sample Input 1

1

Sample Output 1

Hello World

As N=1, Takahashi is one year old. Thus, we should print Hello World.

Sample Input 2

2
3
5

Sample Output 2

8

As N=2, Takahashi is two years old. Thus, we should print A+B, which is 8 since A=3 and B=5.

Solution in Rust (1.15.1) (judge verdict: Accepted)

#![allow(unused_imports, non_snake_case)]
use std::cmp::{max, min, Ordering};
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};

// {{{ input!
// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}
macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}
macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}
//}}}

//{{{ read!
macro_rules! read {
	($($t:tt),*; $n:expr) => {{
		let stdin = ::std::io::stdin();
		let ret = ::std::io::BufRead::lines(stdin.lock()).take($n).map(|line| {
			let line = line.unwrap();
			let mut it = line.split_whitespace();
			_read!(it; $($t),*)
		}).collect::<Vec<_>>();
		ret
	}};
	($($t:tt),*) => {{
		let line = readln();
		let mut it = line.split_whitespace();
		_read!(it; $($t),*)
	}};
}

macro_rules! _read {
	($it:ident; [char]) => {
		_read!($it; String).chars().collect::<Vec<_>>()
	};
	($it:ident; [u8]) => {
		Vec::from(_read!($it; String).into_bytes())
	};
	($it:ident; [$t:ty]) => {
		$it.map(|s| s.parse::<$t>().unwrap_or_else(|e| panic!("{}", e))).collect::<Vec<_>>()
	};
	($it:ident; $t:ty) => {
		$it.next().unwrap_or_else(|| panic!("input mismatch")).parse::<$t>().unwrap_or_else(|e| panic!("{}", e))
	};
	($it:ident; $($t:ty),+) => {
		($(_read!($it; $t)),*)
	};
}
//}}}

//{{{ utility macros missing in 1.15.1
// https://atcoder.jp/contests/nikkei2019-qual/submissions/4098548
macro_rules! eprint {
	($($t:tt)*) => {{
            use ::std::io::Write;
            let _ = write!(::std::io::stderr(), $($t)*);
	}};
}
macro_rules! eprintln {
	() => { eprintln!(""); };
	($($t:tt)*) => {{
	    use ::std::io::Write;
            let _ = writeln!(::std::io::stderr(), $($t)*);
	}};
}
macro_rules! dbg {
    ($val:expr) => {
        match $val {
            tmp => {
                eprintln!(
                    "[{}:{}] {} = {:#?}",
                    file!(),
                    line!(),
                    stringify!($val),
                    &tmp
                );
                tmp
            }
        }
    };
}
//}}}

fn run() {
    let n = read!(usize);
    if n == 1 {
        println!("Hello World");
    } else {
        let a = read!(usize);
        let b = read!(usize);
        println!("{}", a + b);
    }
}

//{{{ template
fn main() {
    let _ = ::std::thread::Builder::new()
        .name("run".to_string())
        .stack_size(256 * 1024 * 1024)
        .spawn(run)
        .unwrap()
        .join()
        .unwrap();
}

pub trait SetMinMax {
    fn set_min(&mut self, v: Self) -> bool;
    fn set_max(&mut self, v: Self) -> bool;
}

impl<T> SetMinMax for T
where
    T: PartialOrd,
{
    fn set_min(&mut self, v: T) -> bool {
        *self > v && {
            *self = v;
            true
        }
    }
    fn set_max(&mut self, v: T) -> bool {
        *self < v && {
            *self = v;
            true
        }
    }
}

#[derive(PartialEq, Eq, Debug, Copy, Clone, Default, Hash)]
pub struct Reverse<T>(pub T);

impl<T: PartialOrd> PartialOrd for Reverse<T> {
    #[inline]
    fn partial_cmp(&self, other: &Reverse<T>) -> Option<Ordering> {
        other.0.partial_cmp(&self.0)
    }

    #[inline]
    fn lt(&self, other: &Self) -> bool {
        other.0 < self.0
    }
    #[inline]
    fn le(&self, other: &Self) -> bool {
        other.0 <= self.0
    }
    #[inline]
    fn ge(&self, other: &Self) -> bool {
        other.0 >= self.0
    }
    #[inline]
    fn gt(&self, other: &Self) -> bool {
        other.0 > self.0
    }
}

impl<T: Ord> Ord for Reverse<T> {
    #[inline]
    fn cmp(&self, other: &Reverse<T>) -> Ordering {
        other.0.cmp(&self.0)
    }
}

#[allow(unused)] // This is defined for read! macro
fn readln() -> String {
    let mut line = String::new();
    ::std::io::stdin()
        .read_line(&mut line)
        .unwrap_or_else(|e| panic!("{}", e));
    line
}
//}}}

//{{{library
pub mod data_structure {
    mod bit {
        #[doc = " Binary Indexed Tree (Fenwick Tree) (0-indexed)"]
        #[doc = ""]
        #[doc = " This data structure supports these two queries in O(log n)"]
        #[doc = ""]
        #[doc = " 1. add w to v[at]"]
        #[doc = " 2. the sum of v[begin], v[begin+1], .., v[end-1]"]
        pub struct BIT {
            tree: Vec<i64>,
        }
        #[doc = " BIT (range-version) (0-indexed)"]
        #[doc = ""]
        #[doc = " This data structure two queries in O(log n)"]
        #[doc = ""]
        #[doc = " 1. add w to v[begin], v[begin+1], ..., v[end-1]"]
        #[doc = " 2. get the sum of v[begin], v[begin+1], ..., v[end-1]"]
        pub struct BITRange {
            bit0: BIT,
            bit1: BIT,
        }
        impl BIT {
            pub fn new(n: usize) -> BIT {
                BIT { tree: vec![0; n] }
            }
            #[doc = " v[at] += by"]
            pub fn add(&mut self, at: usize, by: i64) {
                let mut idx = at;
                while idx < self.tree.len() {
                    self.tree[idx] += by;
                    idx |= idx + 1;
                }
            }
            #[doc = " sum of v[idx] such that begin <= idx < end"]
            pub fn get(&self, begin: usize, end: usize) -> i64 {
                if begin >= end {
                    return 0;
                }
                let a = if end > 0 { self.cum(end - 1) } else { 0 };
                let b = if begin > 0 { self.cum(begin - 1) } else { 0 };
                a - b
            }
            #[doc = " v[0] + ... + v[last]"]
            fn cum(&self, last: usize) -> i64 {
                let mut res = 0;
                let mut idx = last as i64;
                while idx >= 0 {
                    res += self.tree[idx as usize];
                    idx = (idx & (idx + 1)) - 1;
                }
                res
            }
        }
        impl BITRange {
            pub fn new(n: usize) -> BITRange {
                BITRange {
                    bit0: BIT::new(n + 1),
                    bit1: BIT::new(n + 1),
                }
            }
            #[doc = " v[begin], v[begin+1], ..., v[end-1] += by"]
            pub fn add(&mut self, begin: usize, end: usize, by: i64) {
                let a = begin as i64;
                let b = end as i64;
                self.bit0.add(begin, -by * a);
                self.bit0.add(end, by * b);
                self.bit1.add(begin, by);
                self.bit1.add(end, -by);
            }
            #[doc = " v[begin] + ... + v[end-1]"]
            pub fn get(&self, begin: usize, end: usize) -> i64 {
                if begin >= end {
                    return 0;
                }
                self.cum(end) - self.cum(begin)
            }
            #[doc = " v[0] + ... + v[end-1]"]
            fn cum(&self, end: usize) -> i64 {
                let a = self.bit0.get(0, end);
                let b = self.bit1.get(0, end);
                return a + b * end as i64;
            }
        }
        #[cfg(test)]
        mod tests {
            use super::*;
            #[test]
            fn test_simple() {
                let mut bit = BIT::new(10);
                bit.add(2, 1);
                bit.add(3, 3);
                bit.add(5, 10);
                bit.add(0, -4);
                bit.add(9, -5);
                assert_eq!(5, bit.get(0, 10));
                assert_eq!(4, bit.get(2, 4));
                assert_eq!(1, bit.get(2, 3));
                assert_eq!(0, bit.get(2, 2));
                assert_eq!(0, bit.get(2, 0));
                assert_eq!(-4, bit.get(0, 1));
                assert_eq!(5, bit.get(5, 10));
                let mut bit = BITRange::new(10);
                bit.add(1, 3, 1);
                bit.add(2, 5, 2);
                assert_eq!(1, bit.get(1, 2));
                assert_eq!(4, bit.get(1, 3));
                assert_eq!(6, bit.get(1, 4));
                assert_eq!(6, bit.get(0, 4));
            }
        }
    }
    mod union_find {
        pub struct UnionFind {
            data: Vec<i32>,
        }
        impl UnionFind {
            pub fn new(n: usize) -> UnionFind {
                UnionFind { data: vec![-1; n] }
            }
            pub fn unite(&mut self, x: usize, y: usize) -> bool {
                let x = self.root(x);
                let y = self.root(y);
                if x != y {
                    let (x, y) = if self.data[x] <= self.data[y] {
                        (x, y)
                    } else {
                        (y, x)
                    };
                    self.data[x] += self.data[y];
                    self.data[y] = x as i32;
                }
                x != y
            }
            pub fn same(&mut self, x: usize, y: usize) -> bool {
                self.root(x) == self.root(y)
            }
            pub fn size(&mut self, x: usize) -> u32 {
                let r = self.root(x);
                (-self.data[r]) as u32
            }
            pub fn root(&mut self, x: usize) -> usize {
                if self.data[x] < 0 {
                    x
                } else {
                    let nx = self.data[x] as usize;
                    let r = self.root(nx);
                    self.data[x] = r as i32;
                    r
                }
            }
        }
        #[cfg(test)]
        mod tests {
            use super::*;
            #[test]
            fn test_simple() {
                let mut uf = UnionFind::new(3);
                assert_eq!(1, uf.size(0));
                assert_eq!(1, uf.size(1));
                assert_eq!(1, uf.size(2));
                assert_eq!(0, uf.root(0));
                assert_eq!(1, uf.root(1));
                assert_eq!(2, uf.root(2));
                assert!(!uf.same(1, 2));
                uf.unite(1, 2);
                assert_ne!(uf.root(0), uf.root(2));
                assert_eq!(uf.root(1), uf.root(2));
                assert_eq!(1, uf.size(0));
                assert_eq!(2, uf.size(1));
                assert_eq!(2, uf.size(2));
                assert!(uf.same(1, 2));
                uf.unite(0, 1);
                assert_eq!(uf.root(0), uf.root(2));
                assert_eq!(uf.root(1), uf.root(2));
                assert_eq!(3, uf.size(0));
                assert_eq!(3, uf.size(1));
                assert_eq!(3, uf.size(2));
                assert!(uf.same(1, 2));
                assert!(uf.same(0, 2));
            }
        }
    }
    pub use self::bit::*;
    pub use self::union_find::*;
}
pub mod math {
    mod comb {
        use super::mint::{Mint, MOD};
        pub struct Comb {
            fact: Vec<Mint>,
            factinv: Vec<Mint>,
        }
        impl Comb {
            pub fn new(n: usize) -> Comb {
                let mut fact: Vec<Mint> = vec![0.into(); n + 1];
                let mut factinv: Vec<Mint> = vec![0.into(); n + 1];
                fact[0] = 1.into();
                for i in 0..n {
                    fact[i + 1] = fact[i] * (i + 1);
                }
                factinv[n] = fact[n].inv();
                for i in (0..n).rev() {
                    factinv[i] = factinv[i + 1] * (i + 1);
                }
                Comb {
                    fact: fact,
                    factinv: factinv,
                }
            }
            pub fn fact(&self, n: u64) -> Mint {
                if let Some(x) = self.fact.get(n as usize) {
                    *x
                } else if n >= MOD as u64 {
                    Mint::from(0)
                } else {
                    let mut res = 1.into();
                    for a in 1..(n + 1) {
                        res *= a;
                    }
                    res
                }
            }
            pub fn factinv(&self, n: u64) -> Mint {
                if let Some(x) = self.factinv.get(n as usize) {
                    *x
                } else {
                    self.fact(n).inv()
                }
            }
            pub fn perm(&self, n: u64, r: u64) -> Mint {
                if n >= r {
                    self.fact(n) * self.factinv((n - r) as u64)
                } else {
                    0.into()
                }
            }
            pub fn comb(&self, n: u64, r: u64) -> Mint {
                let m = MOD as u64;
                if n >= m {
                    self.comb(n % m, r % m) * self.comb(n / m, r / m)
                } else if n >= r {
                    self.fact(n) * self.factinv(n - r) * self.factinv(r)
                } else {
                    Mint::from(0)
                }
            }
            pub fn multi_comb(&self, n: u64, r: u64) -> Mint {
                if r == 0 {
                    Mint::from(1)
                } else {
                    self.comb(n + r - 1, r)
                }
            }
        }
        #[cfg(test)]
        mod tests {
            use super::*;
            #[test]
            fn test_simple() {
                let c = Comb::new(100);
                assert_eq!(Mint::from(336), c.perm(8, 3));
                assert_eq!(Mint::from(56), c.comb(8, 3));
                assert_eq!(Mint::from(10), c.multi_comb(3, 3));
            }
            #[test]
            fn test_fact() {
                let c = Comb::new(100);
                let p = 8721234;
                let mut f = Mint::from(1);
                for i in 1..(p + 1) {
                    f *= i;
                }
                assert_eq!(f, c.fact(p));
            }
        }
    }
    mod mint {
        use std;
        pub const MOD: u32 = 1000000007;
        #[derive(Debug, Copy, Clone, Eq)]
        pub struct Mint {
            pub val: u32,
        }
        impl<T: Into<Mint>> std::ops::Add<T> for Mint {
            type Output = Mint;
            fn add(self, other: T) -> Mint {
                let nval = self.val + other.into().val;
                Mint {
                    val: if nval >= MOD { nval - MOD } else { nval },
                }
            }
        }
        impl<T: Into<Mint>> std::ops::Sub<T> for Mint {
            type Output = Mint;
            fn sub(self, other: T) -> Mint {
                let nval = self.val + MOD - other.into().val;
                Mint {
                    val: if nval >= MOD { nval - MOD } else { nval },
                }
            }
        }
        impl<T: Into<Mint>> std::ops::Mul<T> for Mint {
            type Output = Mint;
            fn mul(self, other: T) -> Mint {
                let nval = self.val as u64 * other.into().val as u64;
                Mint {
                    val: (nval % (MOD as u64)) as u32,
                }
            }
        }
        impl<T: Into<Mint>> std::ops::Div<T> for Mint {
            type Output = Mint;
            fn div(self, other: T) -> Mint {
                self * other.into().inv()
            }
        }
        impl Mint {
            pub fn inv(self) -> Mint {
                let mut a = self.val as i32;
                let mut b = MOD as i32;
                let mut u = 1 as i32;
                let mut v = 0 as i32;
                while b != 0 {
                    let t = a / b;
                    a -= t * b;
                    std::mem::swap(&mut a, &mut b);
                    u -= t * v;
                    std::mem::swap(&mut u, &mut v);
                }
                Mint {
                    val: if u < 0 { u + MOD as i32 } else { u } as u32,
                }
            }
        }
        impl PartialEq for Mint {
            fn eq(&self, other: &Mint) -> bool {
                self.val == other.val
            }
        }
        impl std::fmt::Display for Mint {
            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                self.val.fmt(f)
            }
        }
        macro_rules ! impl_signed_mint { ( $ ( $ t : ty ) * ) => ( $ ( impl From <$ t > for Mint { # [ inline ] fn from ( x : $ t ) -> Mint { let t = ( x as i64 ) % ( MOD as i64 ) ; if x >= 0 { Mint { val : t as u32 } } else { Mint { val : ( MOD as i64 + t ) as u32 } } } } ) * ) }
        macro_rules ! impl_unsigned_mint { ( $ ( $ t : ty ) * ) => ( $ ( impl From <$ t > for Mint { # [ inline ] fn from ( x : $ t ) -> Mint { let t = x as u64 % MOD as u64 ; Mint { val : t as u32 } } } ) * ) }
        impl_signed_mint! { i8 i16 i32 i64 isize }
        impl_unsigned_mint! { u8 u16 u32 u64 usize }
        impl<T: Into<Mint>> std::ops::AddAssign<T> for Mint {
            fn add_assign(&mut self, other: T) {
                *self = *self + other.into();
            }
        }
        impl<T: Into<Mint>> std::ops::SubAssign<T> for Mint {
            fn sub_assign(&mut self, other: T) {
                *self = *self - other.into();
            }
        }
        impl<T: Into<Mint>> std::ops::MulAssign<T> for Mint {
            fn mul_assign(&mut self, other: T) {
                *self = *self * other.into();
            }
        }
        impl<T: Into<Mint>> std::ops::DivAssign<T> for Mint {
            fn div_assign(&mut self, other: T) {
                *self = *self / other.into();
            }
        }
        #[cfg(test)]
        mod tests {
            use super::*;
            #[test]
            fn test_simple() {
                let a: Mint = Mint::from(3);
                let b: Mint = Mint::from(1000000000);
                assert_eq!(Mint::from(3000000000u64 % MOD as u64), a * b);
            }
        }
    }
    mod prime {
        #[doc = " Test if `n` is prime, using the deterministic version of the"]
        #[doc = " Miller-Rabin test."]
        #[doc = " # Examples"]
        #[doc = ""]
        #[doc = " ```rust"]
        #[doc = " # use algo::math::is_prime;"]
        #[doc = " assert_eq!(is_prime(1), false);"]
        #[doc = " assert_eq!(is_prime(2), true);"]
        #[doc = " assert_eq!(is_prime(3), true);"]
        #[doc = " assert_eq!(is_prime(4), false);"]
        #[doc = " assert_eq!(is_prime(5), true);"]
        #[doc = ""]
        #[doc = " assert_eq!(is_prime(22_801_763_487), false);"]
        #[doc = " assert_eq!(is_prime(22_801_763_489), true);"]
        #[doc = " assert_eq!(is_prime(22_801_763_491), false);"]
        #[doc = " ```"]
        pub fn is_prime(n: u64) -> bool {
            const HINT: &'static [u64] = &[2];
            const WITNESSES: &'static [(u64, &'static [u64])] = &[
                (2_046, HINT),
                (1_373_652, &[2, 3]),
                (9_080_190, &[31, 73]),
                (25_326_000, &[2, 3, 5]),
                (4_759_123_140, &[2, 7, 61]),
                (1_112_004_669_632, &[2, 13, 23, 1662803]),
                (2_152_302_898_746, &[2, 3, 5, 7, 11]),
                (3_474_749_660_382, &[2, 3, 5, 7, 11, 13]),
                (341_550_071_728_320, &[2, 3, 5, 7, 11, 13, 17]),
                (0xFFFF_FFFF_FFFF_FFFF, &[2, 3, 5, 7, 11, 13, 17, 19, 23]),
            ];
            if n % 2 == 0 {
                return n == 2;
            }
            if n == 1 {
                return false;
            }
            let mut d = n - 1;
            let mut s = 0;
            while d % 2 == 0 {
                d /= 2;
                s += 1
            }
            let witnesses = WITNESSES
                .iter()
                .find(|&&(hi, _)| hi >= n)
                .map(|&(_, wtnss)| wtnss)
                .unwrap();
            'next_witness: for &a in witnesses.iter() {
                let mut power = mod_exp(a, d, n);
                assert!(power < n);
                if power == 1 || power == n - 1 {
                    continue 'next_witness;
                }
                for _r in 0..s {
                    power = mod_sqr(power, n);
                    assert!(power < n);
                    if power == 1 {
                        return false;
                    }
                    if power == n - 1 {
                        continue 'next_witness;
                    }
                }
                return false;
            }
            true
        }
        #[derive(Copy, Clone, PartialEq, PartialOrd, Ord, Eq, Debug)]
        struct U128 {
            hi: u64,
            lo: u64,
        }
        fn modulo(mut a: U128, m: u64) -> u64 {
            if a.hi >= m {
                a.hi -= (a.hi / m) * m;
            }
            let mut x = a.hi;
            let mut y = a.lo;
            for _ in 0..64 {
                let t = (x as i64 >> 63) as u64;
                x = (x << 1) | (y >> 63);
                y <<= 1;
                if (x | t) >= m {
                    x = x.wrapping_sub(m);
                    y += 1;
                }
            }
            x
        }
        fn mul128(u: u64, v: u64) -> U128 {
            let u1 = u >> 32;
            let u0 = u & (!0 >> 32);
            let v1 = v >> 32;
            let v0 = v & (!0 >> 32);
            let t = u0 * v0;
            let w0 = t & (!0 >> 32);
            let k = t >> 32;
            let t = u1 * v0 + k;
            let w1 = t & (!0 >> 32);
            let w2 = t >> 32;
            let t = u0 * v1 + w1;
            let k = t >> 32;
            U128 {
                lo: (t << 32) + w0,
                hi: u1 * v1 + w2 + k,
            }
        }
        fn mod_mul_(a: u64, b: u64, m: u64) -> u64 {
            modulo(mul128(a, b), m)
        }
        fn mod_mul(a: u64, b: u64, m: u64) -> u64 {
            match a.checked_mul(b) {
                Some(r) => {
                    if r >= m {
                        r % m
                    } else {
                        r
                    }
                }
                None => mod_mul_(a, b, m),
            }
        }
        fn mod_sqr(a: u64, m: u64) -> u64 {
            if a < (1 << 32) {
                let r = a * a;
                if r >= m {
                    r % m
                } else {
                    r
                }
            } else {
                mod_mul_(a, a, m)
            }
        }
        fn mod_exp(mut x: u64, mut d: u64, n: u64) -> u64 {
            let mut ret: u64 = 1;
            while d != 0 {
                if d % 2 == 1 {
                    ret = mod_mul(ret, x, n)
                }
                d /= 2;
                x = mod_sqr(x, n);
            }
            ret
        }
    }
    pub use self::comb::*;
    pub use self::mint::*;
    pub use self::prime::*;
}
pub mod util {
    mod permutation {
        pub trait Permutation {
            fn next_permutation(&mut self) -> bool;
            fn prev_permutation(&mut self) -> bool;
        }
        impl<T> Permutation for [T]
        where
            T: Ord,
        {
            fn next_permutation(&mut self) -> bool {
                if self.len() <= 1 {
                    return false;
                }
                let mut i = self.len() - 1;
                while i > 0 && self[i - 1] >= self[i] {
                    i -= 1;
                }
                if i == 0 {
                    return false;
                }
                let mut j = self.len() - 1;
                while self[j] <= self[i - 1] {
                    j -= 1;
                }
                self.swap(j, i - 1);
                self[i..].reverse();
                true
            }
            fn prev_permutation(&mut self) -> bool {
                if self.len() <= 1 {
                    return false;
                }
                let mut i = self.len() - 1;
                while i > 0 && self[i - 1] <= self[i] {
                    i -= 1;
                }
                if i == 0 {
                    return false;
                }
                self[i..].reverse();
                let mut j = self.len() - 1;
                while self[j - 1] < self[i - 1] {
                    j -= 1;
                }
                self.swap(i - 1, j);
                true
            }
        }
        #[cfg(test)]
        mod tests {
            use super::*;
            #[test]
            fn test_simple() {
                let mut data = [0, 0, 1, 1, 2];
                data.next_permutation();
                assert_eq!(&data, &[0, 0, 1, 2, 1]);
                data.next_permutation();
                assert_eq!(&data, &[0, 0, 2, 1, 1]);
                data.next_permutation();
                assert_eq!(&data, &[0, 1, 0, 1, 2]);
                data.next_permutation();
                assert_eq!(&data, &[0, 1, 0, 2, 1]);
                data.next_permutation();
                assert_eq!(&data, &[0, 1, 1, 0, 2]);
                data.prev_permutation();
                assert_eq!(&data, &[0, 1, 0, 2, 1]);
                data.prev_permutation();
                assert_eq!(&data, &[0, 1, 0, 1, 2]);
                data.prev_permutation();
                assert_eq!(&data, &[0, 0, 2, 1, 1]);
                data.prev_permutation();
                assert_eq!(&data, &[0, 0, 1, 2, 1]);
                data.prev_permutation();
                assert_eq!(&data, &[0, 0, 1, 1, 2]);
                assert!(!data.prev_permutation());
            }
        }
    }
    pub use self::permutation::*;
}

//}}}