#include <iostream>

 #include <cstdio>

 #include <algorithm>

 #define N 50050

 #define M 100100

 #define inf 0x7fffffff

 using namespace std;

 int n,m,ans;

 struct E{int x,y,a,b;}e[M];

 struct node

 {

     node *fa,*ch[];

     void init();

     int pos,rpos;

     bool rev;

     bool chr() {return this==fa->ch[];}

     bool isrt() {return this!=fa->ch[] && this!=fa->ch[];}

     void setc(node *x,int t) {this->ch[t]=x; x->fa=this;}

     void push_up();

     void push_down();

 /*    void push_down()

     {

         if (this==null) return;

         if (!x->isrt()) x->fa->push_down();

         if (rev)

         {

             ch[1]->rev^=1;

             ch[0]->rev^=1;

             swap(ch[1],ch[0]);

             rev=0;

         }

     }

     void push_up()

     {

         if (this==null) return;

         pos=rpos;

         if (ch[0]!=null && e[pos].b<e[ch[0]->pos].b)    pos=ch[0]->pos;

         if (ch[1]!=null && e[pos].b<e[ch[1]->pos].b)    pos=ch[1]->pos;

     }*/

 }pool[N+M],*pt=pool,*point[N],*et[M],*null;

 void node::init() {ch[]=ch[]=fa=null; pos=; rev=; rpos=;}

 void node::push_up()

 {

     if (this==null) return;

     pos=rpos;

     if (ch[]!=null && e[pos].b<e[ch[]->pos].b)    pos=ch[]->pos;

     if (ch[]!=null && e[pos].b<e[ch[]->pos].b)    pos=ch[]->pos;

 }

 void node::push_down()

 {

     if (this==null) return;

         if (!this->isrt()) this->fa->push_down();

         if (rev)

         {

             if (ch[]!=null) ch[]->rev^=;

             if (ch[]!=null) ch[]->rev^=;

             swap(ch[],ch[]);

             rev=;

         }

 }

 namespace LCT

 {

     node *NewNode()

     {

         pt++;

         pt->init();

         return pt;

     }

     void rotate(node *x)

     {

         node *r=x->fa;

         if (x==null || r==null) return;

         int t=x->chr();

         if (r->isrt()) x->fa=r->fa;

         else r->fa->setc(x,r->chr());

         r->setc(x->ch[t^],t);

         x->setc(r,!t);

         x->push_up(); r->push_up();

     }

     void Splay(node *x)

     {

         x->push_down();

         for (;!x->isrt();rotate(x))

             if (!x->fa->isrt())

                 if (x->chr()==x->fa->chr()) rotate(x->fa);

                 else rotate(x);

         x->push_up();

     }

     void Access(node *x)

     {

         node *r=null;

         for (;x!=null;r=x,x=x->fa)

         {

             Splay(x);

             x->ch[]=r;

         }

     }

     void MoveRoot(node *x)

     {

         Access(x);

         Splay(x);

         x->rev^=;

     }

     void Link(node *x,node *y)

     {

         MoveRoot(x);

         x->fa=y;

     }

     void Cut(node *x,node *y)

     {

         MoveRoot(x);

         Access(y); Splay(y);

         y->ch[]->fa=null; y->ch[]=null;

     }

     node *Find(node *x)

     {

         Access(x);

         Splay(x);

         while (x->ch[]!=null) x=x->ch[];

         return x;

     }

     int Query(node *x,node *y)

     {

         MoveRoot(x);

         Access(y);Splay(y);

         return y->pos;

     }

 }

 inline int read()

 {

     char c;

     int ans=,f=;

     while (!isdigit(c=getchar())) if (c=='-') f=-;

     ans=c-'';

     while (isdigit(c=getchar())) ans=ans*+c-'';

     return ans*f;

 }

 inline bool cmp (E a,E b) {return a.a<b.a;}

 using namespace LCT;

 int main()

 {

     n=read();m=read();

     null=pt++;

     null->init();

     for (int i=;i<=m;i++) {e[i].x=read(); e[i].y=read(); e[i].a=read(); e[i].b=read();}

     for (int i=;i<=n;i++)     point[i]=NewNode();

     sort(e+,e+m+,cmp);

     ans=inf;e[].b=-inf;

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

     {

         int x=e[i].x,y=e[i].y,b=e[i].b;

         et[i]=NewNode(); et[i]->pos=et[i]->rpos=i;

         if (Find(point[x])==Find(point[y]))

         {

             int pos=Query(point[x],point[y]);

             if (e[pos].b>b)

             {

                 Cut(et[pos],point[e[pos].x]);

                 Cut(et[pos],point[e[pos].y]);

                 Link(et[i],point[x]);

                 Link(et[i],point[y]);

             }

         }

         else

         {

             Link(et[i],point[x]);

             Link(et[i],point[y]);

         }

         if (Find(point[])==Find(point[n])) ans=min(ans,e[i].a+e[Query(point[],point[n])].b);

     }

     if (ans!=inf) printf("%d\n",ans);

     else printf("-1\n");

     return ;

 }