/*
 *
 *
 */

#include <bits/stdc++.h>

using namespace std;

#define LOG(...) fprintf(stderr, __VA_ARGS__)
//#define LOG(...)
#define FOR(i, a, b) for(int i = (int)(a); i < (int)(b); ++i)
#define REP(i, n) for(int i = 0; i < (int)(n); ++i)
#define RREP(i, n) for(int i = (int)(n - 1); i >= 0; --i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define SQ(n) (n) * (n)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<pii> vpi;
typedef vector<pll> vpl;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vc> vvc;
typedef vector<vll> vvll;

const int INF = (int)1e9;

// ?´?????????????????§????
struct UnionFind
{
  // par[i]????????????i????±?????????¨??????????????????i == par[i]?????¨???????????????i?????¨?????????????????§??????
  vector<int> par;
  // sizes[i]???????????????i?????¨?????????????????????????????°???i?????????????????§????????´???????????????????????¨??????
  vector<int> sizes;

  UnionFind(int n) : par(n), sizes(n, 1) {
    // ???????????¨???????????????i?????°?????????i????????¨??????????????¨???????????????
    REP(i, n) par[i] = i;
  }

  // ?????????x????±?????????¨???????????????
  int find(int x) {
    if (x == par[x]) return x;
    return par[x] = find(par[x]);  // ????????????????????????????????°???????????????????????¢???
  }

  // 2???????????????x, y????±?????????¨??????????????????
  void unite(int x, int y) {
    // ?????????????????????????????????
    x = find(x);
    y = find(y);

    // ??¢???????????¨????±?????????????????????????????????????
    if (x == y) return;

    // x?????¨???y?????¨????????§???????????????????????????
    if (sizes[x] < sizes[y]) swap(x, y);

    // x???y??????????????????????????£?????????
    par[y] = x;
    sizes[x] += sizes[y];
    // sizes[y] = 0;  // sizes[y]????????????????????¨???????????§0?????\????????????????????????
  }

  // 2???????????????x, y????±?????????¨???????????????true?????????
  bool same(int x, int y) {
    return find(x) == find(y);
  }

  // ?????????x?????????????????¨?????§???????????????
  int size(int x) {
    return sizes[find(x)];
  }
};

// ??????a, b?????????????????????cost??????????????????
struct Edge
{
  int a, b;
  int cost;

  // ??????????????§?°???§????????????
  bool operator<(const Edge& o) const {
    return cost < o.cost;
  }
};

// ????????°??¨?????????????????¨????????????????????°??????
struct Graph
{
  int n;  // ????????°
  vector<Edge> es;  // ?????????

  // ????????????????????§??????????°???¨?????¨??????????????????????¨??????????
  // ??°??????????????£????????¨??????????°???¨????£?????????????????????¨??????
  int kruskal() {
    UnionFind uf(n);

    int cnt = 0;
    int fi = 0;

    REP(i, es.size()) {
      Edge& e = es[i];
      if (!uf.same(e.a, e.b)) {
        // ????????????????????????????????§???????????????????????????????????¨??????
        uf.unite(e.a, e.b);

        cnt++;
        fi = i;
      }
    }

    return (cnt != n - 1 ? INF : es[fi].cost - es[0].cost);
  }
};

int main() {
  int n, m;
  while(cin >> n >> m, n) {
    Graph g;
    g.n = n;
    REP(i, m){
      int a, b, v;
      cin >> a >> b >> v;
      g.es.push_back({a - 1, b - 1, v});
    }

    SORT(g.es);


    int res = INF;
    while(g.es.size() >= n - 1) {
      int v = g.kruskal();
      if (v == INF) break;
      res = min(res, v);
      g.es.erase(g.es.begin());
    }

    cout << (res == INF ? -1 : res) << endl;
  }

}

Measured memory_bytes: 3268