#include <bits/stdc++.h>

#define lsb(x) (x & (-x))

using ull = unsigned long long;
using ll = long long;

using namespace std;

constexpr int MAXN = (int) 1e5;
constexpr int LIM = 500;

bitset<LIM> adj[LIM + 1];
bitset<LIM> adj3[LIM + 1];

int main() {
#ifdef HOME
    ifstream cin("input.in");
    ofstream cout("output.out");
#endif
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    int n, m;
    cin >> n >> m;

    vector<pair<int, int>> edges;
    vector<int> deg(n + 1);
    for (int i = 1; i <= m; i++) {
        int x, y;
        cin >> x >> y;
        deg[x]++, deg[y]++;
        edges.emplace_back(x, y);
    }

    vector<int> nodes(n);
    iota(nodes.begin(), nodes.end(), 1);
    sort(nodes.begin(), nodes.end(), [&](const int& a, const int& b) {
        return deg[a] < deg[b];
    });

    vector<int> order(n + 1);
    for (int i = 0; i < n; i++) {
        order[nodes[i]] = i;
    }

    vector<vector<int>> g(n + 1);
    for (auto edge : edges) {
        int x = edge.first, y = edge.second;
        if (order[x] > order[y]) {
            swap(x, y);
        }
        g[x].push_back(y);
    }

    vector<int> pos(n + 1);

    ll answer = 0;
    for (auto v : nodes) {
        for (int i = 0; i < (int)g[v].size(); i++) {
            pos[g[v][i]] = i;
        }

        for (auto x : g[v]) {
            adj[pos[x]].reset();
            for (auto y : g[x]) {
                adj[pos[x]][pos[y]] = true;        
            }
            adj3[pos[x]].reset();
        }

        for (auto x : g[v]) {
            for (auto y : g[v]) {
                adj3[pos[x]][pos[y]] = adj[pos[x]][pos[y]];
            }
        }

        for (auto x : g[v]) {
            for (auto y : g[v]) {
                if (!adj[pos[x]][pos[y]]) continue;

                answer += (adj3[pos[x]] & adj3[pos[y]]).count();
            } 
        }
    }

    cout << answer;

    return 0;
}