Problem:
Score : 100 points

Problem Statement

You are given a positive integer N.
Find the minimum positive integer divisible by both 2 and N.

Constraints

1 \leq N \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N

Output

Print the minimum positive integer divisible by both 2 and N.

Sample Input 1

3

Sample Output 1

6

6 is divisible by both 2 and 3.
Also, there is no positive integer less than 6 that is divisible by both 2 and 3.
Thus, the answer is 6.

Sample Input 2

10

Sample Output 2

10

Sample Input 3

999999999

Sample Output 3

1999999998

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() {
    input! {
        n: usize,
    }
    if n % 2 == 0 {
        println!("{}", n);
    } else {
        println!("{}", 2 * n);
    }
}

//{{{ 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
}
//}}}
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 base = 1000000;
                    let p = n / base;
                    let mut res = PRECALC_FACT[p as usize].into();
                    for a in (p * base + 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)
                }
            }
        }
        static PRECALC_FACT: &'static [u32] = &[
            1,
            641102369,
            578095319,
            5832229,
            259081142,
            974067448,
            316220877,
            690120224,
            251368199,
            980250487,
            682498929,
            134623568,
            95936601,
            933097914,
            167332441,
            598816162,
            336060741,
            248744620,
            626497524,
            288843364,
            491101308,
            245341950,
            565768255,
            246899319,
            968999,
            586350670,
            638587686,
            881746146,
            19426633,
            850500036,
            76479948,
            268124147,
            842267748,
            886294336,
            485348706,
            463847391,
            544075857,
            898187927,
            798967520,
            82926604,
            723816384,
            156530778,
            721996174,
            299085602,
            323604647,
            172827403,
            398699886,
            530389102,
            294587621,
            813805606,
            67347853,
            497478507,
            196447201,
            722054885,
            228338256,
            407719831,
            762479457,
            746536789,
            811667359,
            778773518,
            27368307,
            438371670,
            59469516,
            5974669,
            766196482,
            606322308,
            86609485,
            889750731,
            340941507,
            371263376,
            625544428,
            788878910,
            808412394,
            996952918,
            585237443,
            1669644,
            361786913,
            480748381,
            595143852,
            837229828,
            199888908,
            526807168,
            579691190,
            145404005,
            459188207,
            534491822,
            439729802,
            840398449,
            899297830,
            235861787,
            888050723,
            656116726,
            736550105,
            440902696,
            85990869,
            884343068,
            56305184,
            973478770,
            168891766,
            804805577,
            927880474,
            876297919,
            934814019,
            676405347,
            567277637,
            112249297,
            44930135,
            39417871,
            47401357,
            108819476,
            281863274,
            60168088,
            692636218,
            432775082,
            14235602,
            770511792,
            400295761,
            697066277,
            421835306,
            220108638,
            661224977,
            261799937,
            168203998,
            802214249,
            544064410,
            935080803,
            583967898,
            211768084,
            751231582,
            972424306,
            623534362,
            335160196,
            243276029,
            554749550,
            60050552,
            797848181,
            395891998,
            172428290,
            159554990,
            887420150,
            970055531,
            250388809,
            487998999,
            856259313,
            82104855,
            232253360,
            513365505,
            244109365,
            1559745,
            695345956,
            261384175,
            849009131,
            323214113,
            747664143,
            444090941,
            659224434,
            80729842,
            570033864,
            664989237,
            827348878,
            195888993,
            576798521,
            457882808,
            731551699,
            212938473,
            509096183,
            827544702,
            678320208,
            677711203,
            289752035,
            66404266,
            555972231,
            195290384,
            97136305,
            349551356,
            785113347,
            83489485,
            66247239,
            52167191,
            307390891,
            547665832,
            143066173,
            350016754,
            917404120,
            296269301,
            996122673,
            23015220,
            602139210,
            748566338,
            187348575,
            109838563,
            574053420,
            105574531,
            304173654,
            542432219,
            34538816,
            325636655,
            437843114,
            630621321,
            26853683,
            933245637,
            616368450,
            238971581,
            511371690,
            557301633,
            911398531,
            848952161,
            958992544,
            925152039,
            914456118,
            724691727,
            636817583,
            238087006,
            946237212,
            910291942,
            114985663,
            492237273,
            450387329,
            834860913,
            763017204,
            368925948,
            475812562,
            740594930,
            45060610,
            806047532,
            464456846,
            172115341,
            75307702,
            116261993,
            562519302,
            268838846,
            173784895,
            243624360,
            61570384,
            481661251,
            938269070,
            95182730,
            91068149,
            115435332,
            495022305,
            136026497,
            506496856,
            710729672,
            113570024,
            366384665,
            564758715,
            270239666,
            277118392,
            79874094,
            702807165,
            112390913,
            730341625,
            103056890,
            677948390,
            339464594,
            167240465,
            108312174,
            839079953,
            479334442,
            271788964,
            135498044,
            277717575,
            591048681,
            811637561,
            353339603,
            889410460,
            839849206,
            192345193,
            736265527,
            316439118,
            217544623,
            788132977,
            618898635,
            183011467,
            380858207,
            996097969,
            898554793,
            335353644,
            54062950,
            611251733,
            419363534,
            965429853,
            160398980,
            151319402,
            990918946,
            607730875,
            450718279,
            173539388,
            648991369,
            970937898,
            500780548,
            780122909,
            39052406,
            276894233,
            460373282,
            651081062,
            461415770,
            358700839,
            643638805,
            560006119,
            668123525,
            686692315,
            673464765,
            957633609,
            199866123,
            563432246,
            841799766,
            385330357,
            504962686,
            954061253,
            128487469,
            685707545,
            299172297,
            717975101,
            577786541,
            318951960,
            773206631,
            306832604,
            204355779,
            573592106,
            30977140,
            450398100,
            363172638,
            258379324,
            472935553,
            93940075,
            587220627,
            776264326,
            793270300,
            291733496,
            522049725,
            579995261,
            335416359,
            142946099,
            472012302,
            559947225,
            332139472,
            499377092,
            464599136,
            164752359,
            309058615,
            86117128,
            580204973,
            563781682,
            954840109,
            624577416,
            895609896,
            888287558,
            836813268,
            926036911,
            386027524,
            184419613,
            724205533,
            403351886,
            715247054,
            716986954,
            830567832,
            383388563,
            68409439,
            6734065,
            189239124,
            68322490,
            943653305,
            405755338,
            811056092,
            179518046,
            825132993,
            343807435,
            985084650,
            868553027,
            148528617,
            160684257,
            882148737,
            591915968,
            701445829,
            529726489,
            302177126,
            974886682,
            241107368,
            798830099,
            940567523,
            11633075,
            325334066,
            346091869,
            115312728,
            473718967,
            218129285,
            878471898,
            180002392,
            699739374,
            917084264,
            856859395,
            435327356,
            808651347,
            421623838,
            105419548,
            59883031,
            322487421,
            79716267,
            715317963,
            429277690,
            398078032,
            316486674,
            384843585,
            940338439,
            937409008,
            940524812,
            947549662,
            833550543,
            593524514,
            996164327,
            987314628,
            697611981,
            636177449,
            274192146,
            418537348,
            925347821,
            952831975,
            893732627,
            1277567,
            358655417,
            141866945,
            581830879,
            987597705,
            347046911,
            775305697,
            125354499,
            951540811,
            247662371,
            343043237,
            568392357,
            997474832,
            209244402,
            380480118,
            149586983,
            392838702,
            309134554,
            990779998,
            263053337,
            325362513,
            780072518,
            551028176,
            990826116,
            989944961,
            155569943,
            596737944,
            711553356,
            268844715,
            451373308,
            379404150,
            462639908,
            961812918,
            654611901,
            382776490,
            41815820,
            843321396,
            675258797,
            845583555,
            934281721,
            741114145,
            275105629,
            666247477,
            325912072,
            526131620,
            252551589,
            432030917,
            554917439,
            818036959,
            754363835,
            795190182,
            909210595,
            278704903,
            719566487,
            628514947,
            424989675,
            321685608,
            50590510,
            832069712,
            198768464,
            702004730,
            99199382,
            707469729,
            747407118,
            302020341,
            497196934,
            5003231,
            726997875,
            382617671,
            296229203,
            183888367,
            703397904,
            552133875,
            732868367,
            350095207,
            26031303,
            863250534,
            216665960,
            561745549,
            352946234,
            784139777,
            733333339,
            503105966,
            459878625,
            803187381,
            16634739,
            180898306,
            68718097,
            985594252,
            404206040,
            749724532,
            97830135,
            611751357,
            31131935,
            662741752,
            864326453,
            864869025,
            167831173,
            559214642,
            718498895,
            91352335,
            608823837,
            473379392,
            385388084,
            152267158,
            681756977,
            46819124,
            313132653,
            56547945,
            442795120,
            796616594,
            256141983,
            152028387,
            636578562,
            385377759,
            553033642,
            491415383,
            919273670,
            996049638,
            326686486,
            160150665,
            141827977,
            540818053,
            693305776,
            593938674,
            186576440,
            688809790,
            565456578,
            749296077,
            519397500,
            551096742,
            696628828,
            775025061,
            370732451,
            164246193,
            915265013,
            457469634,
            923043932,
            912368644,
            777901604,
            464118005,
            637939935,
            956856710,
            490676632,
            453019482,
            462528877,
            502297454,
            798895521,
            100498586,
            699767918,
            849974789,
            811575797,
            438952959,
            606870929,
            907720182,
            179111720,
            48053248,
            508038818,
            811944661,
            752550134,
            401382061,
            848924691,
            764368449,
            34629406,
            529840945,
            435904287,
            26011548,
            208184231,
            446477394,
            206330671,
            366033520,
            131772368,
            185646898,
            648711554,
            472759660,
            523696723,
            271198437,
            25058942,
            859369491,
            817928963,
            330711333,
            724464507,
            437605233,
            701453022,
            626663115,
            281230685,
            510650790,
            596949867,
            295726547,
            303076380,
            465070856,
            272814771,
            538771609,
            48824684,
            951279549,
            939889684,
            564188856,
            48527183,
            201307702,
            484458461,
            861754542,
            326159309,
            181594759,
            668422905,
            286273596,
            965656187,
            44135644,
            359960756,
            936229527,
            407934361,
            267193060,
            456152084,
            459116722,
            124804049,
            262322489,
            920251227,
            816929577,
            483924582,
            151834896,
            167087470,
            490222511,
            903466878,
            361583925,
            368114731,
            339383292,
            388728584,
            218107212,
            249153339,
            909458706,
            322908524,
            202649964,
            92255682,
            573074791,
            15570863,
            94331513,
            744158074,
            196345098,
            334326205,
            9416035,
            98349682,
            882121662,
            769795511,
            231988936,
            888146074,
            137603545,
            582627184,
            407518072,
            919419361,
            909433461,
            986708498,
            310317874,
            373745190,
            263645931,
            256853930,
            876379959,
            702823274,
            147050765,
            308186532,
            175504139,
            180350107,
            797736554,
            606241871,
            384547635,
            273712630,
            586444655,
            682189174,
            666493603,
            946867127,
            819114541,
            502371023,
            261970285,
            825871994,
            126925175,
            701506133,
            314738056,
            341779962,
            561011609,
            815463367,
            46765164,
            49187570,
            188054995,
            957939114,
            64814326,
            933376898,
            329837066,
            338121343,
            765215899,
            869630152,
            978119194,
            632627667,
            975266085,
            435887178,
            282092463,
            129621197,
            758245605,
            827722926,
            201339230,
            918513230,
            322096036,
            547838438,
            985546115,
            852304035,
            593090119,
            689189630,
            555842733,
            567033437,
            469928208,
            212842957,
            117842065,
            404149413,
            155133422,
            663307737,
            208761293,
            206282795,
            717946122,
            488906585,
            414236650,
            280700600,
            962670136,
            534279149,
            214569244,
            375297772,
            811053196,
            922377372,
            289594327,
            219932130,
            211487466,
            701050258,
            398782410,
            863002719,
            27236531,
            217598709,
            375472836,
            810551911,
            178598958,
            247844667,
            676526196,
            812283640,
            863066876,
            857241854,
            113917835,
            624148346,
            726089763,
            564827277,
            826300950,
            478982047,
            439411911,
            454039189,
            633292726,
            48562889,
            802100365,
            671734977,
            945204804,
            508831870,
            398781902,
            897162044,
            644050694,
            892168027,
            828883117,
            277714559,
            713448377,
            624500515,
            590098114,
            808691930,
            514359662,
            895205045,
            715264908,
            628829100,
            484492064,
            919717789,
            513196123,
            748510389,
            403652653,
            574455974,
            77123823,
            172096141,
            819801784,
            581418893,
            15655126,
            15391652,
            875641535,
            203191898,
            264582598,
            880691101,
            907800444,
            986598821,
            340030191,
            264688936,
            369832433,
            785804644,
            842065079,
            423951674,
            663560047,
            696623384,
            496709826,
            161960209,
            331910086,
            541120825,
            951524114,
            841656666,
            162683802,
            629786193,
            190395535,
            269571439,
            832671304,
            76770272,
            341080135,
            421943723,
            494210290,
            751040886,
            317076664,
            672850561,
            72482816,
            493689107,
            135625240,
            100228913,
            684748812,
            639655136,
            906233141,
            929893103,
            277813439,
            814362881,
            562608724,
            406024012,
            885537778,
            10065330,
            60625018,
            983737173,
            60517502,
            551060742,
            804930491,
            823845496,
            727416538,
            946421040,
            678171399,
            842203531,
            175638827,
            894247956,
            538609927,
            885362182,
            946464959,
            116667533,
            749816133,
            241427979,
            871117927,
            281804989,
            163928347,
            563796647,
            640266394,
            774625892,
            59342705,
            256473217,
            674115061,
            918860977,
            322633051,
            753513874,
            393556719,
            304644842,
            767372800,
            161362528,
            754787150,
            627655552,
            677395736,
            799289297,
            846650652,
            816701166,
            687265514,
            787113234,
            358757251,
            701220427,
            607715125,
            245795606,
            600624983,
            10475577,
            728620948,
            759404319,
            36292292,
            491466901,
            22556579,
            114495791,
            647630109,
            586445753,
            482254337,
            718623833,
            763514207,
            66547751,
            953634340,
            351472920,
            308474522,
            494166907,
            634359666,
            172114298,
            865440961,
            364380585,
            921648059,
            965683742,
            260466949,
            117483873,
            962540888,
            237120480,
            620531822,
            193781724,
            213092254,
            107141741,
            602742426,
            793307102,
            756154604,
            236455213,
            362928234,
            14162538,
            753042874,
            778983779,
            25977209,
            49389215,
            698308420,
            859637374,
            49031023,
            713258160,
            737331920,
            923333660,
            804861409,
            83868974,
            682873215,
            217298111,
            883278906,
            176966527,
            954913,
            105359006,
            390019735,
            10430738,
            706334445,
            315103615,
            567473423,
            708233401,
            48160594,
            946149627,
            346966053,
            281329488,
            462880311,
            31503476,
            185438078,
            965785236,
            992656683,
            916291845,
            881482632,
            899946391,
            321900901,
            512634493,
            303338827,
            121000338,
            967284733,
            492741665,
            152233223,
            165393390,
            680128316,
            917041303,
            532702135,
            741626808,
            496442755,
            536841269,
            131384366,
            377329025,
            301196854,
            859917803,
            676511002,
            373451745,
            847645126,
            823495900,
            576368335,
            73146164,
            954958912,
            847549272,
            241289571,
            646654592,
            216046746,
            205951465,
            3258987,
            780882948,
            822439091,
            598245292,
            869544707,
            698611116,
        ];
        #[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 comp_library::math::prime::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());
            }
        }
    }
    mod read {
        #[macro_export]
        macro_rules ! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; let mut next = || { iter . next ( ) . unwrap ( ) } ; $ crate :: 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 ( ) } ; $ crate :: input_inner ! { next , $ ( $ r ) * } } ; }
        #[doc(hidden)]
        #[macro_export]
        macro_rules ! input_inner { ( $ next : expr ) => { } ; ( $ next : expr , ) => { } ; ( $ next : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = $ crate :: read_value ! ( $ next , $ t ) ; $ crate :: input_inner ! { $ next $ ( $ r ) * } } ; }
        #[doc(hidden)]
        #[macro_export]
        macro_rules ! read_value { ( $ next : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( $ crate :: read_value ! ( $ next , $ t ) ) ,* ) } ; ( $ next : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | $ crate :: read_value ! ( $ next , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ next : expr , chars ) => { $ crate :: read_value ! ( $ next , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ next : expr , usize1 ) => { $ crate :: read_value ! ( $ next , usize ) - 1 } ; ( $ next : expr , $ t : ty ) => { $ next ( ) . parse ::<$ t > ( ) . expect ( "Parse error" ) } ; }
        pub trait FromLn {
            fn fromln(s: &str) -> Self;
        }
        pub fn readln<T: FromLn>() -> T {
            let mut buf = String::new();
            let _ = ::std::io::stdin().read_line(&mut buf).unwrap();
            T::fromln(buf.trim())
        }
        pub fn readlns<T: FromLn>(n: usize) -> Vec<T> {
            let mut vs = vec![];
            for _ in 0..n {
                vs.push(readln());
            }
            vs
        }
        macro_rules ! fromln_primitives { ( $ ( $ t : ty ) ,* ) => { $ ( impl FromLn for $ t { fn fromln ( s : & str ) -> $ t { s . parse ( ) . unwrap ( ) } } ) * } }
        fromln_primitives!(
            String,
            bool,
            f32,
            f64,
            isize,
            i8,
            i16,
            i32,
            i64,
            usize,
            u8,
            u16,
            u32,
            u64
        );
        impl<T> FromLn for Vec<T>
        where
            T: FromLn,
        {
            fn fromln(s: &str) -> Vec<T> {
                s.split_whitespace().map(T::fromln).collect()
            }
        }
        impl FromLn for Vec<char> {
            fn fromln(s: &str) -> Vec<char> {
                s.chars().collect()
            }
        }
        macro_rules ! fromln_tuple { ( $ ( $ t : ident ) ,* ) => { impl <$ ( $ t ) ,*> FromLn for ( $ ( $ t ) ,* ) where $ ( $ t : FromLn ) ,* { fn fromln ( s : & str ) -> ( $ ( $ t ) ,* ) { let mut it = s . split_whitespace ( ) ; let t = ( $ ( $ t :: fromln ( it . next ( ) . unwrap ( ) ) ) ,* ) ; assert_eq ! ( it . next ( ) , None ) ; t } } } }
        fromln_tuple!(A, B);
        fromln_tuple!(A, B, C);
        fromln_tuple!(A, B, C, D);
        fromln_tuple!(A, B, C, D, E);
        fromln_tuple!(A, B, C, D, E, F);
    }
    pub use self::permutation::*;
    pub use self::read::*;
}