#ifdef DEBUG
#define _GLIBCXX_DEBUG
#endif
//#pragma GCC optimize("O3")
#include<bits/stdc++.h>
using namespace std;

#define pb push_back

typedef long long ll;
typedef double ld;
struct pt{
    ld x, y;
    int id;
};
int n, m;
const int maxN = 2e5 + 10;
ll a[maxN], b[maxN], c[maxN];
bool bad[maxN];
int x[maxN], y[maxN];
ld area(pt a, pt b, pt c) {
    return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
}
const ld eps = 1e-9;
vector<pt> convexHull(vector<pt>& pts) {
    sort(pts.begin(), pts.end(), [&](const pt &a, const pt &b) {
        return a.x + eps < b.x || (fabsl(a.x - b.x) < eps && a.y + eps < b.y);
    });
    vector<pt> npts;
    for (auto& it : pts) {
        if (!npts.empty() && fabsl(it.x - npts.back().x) < eps && fabsl(it.y - npts.back().y) < eps) {
            continue;
        }
        npts.emplace_back(it);
    }
    pts = npts;
    if (pts.size() < 3) {
        return pts;
    }
    pt pUp = pts.front(), pDown = pts.back();
    vector<pt> up{pUp}, down{pUp};
    for (size_t i = 1; i < pts.size(); ++i) {
        if (i == pts.size() - 1 || area(pUp, pts[i], pDown) < -eps) {
            while (up.size() >= 2 &&
                   area(up[up.size()-2], up.back(), pts[i]) > -eps) {
                up.pop_back();
            }
            up.push_back(pts[i]);
        }
        if (i == pts.size() - 1 || area(pUp, pts[i], pDown) > eps) {
            while (down.size() >= 2 &&
                   area(down[down.size()-2], down.back(), pts[i]) < eps) {
                down.pop_back();
            }
            down.push_back(pts[i]);
        }
    }
    assert(up.size() >= 2);
    for (size_t i = up.size() - 2; i > 0; --i) {
        down.push_back(up[i]);
    }
    return down;
}
ll det(ll a11, ll a12, ll a21, ll a22) {
    return a11 * a22 - a21 * a12;
}
pair<pair<int,int>, pair<int,int>> val_l[maxN];
pair<pair<int,int>, pair<int,int>> val_r[maxN];
pt L[maxN], R[maxN];
bool cmp(pair<int, int> a, pair <int, int> b) {
    return (1LL * a.first * b.second < 1LL * a.second * b.first);
}
void upd(int where, ll DX, ll DY, ll D) {
    pair<pair<int,int>, pair<int,int>> we = make_pair(make_pair(DX, D), make_pair(DY, D));
    if (val_l[where].first.second == 0) {
        val_l[where] = we;
        val_r[where] = we;
        L[where] = {(ld)DX / D, (ld)DY / D, -1};
        R[where] = {(ld)DX / D, (ld)DY / D, -1};
        return;
    }
    if (cmp(we.first, val_l[where].first) || (!cmp(val_l[where].first, we.first) && cmp(we.second, val_l[where].second))) {
        val_l[where] = we;
        L[where] = {(ld)DX / D, (ld)DY / D, -1};
    }

    if (cmp(val_r[where].first, we.first) || (!cmp(we.first, val_r[where].first) && cmp(val_r[where].second, we.second))) {
        val_r[where] = we;
        R[where] = {(ld)DX / D, (ld)DY / D, -1};
    }
}
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
#ifdef DEBUG
    freopen("input.txt", "r", stdin);
#endif
    cin >> n >> m;
    if (m >= (1LL * n * (n - 1)) / 2 - 1) {
        cout << fixed << setprecision(12) << 0;
        return 0;
    }
    for (int i = 1; i <= n; i++) {
        cin >> a[i] >> b[i] >> c[i];
        if (b[i] == 0) {
            bad[i] = true;
        }
    }
    map<pair<int,int>,int> mp;
    for (int i = 1; i <= m; i++) {
        cin >> x[i] >> y[i];
        assert(!mp.count({x[i], y[i]}));
        mp[{x[i], y[i]}] = true;
        mp[{y[i], x[i]}] = true;
        bad[x[i]] = true;
        bad[y[i]] = true;
    }
    vector<pt> ch;
    for (int i = 1; i <= n; i++) {
        if (bad[i]) continue;
        pt f;
        f.x = (ld)-a[i] / b[i];
        f.y = (ld)c[i] / b[i];
        f.id = i;
        ch.emplace_back(f);
    }

    vector<pt> cand;
    sort(ch.begin(), ch.end(), [&](pt& a, pt& b) {
        return a.x < b.x;
    });
    auto add = [&](int x, int y) {
        ll D = det(a[x], b[x], a[y], b[y]);
        ll DX = det(c[x], b[x], c[y], b[y]);
        ll DY = det(a[x], c[x], a[y], c[y]);
        assert(D != 0);
        if (D < 0) {
            D *= -1;
            DX *= -1;
            DY *= -1;
        }
        upd(x, DX, DY, D);
        upd(y, DX, DY, D);
    };
    for (int x = 0; x < 2; x++) {
        for (int sgn = -1; sgn <= 1; sgn += 2) {
            vector<pt> cur;
            for (auto t : ch) {
                while (cur.size() >= 2 && (cur[cur.size() - 2].x - t.x) * (cur.back().y - t.y)
                                          > (cur[cur.size() - 2].y - t.y) * (cur.back().x - t.x)) {
                    cur.pop_back();
                }
                if (!cur.empty()) {
                    add(cur.back().id, t.id);
                }
                cur.emplace_back(t);
            }
            for (auto& it : ch) {
                it.y *= -1;
            }
        }
        reverse(ch.begin(), ch.end());
    }
    for (int i = 1; i <= n; i++) {
        if (!bad[i]) continue;
        for (int j = 1; j <= n; j++) {
            if (mp.count({i, j})) continue;
            if (i == j) continue;
            add(i, j);
        }
    }
    vector<pt> fin;
    for (int i = 1; i <= n; i++) {
        if (val_l[i].first.second == 0) continue;
        fin.emplace_back(L[i]);
        fin.emplace_back(R[i]);
    }
    fin = convexHull(fin);
    ld ans = 0;
    for (int z = 0; z < fin.size(); z++) {
        ld D = sqrtl((fin[(z + 1) % fin.size()].x - fin[z].x) * (fin[(z + 1) % fin.size()].x - fin[z].x) +
                     (fin[(z + 1) % fin.size()].y - fin[z].y) * (fin[(z + 1) % fin.size()].y - fin[z].y));
        ans += D;
    }
    cout << fixed << setprecision(12) << ans << '\n';
    return 0;
}