#include <iostream>
#include <vector>
#include <tuple>
#include <algorithm>
#include <numeric>
#include <unordered_map>
#include <set>
#include <fstream>

using namespace std;

const long long MAX_VAL = 2000000000LL;

ifstream fin("oz.in");
ofstream fout("oz.out");

struct Edge {
    int u, v;
    long long gcd;
};

bool dfs(int node, vector<long long>& values, const vector<vector<Edge>>& adj, vector<bool>& visited) {
    visited[node] = true;
    for (const auto& edge : adj[node]) {
        int neighbor = edge.v;
        if (!visited[neighbor]) {
            if (values[node] % edge.gcd != 0) {
                return false;
            }
            values[neighbor] = edge.gcd;
            if (!dfs(neighbor, values, adj, visited)) {
                return false;
            }
        } else {
            if (__gcd(values[node], values[neighbor]) != edge.gcd) {
                return false;
            }
        }
    }
    return true;
}

int main() {
    int N, M;
    fin>> N >> M;

    vector<vector<Edge>> adj(N + 1);
    for (int i = 0; i < M; ++i) {
        int u, v;
        long long gcd;
        fin >> u >> v >> gcd;
        adj[u].push_back({u, v, gcd});
        adj[v].push_back({v, u, gcd});
    }
    vector<long long> values(N + 1, 1);
    vector<bool> visited(N + 1, false);

    for (int i = 1; i <= N; ++i) {
        if (!visited[i]) {
            values[i] = MAX_VAL;
            if (!dfs(i, values, adj, visited)) {
                fout << "-1";
                return 0;
            }
        }
    }
    for (int i = 1; i <= N; ++i) {
        fout << values[i] << " ";
    }
    return 0;
}