#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <cmath>

using namespace std;

struct QuadraticFunction{
    long double Compute(long double x) {
        return a * x * x + b * x + c;
    }
    long double DefiniteIntegral(long double left, long double right) {
        long double F_right = a * right * right * right / 3 + b * right * right / 2 + c * right;
        long double F_left = a * left * left * left / 3 + b * left * left / 2 + c * left;
        return F_right - F_left;
    }

    long double DefiniteIntegralAbs(int left, int right) {
        if (a == 0) {
            if (b == 0) {
                return abs(DefiniteIntegral(left, right));
                //return abs(c) * (right - left);
            } else {
                long double x0 = static_cast<long double> (-c) / b;
                //long double f_left = Compute(left);
                //long double f_right = Compute(right);
                if (left <= x0 && x0 <= right) {
                    return abs(DefiniteIntegral(left, x0)) + abs(DefiniteIntegral(x0, right));
                    //return (abs(f_left) * (x0 - left) + abs(f_right) * (right - x0)) / 2;
                } else {
                    return abs(DefiniteIntegral(left, right));
                    //return (abs(f_left + f_right) * (right - left)) / 2;
                }
            }
        } else {
            int d = b * b - 4 * a * c;
            if (d > 0) {
                long double x1 = (-b - sqrt(d)) / 2 / a;
                long double x2 = (-b + sqrt(d)) / 2 / a;
                if (x2 <= left || right <= x1) {
                    return abs(DefiniteIntegral(left, right));
                } else if (x1 <= right && left <= x2) {
                    return abs(DefiniteIntegral(left, right));
                } else if (x1 <= left && left <= x2 && x2 <= right) {
                    return abs(DefiniteIntegral(left, x2)) + abs(DefiniteIntegral(x2, right));
                } else if (left <= x1 && x2 <= right) {
                    return abs(DefiniteIntegral(left, x1)) +
                        abs(DefiniteIntegral(x1, x2)) +
                        abs(DefiniteIntegral(x2, right));
                } else if (left <= x1 && x1 <= right && right <= x2) {
                    return abs(DefiniteIntegral(left, x1)) + abs(DefiniteIntegral(x1, right));
                }
            }
        }
    }

    // a*x*x+b*x+c
    int a;
    int b;
    int c;
};

QuadraticFunction operator-(const QuadraticFunction& lhs, const QuadraticFunction& rhs) {
    return {lhs.a - rhs.a, lhs.b - rhs.b, lhs.c - rhs.c};
}

struct Border{
    int x;
    int function_id;
};

bool operator<(const Border& lhs, const Border& rhs) {
    if (lhs.x == rhs.x) {
        return lhs.function_id < rhs.function_id;
    }
    return lhs.x < rhs.x;
}

int main() {

    /*

    {
        QuadraticFunction f = {0, 0, 1};
        QuadraticFunction g = {0, 0, 2};
        QuadraticFunction difference = f - g;
        cout << difference.DefiniteIntegralAbs(1, 0) << endl;
    }

    {
        QuadraticFunction f = {1, -2, 1};
        QuadraticFunction g = {-1, 2, 1};
        QuadraticFunction difference = f - g;
        cout << difference.DefiniteIntegralAbs(1, 0) << endl;
    }

     */

    int n = 0;
    int m = 0;
    cin >> n >> m;

    vector<Border> f_borders( n + 1);
    for (Border& border : f_borders) {
        int x;
        cin >> x;
        border = {x, 1};
    }

    vector<QuadraticFunction> f_parts(n);
    for (auto& part : f_parts) {
        int a, b, c;
        cin >> a >> b >> c;
        part = {a, b, c};
    }
    f_parts.push_back({0, 0, 0});

    vector<Border> g_borders(m + 1);
    for (Border& border : g_borders) {
        int x;
        cin >> x;
        border = {x, 2};
    }

    vector<QuadraticFunction> g_parts(m);
    for (auto& part : g_parts) {
        int a, b, c;
        cin >> a >> b >> c;
        part = {a, b, c};
    }

    vector<Border> general_borders(n + m + 2);
    merge(f_borders.begin(), f_borders.end(),
          g_borders.begin(), g_borders.end(),
          general_borders.begin()
    );

    int pos_f = 0;
    int pos_g = 0;
    int left = general_borders[0].x;
    int right = left;

    long double sum = 0;

    for (int i = 2; i < n + m + 1; ++i) {
        left = right;
        right = general_borders[i].x;
        sum += (f_parts[pos_f] - g_parts[pos_g]).DefiniteIntegralAbs(left, right);
        if (general_borders[i].function_id == 1) {
            ++pos_f;
        } else {
            ++pos_g;
        }
    }

    cout << setprecision(10) << fixed
        << sum << endl;

    return 0;
}