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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Wolfgang Beyer
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        boolean[] visited;
        List<Integer>[] adj;
        boolean[] selfloops;

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int m = in.nextInt();
            //long loopCount = 0;
            adj = new ArrayList[n];
            for (int i = 0; i < n; i++) {
                adj[i] = new ArrayList<>();
            }
            //selfloops = new HashSet<>();
            selfloops = new boolean[n];
            int loopCount = 0;

            int start = -1;
            for (int i = 0; i < m; i++) {
                int u = in.nextInt() - 1;
                int v = in.nextInt() - 1;
                if (u == v) {
                    //selfloops.add(u);
                    selfloops[u] = true;
                    loopCount++;
                } else {
                    adj[u].add(v);
                    adj[v].add(u);
                    start = u;
                }
            }

            visited = new boolean[n];

        /*int components = 0;
        for (int i = 0; i < n; i++) {
            if (!visited[i]) {
                size = 0;
                dfs(i);
                if (size > 1) {
                    components++;
                } else if ((size == 1) && (selfloops.contains(i))) {
                    components++;
                }
            }
        }
        if (components > 1) {
            out.println(0);
            return;
        }*/
            if (start == -1) {
                out.println(0);
                return;
            }
            dfs(start);
            for (int i = 0; i < n; i++) {
                if ((!visited[i]) && ((selfloops[i]) || (adj[i].size() > 0))) {
                    out.println(0);
                    return;
                }
            }


            long result = 0;
            for (int i = 0; i < n; i++) {
                long x = adj[i].size();
                if (x > 1) {
                    result += ((x * (x - 1)) / 2);
                }
            }

            //long loopCount = selfloops.size();
            result += loopCount * (m - loopCount);
            result += ((loopCount * (loopCount - 1)) / 2);
            out.println(result);
        }

        public void dfs(int a) {
            //size++;
            visited[a] = true;
            for (int neighbor : adj[a]) {
                if (!visited[neighbor]) {
                    dfs(neighbor);
                }
            }
        }

    }

    static class InputReader {
        private static BufferedReader in;
        private static StringTokenizer tok;

        public InputReader(InputStream in) {
            this.in = new BufferedReader(new InputStreamReader(in));
        }

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

        public String next() {
            try {
                while (tok == null || !tok.hasMoreTokens()) {
                    tok = new StringTokenizer(in.readLine());
                }
            } catch (IOException ex) {
                System.err.println("An IOException was caught :" + ex.getMessage());
            }
            return tok.nextToken();
        }

    }
}

