#include <iostream>

#include <cstdio>

#include <cstring>

#include <cmath>

#include <algorithm>

#define maxn 150005

#define maxm 100005

#define pi pair<int,int>

#define mp(a,b) make_pair(a,b)

using namespace std;

struct note{

    int u,v,a,b;

}wi[maxm];

int n,m,ans,fa[maxn],son[maxn][],val[maxn],sm[maxn],sm_id[maxn];

bool rev[maxn];

bool comp(note x,note y){

    if (x.a==y.a) return x.b<y.b;

    return x.a<y.a;

}

struct date{

    int which(int x){

        return son[fa[x]][]==x;

    }

    int isroot(int x){

        return son[fa[x]][]!=x&&son[fa[x]][]!=x;

    }

    void update(int x){

        sm_id[x]=x,sm[x]=val[x];

        if (son[x][]&&sm[son[x][]]>sm[x]) sm[x]=sm[son[x][]],sm_id[x]=sm_id[son[x][]];

        if (son[x][]&&sm[son[x][]]>sm[x]) sm[x]=sm[son[x][]],sm_id[x]=sm_id[son[x][]];

    }

    void pushdown(int x){

        if (rev[x]){

            rev[x]^=,swap(son[x][],son[x][]);

            if (son[x][]) rev[son[x][]]^=;

            if (son[x][]) rev[son[x][]]^=;

        }

    }

    void relax(int x){

        if (!isroot(x)) relax(fa[x]);

        pushdown(x);

    }

    void rotata(int x){

        int y=fa[x],d=which(x),dd=which(y);

        if (!isroot(y)) son[fa[y]][dd]=x; fa[x]=fa[y];

        fa[son[x][d^]]=y,son[y][d]=son[x][d^];

        fa[y]=x,son[x][d^]=y;

        update(y);

    }

    void splay(int x){

        relax(x);

        while (!isroot(x)){

            if (isroot(fa[x])) rotata(x);

            else if (which(x)==which(fa[x])) rotata(fa[x]),rotata(x);

            else rotata(x),rotata(x);

        }

        update(x);

    }

    void access(int x){

        for (int p=;x;x=fa[x]){

            splay(x);

            son[x][]=p;

            update(x);

            p=x;

        }

    }

    void make_root(int x){

        access(x);

        splay(x);

        rev[x]^=;

    }

    void link(int x,int y){

        make_root(x);

        fa[x]=y;

    }

    void cut(int x,int y){

        make_root(x);

        access(y);

        splay(y);

        son[y][]=fa[x]=;

        update(y);

    }

    void split(int x,int y){

        make_root(x);

        access(y);

        splay(y);

    }

    int query(int x,int y){

        split(x,y);

        return sm[y];

    }

    pi find(int x,int y){

        split(x,y);

        return mp(sm_id[y],sm[y]);

    }

    int find_root(int x){

        access(x);

        splay(x);

        while (son[x][]) x=son[x][];

        return x;

    }

}lct;

int main(){

//    freopen("forest.in","r",stdin);

//    freopen("forest.out","w",stdout);

    memset(rev,,sizeof(rev));

    memset(fa,,sizeof(fa));

    memset(son,,sizeof(son));

    memset(val,,sizeof(val));

    memset(sm,,sizeof(sm));

    scanf("%d%d",&n,&m);

    for (int i=;i<=m;i++) scanf("%d%d%d%d",&wi[i].u,&wi[i].v,&wi[i].a,&wi[i].b);

    sort(wi+,wi+m+,comp);

    for (int i=;i<=n;i++) val[i]=,lct.update(i);

    ans=maxn;

    pi temp;

    for (int i=;i<=m;i++){

        int u=wi[i].u,v=wi[i].v;

        if (lct.find_root(u)!=lct.find_root(v)){

            val[n+i]=wi[i].b,lct.update(n+i);

            lct.link(n+i,u),lct.link(n+i,v);

        }else{

            temp=lct.find(u,v);

            if (temp.second<=wi[i].b) continue;

            else{

                int t=temp.first;

                lct.cut(wi[t-n].u,t),lct.cut(wi[t-n].v,t);

                val[n+i]=wi[i].b,lct.update(n+i);

                lct.link(n+i,u),lct.link(n+i,v);

            }

        }

        if (lct.find_root()!=lct.find_root(n)) continue;

        int t=lct.query(,n);

        ans=min(ans,t+wi[i].a);

    }

    if (ans>maxm) printf("-1\n");

    else printf("%d\n",ans);

    return ;

}