Problem:
Score : 100 points

Problem Statement

We have N+M balls, each of which has an integer written on it.

It is known that:

The numbers written on N of the balls are even.

The numbers written on M of the balls are odd.

Find the number of ways to choose two of the N+M balls (disregarding order) so that the sum of the numbers written on them is even.

It can be shown that this count does not depend on the actual values written on the balls.

Constraints

0 \leq N,M \leq 100

2 \leq N+M

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N M

Output

Print the answer.

Sample Input 1

2 1

Sample Output 1

1

For example, let us assume that the numbers written on the three balls are 1,2,4.

If we choose the two balls with 1 and 2, the sum is odd;

If we choose the two balls with 1 and 4, the sum is odd;

If we choose the two balls with 2 and 4, the sum is even.

Thus, the answer is 1.

Sample Input 2

4 3

Sample Output 2

9

Sample Input 3

1 1

Sample Output 3

0

Sample Input 4

13 3

Sample Output 4

81

Sample Input 5

0 3

Sample Output 5

3

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

fn main() {
    let mut rd = acio::Reader::from_stdin();
    let n: u32 = rd.read();
    let m: u32 = rd.read();
    let mut s = 0;
    if 1 < n {
        s += n * (n - 1) / 2;
    }
    if 1 < m {
        s += m * (m - 1) / 2;
    }
    println!("{}", s);
}

//-- MODULES --

/// Mathematics Module
#[allow(dead_code)]
mod math {
    use std::mem::swap;

    /// Methods for Each Integer Type
    pub trait Integer {}
    /// Implements trait Integer
    macro_rules! integer {
        ($t:ty) => {
            impl Integer for $t {
                // NOTHING...
            }
        };
    }

    /// Methods for Each Natural Integer Type
    pub trait Natural {
        fn lcm(v1: Self, v2: Self) -> Self;
        fn gcd(v1: Self, v2: Self) -> Self;
    }
    /// Implements trait Natural
    macro_rules! natural {
        ($t:ty) => {
            impl Natural for $t {
                fn lcm(v1: $t, v2: $t) -> $t {
                    v1 * v2 / Self::gcd(v1, v2)
                }

                fn gcd(v1: $t, v2: $t) -> $t {
                    let (mut v1, mut v2) = (v1, v2);
                    if v1 < v2 {
                        swap(&mut v1, &mut v2);
                    }
                    while v2 != 0 {
                        let t = v1;
                        v1 = v2;
                        v2 = t % v2;
                    }
                    return v1;
                }
            }
        };
    }

    // BEGIN DECLARATIONS
    integer!(i8);
    integer!(i16);
    integer!(i32);
    integer!(i64);
    integer!(isize);
    integer!(u8);
    integer!(u16);
    integer!(u32);
    integer!(u64);
    integer!(usize);
    // ---
    natural!(u8);
    natural!(u16);
    natural!(u32);
    natural!(u64);
    natural!(usize);
    // END DECLARATIONS
}

/// IO Module for AtCoder
#[allow(dead_code)]
mod acio {
    use std::fmt::Debug;
    use std::io::{stdin, BufRead, BufReader, Read, Stdin};
    use std::str::FromStr;

    /// Multi-Purpose Value Reader
    pub struct Reader<R>
    where
        R: Read,
    {
        input: BufReader<R>,
        stack: Vec<String>,
    }

    impl<R: Read> Reader<R> {
        /// Create Reader from Read
        pub fn new<T>(input: R) -> Self {
            // Self { // <- Warning: NOT YET on AtCoder
            Reader {
                input: BufReader::new(input),
                stack: vec![],
            }
        }

        /// Read Multiple Value
        pub fn read_by<F>(&mut self, count: usize) -> Vec<F>
        where
            F: FromStr,
            <F as FromStr>::Err: Debug,
        {
            (0..count).map(|_| self.read()).collect()
        }

        /// Read Single Value
        pub fn read<F>(&mut self) -> F
        where
            F: FromStr,
            <F as FromStr>::Err: Debug,
        {
            while self.stack.is_empty() {
                let mut line = self.read_line();
                self.stack.append(&mut line);
                self.stack.reverse();
            }
            self.stack.pop().unwrap().parse().unwrap()
        }

        /// Read Space Split Line
        fn read_line(&mut self) -> Vec<String> {
            let mut buf = String::new();
            self.input.read_line(&mut buf).unwrap();
            buf.split_whitespace().map(|s| s.to_string()).collect()
        }
    }

    impl Reader<Stdin> {
        /// Create Reader from stdin
        pub fn from_stdin() -> Self {
            Self::new::<Reader<Stdin>>(stdin())
        }
    }

    /*
    impl<T> Drop for Reader<T> {
        /// FOR DEBUG
        fn drop(&mut self) {
            if self.stack.len() != 0 {
                panic!("Reader with remaining value is dropped.")
            }
        }
    }
    */
}