100 10
87 73
15 71
14 33
1 4
20 80
65 67
36 36
25 4
22 21
7 97
 4 2
3 3
3 4
 5 4
3 3
4 4
5 5
1 2
 4 4
1 2
2 3
3 1
4 4
 4 3
1 1
2 3
3 4
 1000000 1
255765 255765
 4 3
1 2
2 3
4 4
 4 2
1 1
1 2
 3 3
1 1
2 2
3 3
 5 4
1 1
2 3
2 4
2 5
 4 5
1 4
3 4
1 2
2 3
2 4
 4 4
2 3
2 4
3 4
4 4
 10 9
8 10
3 10
2 8
9 3
4 8
1 10
7 9
5 4
7 3
 10 10
1 2
2 3
3 4
4 5
5 1
6 6
7 7
8 8
9 9
10 10
 5 5
1 4
3 4
1 2
2 3
2 4
 3 3
1 2
2 2
3 3
 5 3
1 1
2 2
3 3
 6 12
1 2
1 3
2 3
1 1
2 2
3 3
4 5
5 6
4 6
4 4
5 5
6 6
 4 4
1 2
2 3
1 3
4 4
 5 4
1 2
3 3
4 4
5 5
 7 13
6 7
2 7
3 7
4 3
5 2
1 4
7 7
3 1
5 5
3 3
1 5
2 6
6 6
 2 2
1 1
2 2
 5 5
1 1
2 2
3 3
4 4
5 5
 1 1
1 1
 7 3
1 1
3 3
6 6
 3 3
1 1
2 3
3 3

0 1 0 0 0 0 0 1 0 0 8 6 12 0 8 0 0 0 0 0 57 0 0 0 0 0
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class Main {

	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;

		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);

		TaskD solver = new TaskD();
		solver.solve(in, out);

		out.close();
	}

}

class TaskD {

	public void solve(InputReader in, OutputWriter out) {
		
		int n = in.nextInt();
		int m = in.nextInt();
		used = new boolean[n];
		tin = new int[n];
		fup = new int[n];
		nb = new  long[n];
		//bridges = new TreeSet<Edge>();
		
		
		g = new ArrayList[n];
		for(int i = 0; i < n; i++) {
			g[i] = new ArrayList<Integer>();
		}
		
		for(int i = 0; i < m; i++) {
			int u = in.nextInt()-1;
			int v = in.nextInt()-1;
			nb[u]++;
			nb[v]++;
			if(u==v) nb[u]--;
			g[u].add(v);
			g[v].add(u);
		}
		
		int cnt = 0;
		timer = 0;
		for(int i = 0; i < n; i++) {
			if(!used[i]) {
				dfs(i, -1);
				cnt++;
			}
		}
		if(cnt > 1) {
			out.write(0);
			return;
		}
		/*
		for(int i = 0; i < n; i++) {
			System.out.print(nb[i] + " "); 
		}
		System.out.println();
		*/
		long sum = 0;
		for(int i = 0; i < n; i++) {
			sum += (nb[i]*(nb[i]-1))/2L;
		}
		
		long e = ans;
		out.write(sum + (ans*(ans-1L))/2L);
		
	}
	
	boolean[] used;
	int timer;
	int[] tin, fup;
	ArrayList<Integer>[] g;
	long[] nb;
	//TreeSet<Edge> bridges;
	
	int ans = 0;
	
	void dfs(int v, int p) {
		used[v] = true;
		tin[v] = fup[v] = timer++;
		for(int i = 0; i < g[v].size(); i++) {
			int to = g[v].get(i);
			if(to == p) continue;
			if(used[to]) {
				fup[v] = Math.min(fup[v], tin[to]);
			} else {
				dfs(to, v);
				fup[v] = Math.min(fup[v], fup[to]);
				if(fup[to] > tin[v]) {
					ans++;
					nb[to]--;
					nb[v]--;
					//bridges.add(new Edge(v, to));
				}
			}
		}
	}

}

class Edge implements Comparable<Edge>{
	
	public Edge(int a, int b) {
		this.a = Math.min(a,b);
		this.b = Math.max(a,b);
	}
	
	public int compareTo(Edge e) {
		if(this.a == e.a)
			return this.b - e.b;
		else
			return this.a - e.a;
	}
 	
	int a,b;
}

class InputReader {

	public InputReader(InputStream inputStream) {
		tokenizer = null;
		reader = new BufferedReader(new InputStreamReader(inputStream));
	}

	public String next() {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(reader.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}

		return tokenizer.nextToken();
	}

	public String nextLine() {
		try {
			return reader.readLine();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}

	public int nextInt() {
		return Integer.parseInt(next());
	}

	StringTokenizer tokenizer;
	BufferedReader reader;
}

class OutputWriter {

	public OutputWriter(OutputStream outputStream) {
		out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
				outputStream)));
	}

	public void write(Object... o) {
		for (Object x : o)
			out.print(x);
	}

	public void writeln(Object... o) {
		write(o);
		out.println();
	}

	public void close() {
		out.close();
	}

	PrintWriter out;
}