#include<bits/stdc++.h>

#define ll long long

using namespace std;

vector<int>e[];

int n,m,t[],q[],siz[],ans,efree,a[],cnt,l[],r[],u[],v[],f[];

template<class T>

inline void read(T&a){

    char c=getchar();

    for(a=;(c<''||c>'')&&c!='-';c=getchar());

    bool f=;if(c=='-')f=,c=getchar();

    for(;c>=''&&c<='';c=getchar())a=a*+c-'';

    if(f)a=-a;

}

inline int gf(int x){return x==f[x]?f[x]:gf(f[x]);}

void ins(int k,int nl,int nr,int l,int r,int x){

    if(nl==l&&nr==r)return (void)e[k].push_back(x);

    int mid=(nl+nr)>>;

    if(r<=mid)ins(k<<,nl,mid,l,r,x);

    else if(l>mid)ins(k<<|,mid+,nr,l,r,x);

    else ins(k<<,nl,mid,l,mid,x),ins(k<<|,mid+,nr,mid+,r,x);

}

void dfs(int k,int l,int r){

    vector<int>lastf;

    int m=e[k].size(),mid=(l+r)>>;

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

        int x=u[e[k][i]],y=v[e[k][i]];

        x=gf(x),y=gf(y);

        if(siz[x]>siz[y])swap(x,y);

        lastf.push_back(x);f[x]=y;siz[y]+=siz[x];

    }

    if(gf()==gf(n))ans+=a[r+]-a[l];

    else if(l<r)dfs(k<<,l,mid),dfs(k<<|,mid+,r);

    m=lastf.size();

    for(register int i=m-;i>=;i--)f[lastf[i]]=lastf[i];

    lastf.clear();

}

int main(){

    read(n),read(m);

    for(int i=;i<=n;i++)f[i]=i,siz[i]=;

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

        read(u[i]),read(v[i]),read(l[i]),read(r[i]);

        a[++cnt]=l[i];a[++cnt]=r[i]+;

    }

    sort(a+,a++cnt);cnt=unique(a+,a++cnt)-a-;

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

        ins(,,cnt-,lower_bound(a+,a++cnt,l[i])-a,lower_bound(a+,a++cnt,r[i]+)-a-,i);

    dfs(,,cnt-);printf("%d\n",ans);

    return ;

}

#include<bits/stdc++.h>

using namespace std;

const int maxn=;

const int inf=;

struct edge{

    int x,y,a,b;

}e[maxn];

bool cmp (edge w,edge v){

    return w.b>v.b;

}

void read(int &x){

    char c=getchar(); x=;

    for(;c>''||c<'';c=getchar());

    for(;c<=''&&c>='';c=getchar()) x=(x<<)+(x<<)+c-'';

}

struct LCT

{

    int Max[maxn],rev[maxn],ch[maxn][],fa[maxn],stc[maxn],top;

    int isroot(int x){

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

    }

    int get(int x){

        return ch[fa[x]][]==x;

    }

    void pushdown(int x)

    {

        if(!rev[x]||!x) return ;

        swap(ch[x][],ch[x][]);

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

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

        rev[x]=;

    }

    void pushup(int x)

    {

        Max[x]=x;

        if(ch[x][]&&e[Max[ch[x][]]].a>e[Max[x]].a) Max[x]=Max[ch[x][]];

        if(ch[x][]&&e[Max[ch[x][]]].a>e[Max[x]].a) Max[x]=Max[ch[x][]];

    }

    void rotate(int x)

    {

        int old=fa[x],fold=fa[old],opt=get(x);

        if(!isroot(old)) ch[fold][get(old)]=x;

        fa[x]=fold;

        ch[old][opt]=ch[x][opt^]; fa[ch[old][opt]]=old;

        ch[x][opt^]=old; fa[old]=x;

        pushup(old); pushup(x);

    }

    void splay(int x)

    {

        int top=; stc[++top]=x;

        for(int i=x;!isroot(i);i=fa[i]) stc[++top]=fa[i];

        for(int i=top;i;i--) pushdown(stc[i]);

        for(int f;!isroot(x);rotate(x)){

            if(!isroot(f=fa[x]))

              rotate(get(x)==get(f)?f:x);

        }

    }

    void access(int x)

    {

        int rson=;

        for(;x;rson=x,x=fa[x]){

            splay(x);

            ch[x][]=rson;

            pushup(x);

        }

    }

    int find(int x){ access(x); splay(x); while(ch[x][]) x=ch[x][]; return x;}

    int query(int x,int y) { make_root(y); access(x);  splay(x); return Max[x]; }

    void make_root(int x) { access(x); splay(x); rev[x]^=; }

    void link(int x,int y) { make_root(x); fa[x]=y; splay(x); }

    void cut(int x,int y) { make_root(x); access(y); splay(y); fa[x]=ch[y][]=; }

}S;

pair<int,int>fcy[maxn]; int tot;

int main()

{

    int N,M,i,ans=;

    read(N); read(M);

    for(i=;i<=M;i++){

        read(e[i].x); read(e[i].y);

        read(e[i].a); read(e[i].b);

    }

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

    for(i=;i<=M;i++){

        if(S.find(M+e[i].x)!=S.find(M+e[i].y)) {

             S.link(i,M+e[i].x);

             S.link(i,M+e[i].y);

        }

        else{

            int tmp=S.query(M+e[i].x,M+e[i].y);

            if(e[tmp].a>e[i].a) {

                S.cut(tmp,M+e[tmp].x); S.cut(tmp,M+e[tmp].y);

                S.link(i,M+e[i].x); S.link(i,M+e[i].y);

            }

        }

        if(S.find(M+)==S.find(M+N)){

            int tmp=S.query(M+,M+N);

            if(e[tmp].a<=e[i].b){

                 tot++;

                 fcy[tot].first=e[tmp].a; fcy[tot].second=e[i].b;

            }

        }

    }

    sort(fcy+,fcy+tot+);

    for(i=;i<=tot;i++){

        int j=i,Mx=fcy[i].second;

        while(j+<=tot&&fcy[j+].first<=Mx) {

            j++; Mx=max(Mx,fcy[j].second);

        }

        ans+=Mx-fcy[i].first+;

        i=j;

    }

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

    return ;

}