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.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class Main {

	static class Pair implements Comparable<Pair> {

		int v;
		long d;

		Pair(int v, long d) {
			this.v = v;
			this.d = d;
		}

		@Override
		public int compareTo(Pair o) {
			return Long.compare(d, o.d);
		}

		@Override
		public String toString() {
			return "(" + v + ", " + d + ")";
		}

	}

	int MOD = 1000 * 1000 * 1000 + 7;

	class Edge implements Comparable<Edge> {
		int to;
		long w;

		public Edge(int to, long w) {
			this.to = to;
			this.w = w;
		}

		@Override
		public int compareTo(Edge o) {
			return Long.compare(w, o.w);
		}
	}

	private ArrayList<Integer>[] G;
	private long oo = 100_000_000_000_000L;
	private int[] visited;

	private void solve() {
		int n = in.nextInt();
		int m = in.nextInt();
		visited = new int[n + 1];
		G = (ArrayList<Integer>[]) new ArrayList[n + 1];
		for (int i = 1; i <= n; i++) {
			G[i] = new ArrayList<Integer>();
		}

		long same = 0;
		for (int i = 0; i < m; i++) {
			int u = in.nextInt();
			int v = in.nextInt();
			if (u == v) {
				same++;
				continue;
			}
			G[u].add(v);
			G[v].add(u);
		}

		dfs(1);

		for (int i = 1; i <= n; i++) {
			if (visited[i] == 0) {
				out.print(0);
				return;
			}
		}

		long res = 0;

		for (int i = 1; i <= n; i++) {
			res += (G[i].size() * (G[i].size() - 1)) / 2;
		}

		res += same * (m - same);

		out.print(res);
	}
	/*
	 * 
	* 
	*/
	// --------------------------------------------------------

	private void dfs(int node) {
		visited[node] = 1;
		for (int v : G[node]) {
			if (visited[v] == 1) {
				continue;
			}
			dfs(v);
		}
	}

	private FastScanner in;
	private PrintWriter out;

	void runIO() {

		in = new FastScanner(System.in);
		out = new PrintWriter(System.out);

		solve();

		out.close();
	}

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner(File f) {
			try {
				br = new BufferedReader(new FileReader(f));
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

		public FastScanner(InputStream f) {
			br = new BufferedReader(new InputStreamReader(f));
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				String s = null;
				try {
					s = br.readLine();
				} catch (IOException e) {
					e.printStackTrace();
				}
				if (s == null)
					return null;
				st = new StringTokenizer(s);
			}
			return st.nextToken();
		}

		boolean hasMoreTokens() {
			while (st == null || !st.hasMoreTokens()) {
				String s = null;
				try {
					s = br.readLine();
				} catch (IOException e) {
					e.printStackTrace();
				}
				if (s == null)
					return false;
				st = new StringTokenizer(s);
			}
			return true;
		}

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

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}
	}

	public static void main(String[] args) {
		new Main().runIO();
	}
}