#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class UnionFind {
private:
    vector<int> parent;
    vector<int> parity; // paritás a gyökérhez képest

public:
    UnionFind(int n) : parent(n + 1), parity(n + 1, 0) {
        for (int i = 0; i <= n; i++) {
            parent[i] = i;
        }
    }

    pair<int, int> find(int x) {
        if (parent[x] == x) {
            return {x, 0};
        }
        auto [root, par] = find(parent[x]);
        parent[x] = root;
        parity[x] ^= par;
        return {root, parity[x]};
    }

    // Visszatér true-val, ha sikerült egyesíteni (nem volt páratlan kör)
    // Visszatér false-szal, ha páratlan kör keletkezett
    bool unite(int a, int b) {
        auto [root_a, par_a] = find(a);
        auto [root_b, par_b] = find(b);

        if (root_a == root_b) {
            // Már ugyanabban a komponensben vannak
            // Páratlan kör van, ha a paritásuk azonos
            return par_a != par_b;
        }

        // Egyesítjük a két komponenst
        parent[root_b] = root_a;
        parity[root_b] = par_a ^ par_b ^ 1;
        return true;
    }

    void reset(int n) {
        for (int i = 0; i <= n; i++) {
            parent[i] = i;
            parity[i] = 0;
        }
    }
};

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int N, M;
    cin >> N >> M;

    vector<pair<int, int>> edges(M);
    for (int i = 0; i < M; i++) {
        cin >> edges[i].first >> edges[i].second;
    }

    long long result = 0;
    int l = 0;

    for (int r = 0; r < M; r++) {
        // Próbáljuk meg hozzáadni az r-edik élt
        // Újraépítjük a Union-Find-ot az [l, r] intervallumra
        bool has_odd_cycle = false;

        while (l <= r) {
            UnionFind uf(N);
            has_odd_cycle = false;

            // Építsük fel a gráfot az [l, r] élekkel
            for (int i = l; i <= r; i++) {
                if (!uf.unite(edges[i].first, edges[i].second)) {
                    has_odd_cycle = true;
                    break;
                }
            }

            if (!has_odd_cycle) {
                // PG(l, r) páros gráf
                break;
            } else {
                // Páratlan kör van, növeljük l-et
                l++;
            }
        }

        if (l <= r) {
            // [l, r] intervallum páros, így [l, r], [l+1, r], ..., [r, r] mind páros
            result += (r - l + 1);
        }
    }

    cout << result << endl;

    return 0;
}