#include <bits/stdc++.h>
using namespace std;

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

template<class T>
struct RMQ {
	vector<vector<T>> jmp;
	RMQ(const vector<T>& V) : jmp(1, V) {
		for (int pw = 1, k = 1; pw * 2 <= sz(V); pw *= 2, ++k) {
			jmp.emplace_back(sz(V) - pw * 2 + 1);
			rep(j,0,sz(jmp[k]))
				jmp[k][j] = min(jmp[k - 1][j], jmp[k - 1][j + pw]);
		}
	}
	T query(int a, int b) {
		assert(a < b); // or return inf if a == b
		int dep = 31 - __builtin_clz(b - a);
		return min(jmp[dep][a], jmp[dep][b - (1 << dep)]);
	}
};

int main() {
	cin.tie(0)->sync_with_stdio(0);
	cin.exceptions(cin.failbit);

  struct edge {
    int u, v, w, is_span;
    int to(int x) {
      return u^v^x;
    }
  };

  int n, m;
  cin >> n >> m;
  vector<edge> edges;
  edges.reserve(m);
  vector<vi> g(n);
  rep(i, 0, m) {
    int u, v, w;
    cin >> u >> v >> w;
    u--,v--;
    g[u].push_back(sz(edges));
    g[v].push_back(sz(edges));
    edges.push_back({u,v,w,0});
  }


  int comp_num = 0, T = 0;
  vi vis(n), comp(n), dep(n), time(n), path, ret;
  vector<ll> dist(n);
  auto dfs = [&](auto& self, int s)->void {
    time[s] = T++;
    vis[s] = 1;
    comp[s] = comp_num;
    for (auto& e : g[s]) {
      int u = edges[e].to(s);
      if (vis[u]) continue;
      path.push_back(s);
      ret.push_back(time[s]);
      edges[e].is_span = 1;
      dist[u] = dist[s] + edges[e].w;
      dep[u] = dep[s]+1;
      self(self, u);
    }
  };
  rep(i, 0, n)  {
    if (!vis[i]) {
      dfs(dfs, i);
      comp_num++;
    }
  }

  RMQ rmq(ret);
  auto lca = [&](int x, int y)->int {
    assert(comp[x] == comp[y]);
    if (x == y) return x;
    tie(x, y) = minmax(time[x], time[y]);
    return path[rmq.query(x, y)];
  };

  vi not_span;
  rep(i, 0, m) if (!edges[i].is_span) not_span.push_back(i);

  ll ans = 0;
  rep(_i, 0, sz(not_span)) {
    int i = not_span[_i];
    auto& [u,v, w, _] = edges[i];

    if (dep[u] > dep[v]) swap(u, v); // u above v
    
    // Simple cycle
    ans = __gcd(ans, dist[v] - dist[u] + w);

    // xored
    rep(_j, _i+1, sz(not_span)) {
      int j = not_span[_j];
      auto& [a, b, w1, _] = edges[j];
      if (comp[a] != comp[u]) continue; // not in the same component, ignore
      if (dep[a] > dep[b]) swap(a, b); // a above b
      if (dep[b] <= dep[u]) continue; // no intersection, b above u
      int upper = dep[a] < dep[u] ? a : u;
      int lower = dep[a] > dep[u] ? a : u;
      if (lca(upper, lower) != upper) continue; // no shared edges
      int l = lca(v, b);
      if (dep[l] <= dep[lower]) continue;
      ans = __gcd(ans, 2*(dist[l] - dist[lower]));
    }
  }
  cout << ans << '\n';
}