var t:array[..,..]of longint;

     rev,fa,mx,w,a,b,f,q,x,y:array[..]of longint;

     n,m,i,j,u,v,ans,tmp,top:longint;

 procedure swap(var x,y:longint);

 var t:longint;

 begin

  t:=x; x:=y; y:=t;

 end;

 function min(x,y:longint):longint;

 begin

  if x<y then exit(x);

  exit(y);

 end;

 function isroot(x:longint):boolean;

 begin

  if (t[fa[x],]<>x)and(t[fa[x],]<>x) then exit(true);

  exit(false);

 end;

 procedure pushup(p:longint);

 var l,r:longint;

 begin

  l:=t[p,]; r:=t[p,];

  mx[p]:=p;

  if w[mx[l]]>w[mx[p]] then mx[p]:=mx[l];

  if w[mx[r]]>w[mx[p]] then mx[p]:=mx[r];

 end;

 procedure pushdown(p:longint);

 var l,r:longint;

 begin

  l:=t[p,]; r:=t[p,];

  if rev[p]= then

  begin

   rev[p]:=; rev[l]:=rev[l] xor ; rev[r]:=rev[r] xor ;

   swap(t[p,],t[p,]);

  end;

 end;

 procedure rotate(x:longint);

 var y,z,l,r:longint;

 begin

  y:=fa[x]; z:=fa[y];

  if t[y,]=x then l:=

   else l:=;

  r:=l xor ;

  if not isroot(y) then

  begin

   if t[z,]=y then t[z,]:=x

    else t[z,]:=x;

  end;

  fa[x]:=z; fa[y]:=x; fa[t[x,r]]:=y;

  t[y,l]:=t[x,r]; t[x,r]:=y;

  pushup(y);

  pushup(x);

 end;

 procedure splay(x:longint);

 var y,z,k:longint;

 begin

  inc(top); q[top]:=x;

  k:=x;

  while not isroot(k) do

  begin

   inc(top); q[top]:=fa[k];

   k:=fa[k];

  end;

  while top> do

  begin

   pushdown(q[top]);

   dec(top);

  end;

  while not isroot(x) do

  begin

   y:=fa[x]; z:=fa[y];

   if not isroot(y) then

   begin

    if (t[y,]=x)xor(t[z,]=y) then rotate(x)

     else rotate(y);

   end;

   rotate(x);

  end;

 end;

 procedure access(x:longint);

 var k:longint;

 begin

  k:=;

  while x> do

  begin

   splay(x); t[x,]:=k; pushup(x);

   k:=x; x:=fa[x];

  end;

 end;

 procedure makeroot(x:longint);

 begin

  access(x); splay(x); rev[x]:=rev[x] xor ;

 end;

 procedure link(x,y:longint);

 begin

  makeroot(x); fa[x]:=y;

 end;

 procedure split(x,y:longint);

 begin

  makeroot(x); access(y); splay(y);

 end;

 procedure cut(x,y:longint);

 begin

  makeroot(x); access(y); splay(y); t[y,]:=; fa[x]:=;

  pushup(y);

 end;

 function query(x,y:longint):longint;

 begin

  split(x,y);

  exit(mx[y]);

 end;

 procedure qsort(l,r:longint);

 var i,j,mid:longint;

 begin

  i:=l; j:=r; mid:=a[(l+r)>>];

  repeat

   while mid>a[i] do inc(i);

   while mid<a[j] do dec(j);

   if i<=j then

   begin

    swap(a[i],a[j]);

    swap(b[i],b[j]);

    swap(x[i],x[j]);

    swap(y[i],y[j]);

    inc(i); dec(j);

   end;

  until i>j;

  if l<j then qsort(l,j);

  if i<r then qsort(i,r);

 end;

 function find(k:longint):longint;

 begin

  if f[k]<>k then f[k]:=find(f[k]);

  exit(f[k]);

 end;

 begin

  assign(input,'bzoj3669.in'); reset(input);

  assign(output,'bzoj3669.out'); rewrite(output);

  readln(n,m);

  for i:= to n do f[i]:=i;

  for i:= to m do read(x[i],y[i],a[i],b[i]);

  qsort(,m);

  ans:=maxlongint;

  for i:= to m do

  begin

   u:=x[i]; v:=y[i];

   if find(u)=find(v) then

   begin

    tmp:=query(u,v);

    if w[tmp]>b[i] then

    begin

     cut(tmp,x[tmp-n]);

     cut(tmp,y[tmp-n]);

    end

     else

     begin

      if find()=find(n) then

      begin

       tmp:=query(,n);

       ans:=min(ans,w[tmp]+a[i]);

      end;

      continue;

     end;

   end

    else f[find(u)]:=find(v);

   w[i+n]:=b[i]; mx[i+n]:=i+n;

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

   if find()=find(n) then

   begin

    tmp:=query(,n);

    ans:=min(ans,w[tmp]+a[i]);

   end;

  end;

  if ans=maxlongint then writeln(-)

   else writeln(ans);

  close(input);

  close(output);

 end.