#include <iostream>
#include <vector>
#include <set>
#include <climits>

using namespace std;

struct edge_t {
  int a, b, w;
  edge_t(int _a, int _b, int _w) : a(_a), b(_b), w(_w) {};
  bool operator<(const edge_t &o) const {
    return this->w < o.w;
  }
};

class union_find {
private:
  vector<int> p, rank;
public:
  union_find(int size) : p(size, -1), rank(size) { }
  void union_set(int x, int y) { link(group(x), group(y)); }
  bool find_set(int x, int y) { return group(x) == group(y); }
  void make_set(int x) { p[x] = x; rank[x] = 0; }
private:
  int group(int x) {
    if (p[x] != x) p[x] = group(p[x]);
    return p[x];
  }
  void link(int x, int y) {
    if (rank[x] > rank[y]) p[x] = y; else p[y] = x;
    if (rank[x] == rank[y]) rank[y] = rank[x] + 1;
  }
};

int Kruskal(const vector<edge_t> &edges, vector<edge_t>::iterator p, int n)
{
  int connected = 0;
  union_find uf(n);
  for (int i = 0; i < n; ++i) { uf.make_set(i); }

  int maximum_weight = -1;
  for (vector<edge_t>::iterator q = p; q != edges.end(); ++q) {
    if (uf.find_set(q->a-1, q->b-1)) { continue; }
    maximum_weight = q->w;
    uf.union_set(q->a-1, q->b-1);
    ++connected;
  }
  if (connected == n-1) {
    return maximum_weight - (p->w);
  } else {
    return INT_MAX;
  }
}

int main()
{
  int n, m;
  while (cin >> n >> m) {
    if (n == 0 && m == 0) { break; }
    vector<edge_t> edges;
    set<int> weights;
    for (int i = 0; i < m; ++i) {
      int a, b, w; cin >> a >> b >> w; edges.push_back(edge_t(a, b, w));
      weights.insert(w);
    }
    sort(edges.begin(), edges.end());

    int minimum_slimness = INT_MAX;
    vector<edge_t>::iterator lower_limit_edge = edges.begin();
    for (set<int>::iterator p = weights.begin(); p != weights.end(); ++p) {
      while (lower_limit_edge != edges.end() && lower_limit_edge->w < *p) { ++lower_limit_edge; }
      if (lower_limit_edge == edges.end()) { break; }

      int slimness = Kruskal(edges, lower_limit_edge, n);
      if (minimum_slimness > slimness) { minimum_slimness = slimness; }
    }
    if (minimum_slimness == INT_MAX) { cout << -1 << endl; }
    else { cout << minimum_slimness << endl; }
  }
  return 0;
}