Problem:
Score : 100 points

Problem Statement

You are given three integers A, B and C.

Determine if there exists an equilateral triangle whose sides have lengths A, B and C.

Constraints

All values in input are integers.

1 \leq A,B,C \leq 100

Input

Input is given from Standard Input in the following format:

A B C

Output

If there exists an equilateral triangle whose sides have lengths A, B and C, print Yes; otherwise, print No.

Sample Input 1

2 2 2

Sample Output 1

Yes

There exists an equilateral triangle whose sides have lengths 2, 2 and 2.

Sample Input 2

3 4 5

Sample Output 2

No

There is no equilateral triangle whose sides have lengths 3, 4 and 5.

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

pub mod mylib {
use std;
use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
use std::cmp::PartialEq;
use std::str::FromStr;
use std::num::ParseIntError;
use std::fmt::{Display, Formatter};

#[macro_use]
mod macros {
macro_rules! impl_to_modint {
	($($t:ty)*) => ($(
		impl <MOD: ModNumber> ToModInt<MOD> for $t {
			#[inline]
			fn to_modint(self) -> ModInt<MOD> {
				if <$t>::min_value() == 0 {
					<MOD>::from_bu(self as u64)
				} else {
					<MOD>::from_bi(self as i64)
				}
			}
		}
	)*)
}
macro_rules! impl_modint {
	($($im:ty,$b:block);*) => ($(
		impl ModNumber for $im {
			type ModType = u32;
			fn modv() -> Self::ModType $b
			#[inline]
			from_bi_prim_to_modint!($im);
			#[inline]
			from_bu_prim_to_modint!($im);
			#[inline]
			fn direct(x: u32) -> ModInt<$im> {
				ModInt::<$im>(x)
			}
		}
	)*)
}

macro_rules! from_bu_prim_to_modint {
	($($im:ty),*) => ($(
		fn from_bu(x: u64) -> ModInt<$im> {
			let m = <$im>::modv() as u64;
			ModInt::<$im>((x % m) as u32)
		}
	)*)
}
macro_rules! from_bi_prim_to_modint {
	($($im:ty),*) => ($(
		fn from_bi(i: i64) -> ModInt<$im> {
			let m = <$im>::modv() as i64;
			let mut i = i % m;
			if i < 0 {i += m;}
			ModInt::<$im>((i % m) as u32)
		}
	)*)
}

macro_rules! impl_modint_operators {
	($($m:ty)*) => ($(
		impl Add<ModInt<$m>> for ModInt<$m> {
			type Output = ModInt<$m>;
			fn add(self, rhs: ModInt<$m>) -> ModInt<$m> {
				ModInt::<$m>((self.0 + rhs.0) % <$m>::modv())
			}
		}
		impl AddAssign<ModInt<$m>> for ModInt<$m> {
			fn add_assign(&mut self, rhs: ModInt<$m>) {
				*self = *self + rhs;
			}
		}
		impl Sub<ModInt<$m>> for ModInt<$m> {
			type Output = ModInt<$m>;
			fn sub(self, rhs: ModInt<$m>) -> ModInt<$m> {
				let mut x = self.0 as i32 - rhs.0 as i32;
				if x < 0 {x += <$m>::modv() as i32}
				ModInt::<$m>(x as u32 % <$m>::modv())
			}
		}
		impl SubAssign<ModInt<$m>> for ModInt<$m> {
			fn sub_assign(&mut self, rhs: ModInt<$m>) {
				*self = *self - rhs;
			}
		}
		impl Mul<ModInt<$m>> for ModInt<$m> {
			type Output = ModInt<$m>;
			fn mul(self, rhs: ModInt<$m>) -> ModInt<$m> {
				let x = self.0 as u64 * rhs.0 as u64;
				ModInt::<$m>((x % <$m>::modv() as u64) as u32)
			}
		}
		impl MulAssign<ModInt<$m>> for ModInt<$m> {
			fn mul_assign(&mut self, rhs: ModInt<$m>) {
				*self = *self * rhs;
			}
		}
		impl Div<ModInt<$m>> for ModInt<$m> {
			type Output = ModInt<$m>;
			fn div(self, rhs: ModInt<$m>) -> ModInt<$m> {
				self * rhs.pow((<$m>::modv() - 2) as u64)
			}
		}
		impl DivAssign<ModInt<$m>> for ModInt<$m> {
			fn div_assign(&mut self, rhs: ModInt<$m>) {
				*self = *self / rhs;
			}
		}
		impl PartialEq<ModInt<$m>> for ModInt<$m> {
			fn eq(&self, rhs: &ModInt<$m>) -> bool {
				self.0 == rhs.0
			}
		}
	)*)
}
macro_rules! impl_modint_fromstr {
	($($m:ty),*) => ($(
		impl FromStr for ModInt<$m> {
			type Err = ParseIntError;
			fn from_str(s: &str) -> Result<Self, Self::Err> {
				if s.bytes().next() == Some(b'-') {
					Ok(<$m>::from_bi(s.parse::<i64>()?))
				} else {
					Ok(<$m>::from_bu(s.parse::<u64>()?))
				}
			}
		}
	)*)
}
macro_rules! impl_modint_display {
	($($m:ty),*) => ($(
		impl Display for ModInt<$m> {
			fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
				write!(f, "{}", self.0)
			}
		}
	)*)
}
} // mod macros

