#include <bits/stdc++.h>
using namespace std;

void just_do_it();

int main() {
	#ifdef KAMIRULEZ
		freopen("kamirulez.inp", "r", stdin);
		freopen("kamirulez.out", "w", stdout);
	#endif
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	just_do_it();
	return 0;
}

const long long inf = 7e18L + 20;
const int maxN = 5e4 + 20;
const int maxM = 2.5e5 + 20;
vector<pair<int, int>> adj[maxN];
long long A[maxM];
long long B[maxM];
int depth[maxN];
pair<int, int> par[maxN];
bool flag1[maxN];
bool flag2[maxM];

struct point {
	long long x, y;

	point(): x(0), y(0) {};

	point(long long _x, long long _y): x(_x), y(_y) {};
};

point operator+(point p1, point p2) {
	return point(p1.x + p2.x, p1.y + p2.y);
}

point operator-(point p1, point p2) {
	return point(p1.x - p2.x, p1.y - p2.y);
}

long long operator^(point p1, point p2) {
	return p1.x * p2.y - p1.y * p2.x;
}

bool operator<(point p1, point p2) {
	if (p1.x != p2.x) {
		return p1.x < p2.x;
	}
	else {
		return p1.y < p2.y;
	}
}

vector<vector<point>> hulls;

bool cw(point p1, point p2, point p3) {
	return ((p1 - p2) ^ (p3 - p2)) > 0;
}

bool ccw(point p1, point p2, point p3) {
	return ((p1 - p2) ^ (p3 - p2)) < 0;
}

vector<point> build(vector<point> points) {
	sort(points.begin(), points.end());
	int n = points.size();
	if ((points[0].x == points[n - 1].x) && (points[0].y == points[n - 1].y)) {
		return {points[0]};
	}
	vector<point> low = {points[0]};
	vector<point> high = {points[0]};
	for (int i = 1; i < n; i++) {
		if (i == n - 1 || ccw(points[0], points[i], points[n - 1])) {
			while ((int)low.size() >= 2 && !ccw(low.end()[-2], low.back(), points[i])) {
				low.pop_back();
			}
			low.push_back(points[i]);
		}
		if (i == n - 1 || cw(points[0], points[i], points[n - 1])) {
			while ((int)high.size() >= 2 && !cw(high.end()[-2], high.back(), points[i])) {
				high.pop_back();
			}
			high.push_back(points[i]);
		}
	}
	vector<point> hull(low.begin(), low.end());
	hull.insert(hull.end(), high.rbegin() + 1, high.rend() - 1);
	return hull;
}

void dfs(int u) {
	flag1[u] = true;
	for (auto e: adj[u]) {
		int v = e.first;
		int id = e.second;
		if (id == par[u].second) {
			continue;
		}
		if (!flag1[v]) {
			depth[v] = depth[u] + 1;
			par[v] = {u, id};
			dfs(v);
		}
		else if (depth[v] < depth[u]) {
			vector<int> cycle = {id};
			int cur = u;
			while (cur != v) {
				cycle.push_back(par[cur].second);
				cur = par[cur].first;
			}
			long long sumA = 0;
			long long sumB = 0;
			for (auto id: cycle) {
				flag2[id] = true;
				sumA += A[id];
				sumB += B[id];
			}
			vector<point> points;
			for (auto id: cycle) {
				points.emplace_back(sumA - A[id], sumB - B[id]);
			}
			hulls.push_back(build(points));
		}
	}
}

point get(pair<int, int> p) {
	int sz = hulls[p.first].size();
	return hulls[p.first][p.second] - hulls[p.first][(p.second + sz - 1) % sz];
}

struct cmp {
	bool operator() (pair<int, int> p1, pair<int, int> p2) {
		return (get(p1) ^ get(p2)) < 0;
	}
};

void just_do_it() {
	int N, M;
	cin >> N >> M;
	for (int i = 1; i <= M; i++) {
		int u, v;
		cin >> u >> v >> A[i] >> B[i];
		adj[u].emplace_back(v, i);
		adj[v].emplace_back(u, i);
	}
	dfs(1);
	for (int i = 1; i <= M; i++) {
		if (!flag2[i]) {
			hulls.push_back(build({point(A[i], B[i])}));
		}
	}
	point cur(0, 0);
	priority_queue<pair<int, int>, vector<pair<int, int>>, cmp> q;
	for (int i = 0; i < (int)hulls.size(); i++) {
		cur.x += hulls[i][0].x;
		cur.y += hulls[i][0].y;
		if ((int)hulls[i].size() >= 2) {
			q.emplace(i, 1);
		}
	}
	long long res = cur.x * cur.y;
	while (!q.empty()) {
		int id = q.top().first;
		int pos = q.top().second;
		q.pop();
		cur = cur + get({id, pos});
		res = min(res, cur.x * cur.y);
		if (pos != 0) {
			q.emplace(id, (pos + 1) % hulls[id].size());
		}
	}
	cout << res;
}