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 Java8 (OpenJDK 1.8.0) (judge verdict: Time Limit Exceeded)

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Scanner;

class Main {
    void solve() {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), m = in.nextInt();
        HashSet<Long> set = new HashSet<>();
        ArrayList<S> list = new ArrayList<>();
        for(int i = 0; i < m; i++) {
            long a = in.nextLong() - 1, b = in.nextLong() - 1;
            if(a > b) {
                long c = a;
                a = b;
                b = c;
            }
            list.add(new S(a, b));
            set.add(a * n + b);
        }
        boolean f = true;
        int ans = 0;
        while(f) {
            f = false;
            for(int i = 0; i < list.size() - 1; i++) {
                for(int j = i; j < list.size(); j++) {
                    S s1 = list.get(i), s2 = list.get(j);
                    
                    long[] a  = {s1.a, s1.a, s1.b, s1.b};
                    long[] b  = {s2.a, s2.b, s2.a, s2.b};
                    long[] a2 = {s1.b, s1.b, s1.a, s1.a};
                    long[] b2 = {s2.b, s2.a, s2.b, s2.a};
                    
                    for(int k = 0; k < 4; k++) {
                        long from = Math.min(a[k], b[k]);
                        long to = Math.max(a[k], b[k]);
                        
                        if(from == to) {
                            continue;
                        }
                        if(set.contains(new Long(from * n + to))) {
                            continue;
                        }
                        
                        long from2 = Math.min(a2[k], b2[k]);
                        long to2 = Math.max(a2[k], b2[k]);
                        if(from2 == to2) {
                            continue;
                        }
                        if(set.contains(new Long(from2 * n + to2))) {
                            f = true;
                            ans++;
                            set.add(from * n + to);
                            list.add(new S(from, to));
                        }   
                    }
                }
            }
        }
        System.out.println(ans);
    }

    public static void main(String[] args) {
        new Main().solve();
    }
}
class S{
    long a, b;
    public S(long a, long b) {
        this.a = a;
        this.b = b;
    }
}