#include <bits/stdc++.h>
using namespace std;
struct data {
  int x, h, l, r;
} tree[100010];
bool operator<(data a, data b) { return a.x < b.x; }
struct data2 {
  int x, z;
} mush[10010];
bool operator<(data2 a, data2 b) { return a.x < b.x; }
int n, m;
double tr[40010], lazy[40010];
pair<int, int> getRange(int l, int r) {
  pair<int, int> res = pair<int, int>(-1, -1);
  int dau = 1, cuoi = m, mid;
  while (dau <= cuoi) {
    mid = (dau + cuoi) >> 1;
    if (mush[mid].x > r)
      cuoi = mid - 1;
    else
      dau = mid + 1;
  }
  if (cuoi < 1) return pair<int, int>(-1, -1);
  res.second = cuoi;
  dau = 1;
  cuoi = m;
  while (dau <= cuoi) {
    mid = (dau + cuoi) >> 1;
    if (mush[mid].x < l)
      dau = mid + 1;
    else
      cuoi = mid - 1;
  }
  if (dau > m) return pair<int, int>(-1, -1);
  if (dau > res.second) return pair<int, int>(-1, -1);
  res.first = dau;
  return res;
}
void build(int k, int l, int r) {
  if (l > r) return;
  if (l == r) {
    tr[k] = 1;
    lazy[k] = 1;
    return;
  }
  int m = (l + r) >> 1;
  build(k * 2, l, m);
  build(k * 2 + 1, m + 1, r);
  lazy[k] = 1;
}
void lazy_upd(int k, int l, int r) {
  if (lazy[k] == 1) return;
  if (l == r) tr[k] *= lazy[k];
  if (l < r) {
    lazy[k * 2] *= lazy[k];
    lazy[k * 2 + 1] *= lazy[k];
  }
  lazy[k] = 1;
}
void update(int k, int l, int r, int u, int v, int gt) {
  if (l > r || r < u || v < l) return;
  lazy_upd(k, l, r);
  if (u <= l && r <= v) {
    lazy[k] = gt / 100.0;
    lazy_upd(k, l, r);
    return;
  }
  int m = (l + r) >> 1;
  update(k * 2, l, m, u, v, gt);
  update(k * 2 + 1, m + 1, r, u, v, gt);
}
double get(int k, int l, int r, int u) {
  lazy_upd(k, l, r);
  if (l == r) return tr[k];
  int m = (l + r) >> 1;
  if (u <= m) return get(k * 2, l, m, u);
  return get(k * 2 + 1, m + 1, r, u);
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(NULL);
  cin >> n >> m;
  for (int i = (1); i <= (n); i++)
    cin >> tree[i].x >> tree[i].h >> tree[i].l >> tree[i].r;
  for (int i = (1); i <= (m); i++) cin >> mush[i].x >> mush[i].z;
  sort(tree + 1, tree + n + 1);
  sort(mush + 1, mush + m + 1);
  build(1, 1, m);
  for (int i = (1); i <= (n); i++) {
    int l = tree[i].x - tree[i].h;
    int r = tree[i].x - 1;
    pair<int, int> range = getRange(l, r);
    if (range.first != -1)
      update(1, 1, m, range.first, range.second, 100 - tree[i].l);
    l = tree[i].x + 1;
    r = tree[i].x + tree[i].h;
    range = getRange(l, r);
    if (range.first != -1)
      update(1, 1, m, range.first, range.second, 100 - tree[i].r);
  }
  double res = 0;
  for (int i = (1); i <= (m); i++) res += mush[i].z * get(1, 1, m, i);
  cout << fixed << setprecision(9) << res;
  return 0;
}
