#include<bits/stdc++.h>
using namespace std;
using ll = long long;
struct pt{
    ll x,y;
    pt operator + (pt p) const{
        return {x+p.x, y+p.y};
    }
    pt operator - (pt p) const{
        return {x-p.x, y-p.y};
    }
    ll operator * (pt p)const{
        return x * p.y - y * p.x;
    }
};
ll sq(pt a,pt b){
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
void reorder_polygon(vector <pt> &p){
    ll pos = 0;
    for (ll i = 0;i < p.size();i ++){
        if (p[i].y < p[pos].y || (p[i].y == p[pos].y && p[i].x < p[pos].x)){
            pos = i;
        }
    }

    rotate(p.begin(),p.begin() + pos,p.end());
}
ll orientation(pt a, pt b, pt c){
    ll ori = (b-a)*(c-b);
    if (ori == 0)return 0;
    if (ori > 0)return 1;
    if (ori < 0)return -1;
}
vector <pt> sum(vector <pt> &P,vector <pt> &Q){
    //no mulipleple point counter clockwise
    reverse(P.begin(),P.end());
    reverse(Q.begin(),Q.end());
    reorder_polygon(P);
    reorder_polygon(Q);
    P.push_back(P[0]);
    P.push_back(P[1]);
    Q.push_back(Q[0]);
    Q.push_back(Q[1]);
    vector <pt> result;
    ll i,j;
    i = j = 0;
    while (i < P.size() - 2 || j < Q.size() - 2){
        result.push_back(P[i] + Q[j]);
        auto cross = (P[i+1] - P[i]) * (Q[j+1] - Q[j]);
        if (cross >= 0 && i < P.size() - 2){
            ++i;
        }
        if (cross <= 0 && j < Q.size() - 2){
            ++j;
        }
    }
    return result;
}
void convex_hull(vector <pt> &P){
    pt p0 = *min_element(P.begin(),P.end(),[=](pt a, pt b){return make_pair(a.y,a.x) < make_pair(b.y,b.x);});
    sort(P.begin(),P.end(),[&p0](const pt &a,const pt &b){
        auto o = orientation(p0,a,b);
        if (o == 0){
            return sq(p0,a) < sq(p0,b);
        }
        return (o == -1);
    });
    vector <pt> st;
    for (ll i = 0;i < P.size();i ++){
        while (st.size() > 1 && orientation(st[st.size() - 2],st[st.size() - 1],P[i]) == 1){
            st.pop_back();
        }
        st.push_back(P[i]);
    }
    P = st;
}
const ll MAXN = 5e4;
ll n,m;
vector <ll> g[MAXN + 100];
ll pa[MAXN + 100];
bool in[MAXN + 100];
struct edge{
    ll u,v,a,b;
};
ll depth[MAXN + 100];
edge all[MAXN * 5 + 100];
ll nxt(ll u, edge x){
    return (x.u == u?x.v:x.u);
}
vector <pt> minkowski;
void dfs(ll u){
    //cout<<u<<'\n';
    for (auto id:g[u]){
        auto v = nxt(u,all[id]);
        if (!in[v]){
            pa[v] = id;
            in[v] = 1;
            depth[v] = depth[u] + 1;
            //cout<<id<<' '<<u<<' '<<v<<'\n';
            dfs(v);
        }
        if (in[v]){
            if (depth[v] > depth[u] + 1){
                ll cur = v;
                vector <pt> tmp;
                tmp.push_back({all[id].a,all[id].b});
                while (cur != u){

                    tmp.push_back({all[pa[cur]].a,all[pa[cur]].b});
                    cur = nxt(cur,all[pa[cur]]);
                }
                //cout<<pa[1]<<' '<<pa[2]<<' '<<pa[3]<<'\n';
                //cout<<u<<' '<<v<<'\n';
                convex_hull(tmp);
                /*for (auto x:tmp){
                    cout<<x.x<<' '<<x.y<<'\n';
                }
                cout<<'\n';*/
                if (minkowski.empty())minkowski = tmp;
                else minkowski = sum(minkowski,tmp);
            }
        }
    }
}ll sum_a,sum_b;
int main(){
    ios_base::sync_with_stdio(0);cin.tie(nullptr);cout.tie(nullptr);
    cin>>n>>m;

    sum_a = sum_b = 0;
    for (ll i = 1;i <= m;i ++){
        cin>>all[i].u>>all[i].v>>all[i].a>>all[i].b;
        g[all[i].u].push_back(i);
        g[all[i].v].push_back(i);
        sum_a += all[i].a;
        sum_b += all[i].b;
    }
    in[1] = 1;
    dfs(1);
    //return 0;
    ll ans = sum_a * sum_b;
    /*for (ll i = 1;i <= m;i ++){
        cout<<(sum_a - all[i].a) * (sum_b - all[i].b)<<'\n';
    }
    for (auto x:minkowski){
        cout<<x.x<<' '<<x.y<<' ';
    }
    cout<<'\n';*/
    for (auto x:minkowski){
        //cout<<(sum_a - x.x) * (sum_b - x.y)<<' ';
        ans = min(ans,(sum_a - x.x) * (sum_b - x.y));
    }
    cout<<ans<<'\n';
    return 0;
}