pub trait ToModInt<MOD: ModNumber> {
	fn to_modint(self) -> ModInt<MOD>;
}
impl_to_modint!(i8 i16 i32 i64 u8 u16 u32 u64 usize isize);

pub trait ModNumber : Clone + Copy {
	type ModType: Clone + Copy;
	fn modv() -> Self::ModType;
	fn from_bi(x: i64) -> ModInt<Self>;
	fn from_bu(x: u64) -> ModInt<Self>;
	fn direct(x: u32) -> ModInt<Self>;
}

impl_modint!(RuntimeMod, {unsafe{RUNTIME_MOD}};
             Mod107, {1_000_000_007};
             Mod998, {998_244_353});


static mut RUNTIME_MOD: u32 = 0;
#[derive(Clone, Copy)]
pub struct RuntimeMod {}
impl RuntimeMod {
	pub fn set(x: u32) {
		unsafe {
			RUNTIME_MOD = x;
		}
	}
}
#[derive(Clone, Copy)]
pub struct Mod107 {}
#[derive(Clone, Copy)]
pub struct Mod998 {}
#[derive(Clone, Copy)]
pub struct ModInt<MOD: ModNumber> (pub MOD::ModType);

impl_modint_operators!(Mod107 Mod998 RuntimeMod);

impl<MOD: ModNumber> ModInt<MOD> 
where 
	ModInt<MOD>: MulAssign
{
	pub fn pow(self, mut p: u64) -> Self {
		let mut res = <MOD>::direct(1);
		let mut m = self;
		while p != 0 {
			if p & 1 == 1 {
				res *= m;
			}
			p >>= 1;
			m *= m;
		}
		res
	}
}

impl_modint_fromstr!(RuntimeMod, Mod107, Mod998);

impl_modint_display!(RuntimeMod, Mod107, Mod998);
}

pub struct IO<R, W: std::io::Write>(R, std::io::BufWriter<W>);

impl<R: std::io::Read, W: std::io::Write> IO<R, W> {
    pub fn new(r: R, w: W) -> IO<R, W> {
        IO(r, std::io::BufWriter::new(w))
    }
    pub fn write<S: ToString>(&mut self, s: S) {
        use std::io::Write;
        self.1.write(s.to_string().as_bytes()).unwrap();
    }
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .0
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }
    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_io() {
        let input = br"10
        1 2 3 4 5 6 7 8 9 10
        abcde fghij
        
        3.14 -1592
        no_empty_line";
        let mut sc = IO::new(&input[..], Vec::new());

        let n: usize = sc.read();
        assert_eq!(n, 10);

        let a: Vec<u64> = sc.vec(n);
        assert_eq!(&a, &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

        let s = sc.chars();
        let t = sc.chars();
        assert_eq!(&s, &['a', 'b', 'c', 'd', 'e']);
        assert_eq!(&t, &['f', 'g', 'h', 'i', 'j']);

        let f: f64 = sc.read();
        assert_eq!(f, 3.14);

        let neg: i64 = sc.read();
        assert_eq!(neg, -1592);

        let s = sc.read::<String>();
        assert_eq!(&s, "no_empty_line");
        sc.write(format!("1\n"));

        let mut output = Vec::new();
        {
            let mut sc = IO::new(&b""[..], &mut output);
            sc.write(format!("{}\n", 1));
            sc.write(format!("{}\n", 2));
            sc.write(format!("{}\n", 3));
        }

        let output = String::from_utf8(output).expect("Not UTF-8");
        assert_eq!(&output, "1\n2\n3\n");
    }
}

// type ModType = mylib::RuntimeMod;
 type ModType = mylib::Mod107;
// type ModType = mylib::Mod998;
type ModInt = mylib::ModInt<ModType>;
 
#[inline]
fn modint<T: mylib::ToModInt<ModType>>(x: T) -> ModInt {
	x.to_modint()
}

fn main() {
	let (r, w) = (std::io::stdin(), std::io::stdout());
	let mut sc = IO::new(r.lock(), w.lock());
	let b: usize = sc.read();
	let w: usize = sc.read();

	let n = b + w;
	let mut fact = vec![modint(1); n];
	for i in 1..n {
		fact[i] = fact[i-1] * modint(i);
	}
	let comb = |n: usize, r: usize| fact[n] / fact[r] / fact[n-r];
	let mut p = modint(0);
	let mut q = modint(0);
 
	for i in 1..n+1 {
		println!("{}", ((modint(1) - p + q) / modint(2)).0);
		if i >= b {
			p += comb(i-1, b-1) / modint(2).pow(i as u64);
		}
		if i >= w {
			q += comb(i-1, w-1) / modint(2).pow(i as u64);
		}
	}

}