/*
#pragma GCC optimize("O3")
#ifdef ONLINE_JUDGE
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#endif
#pragma GCC optimize("unroll-loops")
*/
#include "bits/stdc++.h"
using namespace std;
#define int long long
#define FOR(i, a, b) for (int i = (a), _##i = (b); i <= _##i; ++i)
#define FORD(i, a, b) for (int i = (a), _##i = (b); i >= _##i; --i)
#define REP(i, a) for (int i = 0, _##i = (a); i < _##i; ++i)
#define REPD(i,n) for(int i = (n)-1; i >= 0; --i)
#define DEBUG(X) { auto _X = (X); cerr << "L" << __LINE__ << ": " << #X << " = " << (_X) << endl; }
#define PR(A, n) { cerr << "L" << __LINE__ << ": " << #A << " = "; FOR(_, 1, n) cerr << A[_] << ' '; cerr << endl; }
#define PR0(A, n) { cerr << "L" << __LINE__ << ": " << #A << " = "; REP(_, n) cerr << A[_] << ' '; cerr << endl; }
#define sqr(x) ((x) * (x))
#define ll long long
// On CF, GNU C++ seems to have some precision issues with long double?
// #define double long double
typedef pair<int, int> II;
#define __builtin_popcount __builtin_popcountll
#define SZ(x) ((int)(x).size())
#define ALL(a) (a).begin(), (a).end()
#define MS(a,x) memset(a, x, sizeof(a))
#define stat akjcjalsjcjalscj
#define hash ajkscjlsjclajsc
#define next ackjalscjaowjico
#define prev ajcsoua0wucckjsl
#define y1 alkscj9u20cjeijc
#define left lajcljascjljl
#define right aucouasocjolkjl
#define y0 u9cqu3jioajc
#define TWO(X) (1LL<<(X))
#define CONTAIN(S,X) (((S) >> (X)) & 1)
long long rand16() {
return rand() & (TWO(16) - 1);
}
long long my_rand() {
return rand16() << 32 | rand16() << 16 | rand16();
}
double safe_sqrt(double x) { return sqrt(max((double)0.0, x)); }
int GI(long long& x) { return scanf("%lld", &x); }
const int BASE_DIGITS = 9;
const int BASE = 1000000000;
struct BigInt {
int sign;
vector<int> a;
// -------------------- Constructors --------------------
// Default constructor.
BigInt() : sign(1) {}
// Constructor from long long.
BigInt(long long v) {
*this = v;
}
BigInt& operator = (long long v) {
sign = 1;
if (v < 0) {
sign = -1;
v = -v;
}
a.clear();
for (; v > 0; v = v / BASE)
a.push_back(v % BASE);
return *this;
}
// Initialize from string.
BigInt(const string& s) {
read(s);
}
// -------------------- Input / Output --------------------
void read(const string& s) {
sign = 1;
a.clear();
int pos = 0;
while (pos < (int) s.size() && (s[pos] == '-' || s[pos] == '+')) {
if (s[pos] == '-')
sign = -sign;
++pos;
}
for (int i = s.size() - 1; i >= pos; i -= BASE_DIGITS) {
int x = 0;
for (int j = max(pos, i - BASE_DIGITS + 1); j <= i; j++)
x = x * 10 + s[j] - '0';
a.push_back(x);
}
trim();
}
friend istream& operator>>(istream &stream, BigInt &v) {
string s;
stream >> s;
v.read(s);
return stream;
}
friend ostream& operator<<(ostream &stream, const BigInt &v) {
if (v.sign == -1 && !v.isZero())
stream << '-';
stream << (v.a.empty() ? 0 : v.a.back());
for (int i = (int) v.a.size() - 2; i >= 0; --i)
stream << setw(BASE_DIGITS) << setfill('0') << v.a[i];
return stream;
}
// -------------------- Comparison --------------------
bool operator<(const BigInt &v) const {
if (sign != v.sign)
return sign < v.sign;
if (a.size() != v.a.size())
return a.size() * sign < v.a.size() * v.sign;
for (int i = ((int) a.size()) - 1; i >= 0; i--)
if (a[i] != v.a[i])
return a[i] * sign < v.a[i] * sign;
return false;
}
bool operator>(const BigInt &v) const {
return v < *this;
}
bool operator<=(const BigInt &v) const {
return !(v < *this);
}
bool operator>=(const BigInt &v) const {
return !(*this < v);
}
bool operator==(const BigInt &v) const {
return !(*this < v) && !(v < *this);
}
bool operator!=(const BigInt &v) const {
return *this < v || v < *this;
}
// Returns:
// 0 if |x| == |y|
// -1 if |x| < |y|
// 1 if |x| > |y|
friend int __compare_abs(const BigInt& x, const BigInt& y) {
if (x.a.size() != y.a.size()) {
return x.a.size() < y.a.size() ? -1 : 1;
}
for (int i = ((int) x.a.size()) - 1; i >= 0; --i) {
if (x.a[i] != y.a[i]) {
return x.a[i] < y.a[i] ? -1 : 1;
}
}
return 0;
}
// -------------------- Unary operator - and operators +- --------------------
BigInt operator-() const {
BigInt res = *this;
if (isZero()) return res;
res.sign = -sign;
return res;
}
// Note: sign ignored.
void __internal_add(const BigInt& v) {
if (a.size() < v.a.size()) {
a.resize(v.a.size(), 0);
}
for (int i = 0, carry = 0; i < (int) max(a.size(), v.a.size()) || carry; ++i) {
if (i == (int) a.size()) a.push_back(0);
a[i] += carry + (i < (int) v.a.size() ? v.a[i] : 0);
carry = a[i] >= BASE;
if (carry) a[i] -= BASE;
}
}
// Note: sign ignored.
void __internal_sub(const BigInt& v) {
for (int i = 0, carry = 0; i < (int) v.a.size() || carry; ++i) {
a[i] -= carry + (i < (int) v.a.size() ? v.a[i] : 0);
carry = a[i] < 0;
if (carry) a[i] += BASE;
}
this->trim();
}
BigInt operator += (const BigInt& v) {
if (sign == v.sign) {
__internal_add(v);
} else {
if (__compare_abs(*this, v) >= 0) {
__internal_sub(v);
} else {
BigInt vv = v;
swap(*this, vv);
__internal_sub(vv);
}
}
return *this;
}
BigInt operator -= (const BigInt& v) {
if (sign == v.sign) {
if (__compare_abs(*this, v) >= 0) {
__internal_sub(v);
} else {
BigInt vv = v;
swap(*this, vv);
__internal_sub(vv);
this->sign = -this->sign;
}
} else {
__internal_add(v);
}
return *this;
}
// Optimize operators + and - according to
// https://stackoverflow.com/questions/13166079/move-semantics-and-pass-by-rvalue-reference-in-overloaded-arithmetic
template< typename L, typename R >
typename std::enable_if<
std::is_convertible<L, BigInt>::value &&
std::is_convertible<R, BigInt>::value &&
std::is_lvalue_reference<R&&>::value,
BigInt>::type friend operator + (L&& l, R&& r) {
BigInt result(std::forward<L>(l));
result += r;
return result;
}
template< typename L, typename R >
typename std::enable_if<
std::is_convertible<L, BigInt>::value &&
std::is_convertible<R, BigInt>::value &&
std::is_rvalue_reference<R&&>::value,
BigInt>::type friend operator + (L&& l, R&& r) {
BigInt result(std::move(r));
result += l;
return result;
}
template< typename L, typename R >
typename std::enable_if<
std::is_convertible<L, BigInt>::value &&
std::is_convertible<R, BigInt>::value,
BigInt>::type friend operator - (L&& l, R&& r) {
BigInt result(std::forward<L>(l));
result -= r;
return result;
}
// -------------------- Operators * / % --------------------
friend pair<BigInt, BigInt> divmod(const BigInt& a1, const BigInt& b1) {
assert(b1 > 0); // divmod not well-defined for b < 0.
long long norm = BASE / (b1.a.back() + 1);
BigInt a = a1.abs() * norm;
BigInt b = b1.abs() * norm;
BigInt q = 0, r = 0;
q.a.resize(a.a.size());
for (int i = a.a.size() - 1; i >= 0; i--) {
r *= BASE;
r += a.a[i];
long long s1 = r.a.size() <= b.a.size() ? 0 : r.a[b.a.size()];
long long s2 = r.a.size() <= b.a.size() - 1 ? 0 : r.a[b.a.size() - 1];
long long d = ((long long) BASE * s1 + s2) / b.a.back();
r -= b * d;
while (r < 0) {
r += b, --d;
}
q.a[i] = d;
}
q.sign = a1.sign * b1.sign;
r.sign = a1.sign;
q.trim();
r.trim();
auto res = make_pair(q, r / norm);
if (res.second < 0) res.second += b1;
return res;
}
BigInt operator/(const BigInt &v) const {
return divmod(*this, v).first;
}
BigInt operator%(const BigInt &v) const {
return divmod(*this, v).second;
}
void operator/=(int v) {
assert(v > 0); // operator / not well-defined for v <= 0.
if (llabs(v) >= BASE) {
*this /= BigInt(v);
return ;
}
if (v < 0)
sign = -sign, v = -v;
for (int i = (int) a.size() - 1, rem = 0; i >= 0; --i) {
long long cur = a[i] + rem * (long long) BASE;
a[i] = (int) (cur / v);
rem = (int) (cur % v);
}
trim();
}
BigInt operator/(int v) const {
assert(v > 0); // operator / not well-defined for v <= 0.
if (llabs(v) >= BASE) {
return *this / BigInt(v);
}
BigInt res = *this;
res /= v;
return res;
}
void operator/=(const BigInt &v) {
*this = *this / v;
}
long long operator%(long long v) const {
assert(v > 0); // operator / not well-defined for v <= 0.
assert(v < BASE);
int m = 0;
for (int i = a.size() - 1; i >= 0; --i)
m = (a[i] + m * (long long) BASE) % v;
return m * sign;
}
void operator*=(int v) {
if (llabs(v) >= BASE) {
*this *= BigInt(v);
return ;
}
if (v < 0)
sign = -sign, v = -v;
for (int i = 0, carry = 0; i < (int) a.size() || carry; ++i) {
if (i == (int) a.size())
a.push_back(0);
long long cur = a[i] * (long long) v + carry;
carry = (int) (cur / BASE);
a[i] = (int) (cur % BASE);
//asm("divl %%ecx" : "=a"(carry), "=d"(a[i]) : "A"(cur), "c"(base));
/*
int val;
__asm {
lea esi, cur
mov eax, [esi]
mov edx, [esi+4]
mov ecx, base
div ecx
mov carry, eax
mov val, edx;
}
a[i] = val;
*/
}
trim();
}
BigInt operator*(int v) const {
if (llabs(v) >= BASE) {
return *this * BigInt(v);
}
BigInt res = *this;
res *= v;
return res;
}
// Convert BASE 10^old --> 10^new.
static vector<int> convert_base(const vector<int> &a, int old_digits, int new_digits) {
vector<long long> p(max(old_digits, new_digits) + 1);
p[0] = 1;
for (int i = 1; i < (int) p.size(); i++)
p[i] = p[i - 1] * 10;
vector<int> res;
long long cur = 0;
int cur_digits = 0;
for (int i = 0; i < (int) a.size(); i++) {
cur += a[i] * p[cur_digits];
cur_digits += old_digits;
while (cur_digits >= new_digits) {
res.push_back((long long)(cur % p[new_digits]));
cur /= p[new_digits];
cur_digits -= new_digits;
}
}
res.push_back((int) cur);
while (!res.empty() && !res.back())
res.pop_back();
return res;
}
void fft(vector<complex<double> > & a, bool invert) const {
int n = (int) a.size();
for (int i = 1, j = 0; i < n; ++i) {
int bit = n >> 1;
for (; j >= bit; bit >>= 1)
j -= bit;
j += bit;
if (i < j)
swap(a[i], a[j]);
}
for (int len = 2; len <= n; len <<= 1) {
double ang = 2 * 3.14159265358979323846 / len * (invert ? -1 : 1);
complex<double> wlen(cos(ang), sin(ang));
for (int i = 0; i < n; i += len) {
complex<double> w(1);
for (int j = 0; j < len / 2; ++j) {
complex<double> u = a[i + j];
complex<double> v = a[i + j + len / 2] * w;
a[i + j] = u + v;
a[i + j + len / 2] = u - v;
w *= wlen;
}
}
}
if (invert)
for (int i = 0; i < n; ++i)
a[i] /= n;
}
void multiply_fft(const vector<int> &a, const vector<int> &b, vector<int> &res) const {
vector<complex<double> > fa(a.begin(), a.end());
vector<complex<double> > fb(b.begin(), b.end());
int n = 1;
while (n < (int) max(a.size(), b.size()))
n <<= 1;
n <<= 1;
fa.resize(n);
fb.resize(n);
fft(fa, false);
fft(fb, false);
for (int i = 0; i < n; ++i)
fa[i] *= fb[i];
fft(fa, true);
res.resize(n);
long long carry = 0;
for (int i = 0; i < n; ++i) {
long long t = (long long) (fa[i].real() + 0.5) + carry;
carry = t / 1000;
res[i] = t % 1000;
}
}
BigInt mul_simple(const BigInt &v) const {
BigInt res;
res.sign = sign * v.sign;
res.a.resize(a.size() + v.a.size());
for (int i = 0; i < (int) a.size(); ++i)
if (a[i])
for (int j = 0, carry = 0; j < (int) v.a.size() || carry; ++j) {
long long cur = res.a[i + j] + (long long) a[i] * (j < (int) v.a.size() ? v.a[j] : 0) + carry;
carry = (int) (cur / BASE);
res.a[i + j] = (int) (cur % BASE);
}
res.trim();
return res;
}
typedef vector<long long> vll;
static vll karatsubaMultiply(const vll &a, const vll &b) {
int n = a.size();
vll res(n + n);
if (n <= 32) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
res[i + j] += a[i] * b[j];
return res;
}
int k = n >> 1;
vll a1(a.begin(), a.begin() + k);
vll a2(a.begin() + k, a.end());
vll b1(b.begin(), b.begin() + k);
vll b2(b.begin() + k, b.end());
vll a1b1 = karatsubaMultiply(a1, b1);
vll a2b2 = karatsubaMultiply(a2, b2);
for (int i = 0; i < k; i++)
a2[i] += a1[i];
for (int i = 0; i < k; i++)
b2[i] += b1[i];
vll r = karatsubaMultiply(a2, b2);
for (int i = 0; i < (int) a1b1.size(); i++)
r[i] -= a1b1[i];
for (int i = 0; i < (int) a2b2.size(); i++)
r[i] -= a2b2[i];
for (int i = 0; i < (int) r.size(); i++)
res[i + k] += r[i];
for (int i = 0; i < (int) a1b1.size(); i++)
res[i] += a1b1[i];
for (int i = 0; i < (int) a2b2.size(); i++)
res[i + n] += a2b2[i];
return res;
}
BigInt mul_karatsuba(const BigInt &v) const {
vector<int> a6 = convert_base(this->a, BASE_DIGITS, 6);
vector<int> b6 = convert_base(v.a, BASE_DIGITS, 6);
vll a(a6.begin(), a6.end());
vll b(b6.begin(), b6.end());
while (a.size() < b.size())
a.push_back(0);
while (b.size() < a.size())
b.push_back(0);
while (a.size() & (a.size() - 1))
a.push_back(0), b.push_back(0);
vll c = karatsubaMultiply(a, b);
BigInt res;
res.sign = sign * v.sign;
long long carry = 0;
for (int i = 0; i < (int) c.size(); i++) {
long long cur = c[i] + carry;
res.a.push_back((int) (cur % 1000000));
carry = cur / 1000000;
}
res.a = convert_base(res.a, 6, BASE_DIGITS);
res.trim();
return res;
}
void operator*=(const BigInt &v) {
*this = *this * v;
}
BigInt operator*(const BigInt &v) const {
if (a.size() * v.a.size() <= 1000111) return mul_simple(v);
if (a.size() > 500111 || v.a.size() > 500111) return mul_fft(v);
return mul_karatsuba(v);
}
BigInt mul_fft(const BigInt& v) const {
BigInt res;
res.sign = sign * v.sign;
multiply_fft(convert_base(a, BASE_DIGITS, 3), convert_base(v.a, BASE_DIGITS, 3), res.a);
res.a = convert_base(res.a, 3, BASE_DIGITS);
res.trim();
return res;
}
// -------------------- Misc --------------------
BigInt abs() const {
BigInt res = *this;
res.sign *= res.sign;
return res;
}
void trim() {
while (!a.empty() && !a.back())
a.pop_back();
if (a.empty())
sign = 1;
}
bool isZero() const {
return a.empty() || (a.size() == 1 && !a[0]);
}
friend BigInt gcd(const BigInt &a, const BigInt &b) {
return b.isZero() ? a : gcd(b, a % b);
}
friend BigInt lcm(const BigInt &a, const BigInt &b) {
return a / gcd(a, b) * b;
}
friend BigInt sqrt(const BigInt &a1) {
BigInt a = a1;
while (a.a.empty() || a.a.size() % 2 == 1)
a.a.push_back(0);
int n = a.a.size();
int firstDigit = (int) sqrt((double) a.a[n - 1] * BASE + a.a[n - 2]);
int norm = BASE / (firstDigit + 1);
a *= norm;
a *= norm;
while (a.a.empty() || a.a.size() % 2 == 1)
a.a.push_back(0);
BigInt r = (long long) a.a[n - 1] * BASE + a.a[n - 2];
firstDigit = (int) sqrt((double) a.a[n - 1] * BASE + a.a[n - 2]);
int q = firstDigit;
BigInt res;
for(int j = n / 2 - 1; j >= 0; j--) {
for(; ; --q) {
BigInt r1 = (r - (res * 2 * BigInt(BASE) + q) * q) * BigInt(BASE) * BigInt(BASE) + (j > 0 ? (long long) a.a[2 * j - 1] * BASE + a.a[2 * j - 2] : 0);
if (r1 >= 0) {
r = r1;
break;
}
}
res *= BASE;
res += q;
if (j > 0) {
int d1 = res.a.size() + 2 < r.a.size() ? r.a[res.a.size() + 2] : 0;
int d2 = res.a.size() + 1 < r.a.size() ? r.a[res.a.size() + 1] : 0;
int d3 = res.a.size() < r.a.size() ? r.a[res.a.size()] : 0;
q = ((long long) d1 * BASE * BASE + (long long) d2 * BASE + d3) / (firstDigit * 2);
}
}
res.trim();
return res / norm;
}
};
template<typename flow_t = int, typename cost_t = int>
struct MinCostFlow {
struct Edge {
cost_t c;
flow_t f;
int to, rev;
Edge(int _to, cost_t _c, flow_t _f, int _rev) : c(_c), f(_f), to(_to), rev(_rev) {}
};
int N, S, T;
vector<vector<Edge> > G;
MinCostFlow(int _N, int _S, int _T) : N(_N), S(_S), T(_T), G(_N), eps(0) {}
void addEdge(int a, int b, flow_t cap, cost_t cost) {
assert(cap >= 0);
assert(a >= 0 && a < N && b >= 0 && b < N);
if (a == b) { assert(cost >= 0); return; }
cost *= N;
eps = max(eps, abs(cost));
G[a].emplace_back(b, cost, cap, G[b].size());
G[b].emplace_back(a, -cost, 0, G[a].size() - 1);
}
flow_t getFlow(Edge const &e) {
return G[e.to][e.rev].f;
}
pair<flow_t, BigInt> minCostMaxFlow() {
BigInt retCost = 0;
for (int i = 0; i<N; ++i) {
for (Edge &e : G[i]) {
retCost += BigInt(e.c)*BigInt(e.f);
}
}
//find max-flow
flow_t retFlow = max_flow();
h.assign(N, 0); ex.assign(N, 0);
isq.assign(N, 0); cur.assign(N, 0);
queue<int> q;
for (; eps; eps >>= scale) {
//refine
fill(cur.begin(), cur.end(), 0);
for (int i = 0; i < N; ++i) {
for (auto &e : G[i]) {
if (h[i] + e.c - h[e.to] < 0 && e.f) push(e, e.f);
}
}
for (int i = 0; i < N; ++i) {
if (ex[i] > 0){
q.push(i);
isq[i] = 1;
}
}
// make flow feasible
while (!q.empty()) {
int u = q.front(); q.pop();
isq[u]=0;
while (ex[u] > 0) {
if (cur[u] == G[u].size()) {
relabel(u);
}
for (unsigned int &i=cur[u], max_i = G[u].size(); i < max_i; ++i) {
Edge &e = G[u][i];
if (h[u] + e.c - h[e.to] < 0) {
push(e, ex[u]);
if (ex[e.to] > 0 && isq[e.to] == 0) {
q.push(e.to);
isq[e.to] = 1;
}
if (ex[u] == 0) break;
}
}
}
}
if (eps > 1 && eps>>scale == 0) {
eps = 1<<scale;
}
}
for (int i = 0; i < N; ++i) {
for (Edge &e : G[i]) {
retCost -= BigInt(e.c)*BigInt(e.f);
}
}
return make_pair(retFlow, retCost / 2 / N);
}
private:
static constexpr cost_t INFCOST = numeric_limits<cost_t>::max()/2;
static constexpr int scale = 2;
cost_t eps;
vector<unsigned int> isq, cur;
vector<flow_t> ex;
vector<cost_t> h;
vector<vector<int> > hs;
vector<int> co;
void add_flow(Edge& e, flow_t f) {
Edge &back = G[e.to][e.rev];
if (!ex[e.to] && f) {
hs[h[e.to]].push_back(e.to);
}
e.f -= f; ex[e.to] += f;
back.f += f; ex[back.to] -= f;
}
void push(Edge &e, flow_t amt) {
if (e.f < amt) amt = e.f;
e.f -= amt; ex[e.to] += amt;
G[e.to][e.rev].f += amt; ex[G[e.to][e.rev].to] -= amt;
}
void relabel(int vertex){
cost_t newHeight = -INFCOST;
for (unsigned int i = 0; i < G[vertex].size(); ++i){
Edge const&e = G[vertex][i];
if(e.f && newHeight < h[e.to] - e.c){
newHeight = h[e.to] - e.c;
cur[vertex] = i;
}
}
h[vertex] = newHeight - eps;
}
flow_t max_flow() {
ex.assign(N, 0);
h.assign(N, 0); hs.resize(2*N);
co.assign(2*N, 0); cur.assign(N, 0);
h[S] = N;
ex[T] = 1;
co[0] = N-1;
for (auto &e : G[S]) {
add_flow(e, e.f);
}
if (hs[0].size()) {
for (int hi = 0; hi>=0;) {
int u = hs[hi].back();
hs[hi].pop_back();
while (ex[u] > 0) { // discharge u
if (cur[u] == G[u].size()) {
h[u] = 1e9;
for(unsigned int i = 0; i < G[u].size(); ++i) {
auto &e = G[u][i];
if (e.f && h[u] > h[e.to]+1) {
h[u] = h[e.to]+1, cur[u] = i;
}
}
if (++co[h[u]], !--co[hi] && hi < N) {
for (int i = 0; i < N; ++i) {
if (hi < h[i] && h[i] < N) {
--co[h[i]];
h[i] = N + 1;
}
}
}
hi = h[u];
} else if (G[u][cur[u]].f && h[u] == h[G[u][cur[u]].to]+1) {
add_flow(G[u][cur[u]], min(ex[u], G[u][cur[u]].f));
} else {
++cur[u];
}
}
while (hi>=0 && hs[hi].empty()) {
--hi;
}
}
}
return -ex[S];
}
};
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << (fixed) << setprecision(9) << boolalpha;
int source, sink;
int n, m; cin >> n >> m >> source >> sink;
--source; --sink;
MinCostFlow<int,int> mcf(n, source, sink);
FOR(i,1,m) {
int u, v, f, c; cin >> u >> v >> f >> c;
--u; --v;
mcf.addEdge(u, v, f, c);
}
auto res = mcf.minCostMaxFlow();
cout << res.second << endl;
return 0;
}
Trung Nguyen I_love_Hoang_Yen