Problem:
Score : 500 points

Problem Statement

Rng has a connected undirected graph with N vertices.
Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.

Rng will add new edges to the graph by repeating the following operation:

Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.

Find the maximum possible number of edges that can be added.

Constraints

2 \leq N \leq 10^5

1 \leq M \leq 10^5

1 \leq A_i,B_i \leq N

The graph has no self-loops or multiple edges.

The graph is connected.

Input

Input is given from Standard Input in the following format:

N M
A_1 B_1
A_2 B_2
:
A_M B_M

Output

Find the maximum possible number of edges that can be added.

Sample Input 1

6 5
1 2
2 3
3 4
4 5
5 6

Sample Output 1

4

If we add edges as shown below, four edges can be added, and no more.

Sample Input 2

5 5
1 2
2 3
3 1
5 4
5 1

Sample Output 2

5

Five edges can be added, for example, as follows:

Add an edge connecting Vertex 5 and Vertex 3.

Add an edge connecting Vertex 5 and Vertex 2.

Add an edge connecting Vertex 4 and Vertex 1.

Add an edge connecting Vertex 4 and Vertex 2.

Add an edge connecting Vertex 4 and Vertex 3.

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

use std::io::Read;


#[derive(Copy, Clone)]
struct Edge{
    from: usize,
    to: usize,
    weight: i64,
}

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();

    // get stdio    
    let n: usize = iter.next().unwrap().parse().unwrap();
    let m: usize = iter.next().unwrap().parse().unwrap();
    
    let edges: Vec<(usize, usize)> = (0..m)
        .map(|_| {
            (
                iter.next().unwrap().parse::<usize>().unwrap() - 1,
                iter.next().unwrap().parse::<usize>().unwrap() - 1,
            )
        })
        .collect();


    // construct graph
    let mut graph: Vec<Vec<Edge>> = (0..n)
        .map(|_| {
            Vec::new()
        }).collect();

    for e in edges.iter() {
        graph[e.0].push( Edge{from:e.0, to:e.1, weight:1});
        graph[e.1].push( Edge{from:e.1, to:e.0, weight:1})
    }

    

    // dfs
    let mut stack: Vec<Edge> = Vec::new();
    stack.push(Edge{from:0, to:0, weight:0});

    let mut visited: Vec<bool> = vec![false; n];
    let mut color: Vec<i32> = vec![-1; n];
    color[0] = 2;

    let mut is_partite : bool = true;
    while let Some(e) = stack.pop()  {

        if visited[e.to] {
            continue;
        }
        visited[e.to] = true;
        color[e.to] = 3 - color[e.from];
        // match color[e.from] {
        //     1 => 2,
        //     2 => 1,
        //     _ => 0,
        // };
        for i in graph[e.to].iter() {
            if ! visited[i.to] {
                stack.push(*i);
            } else if color[i.from] == color[i.to] {
                is_partite = false; // if adjacent node's color is different, given graph is not bipartite.
            }
        }
    }
    
    let whites = color.iter().filter(|&x| *x == 1).collect::<Vec<&i32>>().len();
    if is_partite {
        println!("{}",  whites * (n-whites) - m);
    } else {
        println!("{}", n*(n-1)/2 - m);
    }

}