DELTA

#define task "DELTA"
#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>

using namespace std;

using ll = long long;
using ld = long double;

constexpr int N = 5e2 + 5;
constexpr ll Inf = 1e17;
constexpr int mod[2] = {1000000007, 998244353};

int n, m;

vector<pair<int, int>> adj[N];
struct Edge
{
    int u, v, w;
} e[N * N];

int ans[N * N];
int mark, check[N], l;

vector<int> candidate;
int in[N], out[N];

ll d[N][N];
int cnt[N][N][2];

void Read()
{
    cin >> n >> m;

    for (int i = 1; i <= m; ++i)
    {
        cin >> e[i].u >> e[i].v >> e[i].w;
        adj[e[i].u].emplace_back(e[i].v, i);
        adj[e[i].v].emplace_back(e[i].u, i);
    }
}

inline void Add(int &x, const int &y, const int &mod)
{
    x += y;
    if (x >= mod)
        x -= mod;
}

void Dijkstra(int x, ll d[N])
{
    ++mark;
    fill_n(d, N, Inf);
    d[x] = 0;
    cnt[x][x][0] = cnt[x][x][1] = 1;

    for (int i = 1; i <= n; ++i)
    {
        pair<ll, int> ans = {Inf, 0};

        for (int j = 1; j <= n; ++j)
            if (check[j] != mark && d[j] < ans.first)
                ans = {d[j], j};

        if (ans.first == Inf)
            break;

        check[ans.second] = mark;

        for (auto i : adj[ans.second])
            if (d[i.first] > ans.first + e[i.second].w)
            {
                d[i.first] = ans.first + e[i.second].w;
                cnt[x][i.first][0] = cnt[x][ans.second][0];
                cnt[x][i.first][1] = cnt[x][ans.second][1];
            }
            else if (d[i.first] == ans.first + e[i.second].w)
            {
                Add(cnt[x][i.first][0], cnt[x][ans.second][0], mod[0]);
                Add(cnt[x][i.first][1], cnt[x][ans.second][1], mod[1]);
            }
    }
}

void dfs(int v, ll d[N])
{
    in[v] = ++l;

    for (auto i : adj[v])
        if (d[i.first] == d[v] + e[i.second].w && !in[i.first])
        {
            candidate.emplace_back(i.second);
            dfs(i.first, d);
        }

    out[v] = l;
}

void Solve()
{
    for (int i = 1; i <= n; ++i)
        Dijkstra(i, d[i]);

    for (int i = 1; i <= n; ++i)
    {
        candidate.clear();

        for (int j = 1; j <= n; ++j)
            in[j] = out[j] = 0;

        l = 0;
        dfs(i, d[i]);

        for (auto j : candidate)
        {
            int v = in[e[j].u] > in[e[j].v] ? e[j].u : e[j].v;
            int u = e[j].u + e[j].v - v;

            for (int t = 1; t <= n; ++t)
                if (in[v] <= in[t] && in[t] <= out[v] && 1ll * cnt[i][u][0] * cnt[v][t][0] % mod[0] == cnt[i][t][0] && 1ll * cnt[i][u][1] * cnt[v][t][1] % mod[1] == cnt[i][t][1])
                    ++ans[j];
        }
    }

    for (int i = 1; i <= m; ++i)
        cout << ans[i] / 2 << "\n";
}

int32_t main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    if (fopen(task ".INP", "r"))
    {
        freopen(task ".INP", "r", stdin);
        freopen(task ".OUT", "w", stdout);
    }

    Read();
    Solve();
}