#include <bits/stdc++.h>

using namespace std;

#define maxn 1000000

#define INF 99999999

int n, m, S, T, rec[maxn], flow[maxn], a[maxn], b[maxn];

int ans, tot, c[maxn], d[maxn], dis[maxn], num[maxn];

bool vis[maxn];

int read() {

    int x = , k = ;

    char c; c = getchar();

    while(c < '' || c > '') { if(c == '-') k = -; c = getchar(); }

    while(c >= '' && c <= '') x = x *  + c - '', c = getchar();

    return x * k;

}

struct edge {

    int cnp, to[maxn], last[maxn], head[maxn], f[maxn], co[maxn];

    edge() { cnp = ; }

    void add(int u, int v, int fl, int w) {

        to[cnp] = v, f[cnp] = fl, co[cnp] = w, last[cnp] = head[u], head[u] = cnp ++;

        to[cnp] = u, f[cnp] = , co[cnp] = -w, last[cnp] = head[v], head[v] = cnp ++;

    }

}E1;

struct node {

    int x, y;

}P[maxn];

int multi(int x) { return x * x; }

void Build() {

    S = , T =  * m + ;

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

        int A = a[i] + num[i], B = b[i];

        if(num[i]) rec[i] = tot + ;

        for(int j = ; j <= num[i]; j ++) {

            ++ tot;

            E1.add(tot, T, ,  * B * d[i] -  * A * c[i] + c[i] + d[i]);

            if(j != num[i]) E1.add(tot, tot + , INF, );

            A --, B ++;

        }

    }

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

        E1.add(S, ++ tot, , );

        E1.add(tot, rec[P[i].x], , );

        E1.add(tot, rec[P[i].y], , );

    }

}

bool SPFA() {

    queue <int> q;

    for(int i = ; i <= T; i ++) dis[i] = INF, vis[i] = ;

    q.push(S); dis[S] = ; flow[S] = INF;

    while(!q.empty()) {

        int u = q.front(); q.pop(); vis[u] = ;

        for(int i = E1.head[u]; i; i = E1.last[i]) {

            int v = E1.to[i];

            if(!E1.f[i]) continue;

            if(dis[v] > dis[u] + E1.co[i]) {

                dis[v] = dis[u] + E1.co[i];

                rec[v] = i, flow[v] = min(flow[u], E1.f[i]);

                if(!vis[v]) q.push(v), vis[v] = ;

            }

        }

    }

    if(dis[T] != INF) return ;

    return ;

}

int Max_Flow() {

    int ans = , cost = ;

    while(SPFA()) {

        int u = T;

        while(u != S) {

            int t = rec[u];

            E1.f[t] -= flow[T], E1.f[t ^ ] += flow[T];

            u = E1.to[t ^ ];

        }

        ans += flow[T], cost += dis[T] * flow[T];

    }

    return cost;

}

int main() {

    n = read(), m = read();

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

        a[i] = read(), b[i] = read(), c[i] = read(), d[i] = read();

    }

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

        int x = read(), y = read();

        num[x] ++, num[y] ++; P[i].x = x, P[i].y = y;

    }

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

        ans += c[i] * multi(a[i] + num[i]) + d[i] * multi(b[i]);

    Build();

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

    return ;

}