#include <bits/stdc++.h>
using namespace std;
const double inf = 1e15;
struct triple {
  double Max, Min, Diff;
};
struct node {
  double Max, Min, Diff;
  int l, r;
  node() {
    Max = -inf;
    Min = inf;
    Diff = 0;
    l = r = -1;
  }
};
struct seg {
  vector<node> v;
  seg() {
    v.clear();
    v.push_back(node());
  }
  void update(int k, int from, int to, int x, double val) {
    if (x < from || x > to) {
      return;
    }
    v[k].Max = max(v[k].Max, val);
    v[k].Min = min(v[k].Min, val);
    if (from == to) {
      return;
    }
    if (v[k].l == -1) {
      v[k].l = (int)v.size();
      v.push_back(node());
      v[k].r = (int)v.size();
      v.push_back(node());
    }
    int mid = (from + to) / 2;
    update(v[k].l, from, mid, x, val);
    update(v[k].r, mid + 1, to, x, val);
  }
  void update2(int k, int from, int to) {
    v[k].Diff = 0;
    if (v[k].l != -1) {
      int mid = (from + to) / 2;
      update2(v[k].l, from, mid);
      update2(v[k].r, mid + 1, to);
      v[k].Diff = max(v[k].Diff, v[v[k].l].Diff);
      v[k].Diff = max(v[k].Diff, v[v[k].r].Diff);
      v[k].Diff = max(v[k].Diff, -v[v[k].l].Min + v[v[k].r].Max);
    }
  }
  triple read(int k, int from, int to, int x, int y) {
    if (y < from || x > to) {
      triple ret;
      ret.Max = -inf;
      ret.Min = inf;
      ret.Diff = 0;
      return ret;
    }
    if (from >= x && to <= y) {
      triple ret;
      ret.Max = v[k].Max;
      ret.Min = v[k].Min;
      ret.Diff = v[k].Diff;
      return ret;
    }
    if (v[k].l == -1) {
      v[k].l = (int)v.size();
      v.push_back(node());
      v[k].r = (int)v.size();
      v.push_back(node());
    }
    int mid = (from + to) / 2;
    triple cur1 = read(v[k].l, from, mid, x, y);
    triple cur2 = read(v[k].r, mid + 1, to, x, y);
    triple ret;
    ret.Max = -inf;
    ret.Min = inf;
    ret.Diff = 0;
    ret.Diff = max(ret.Diff, max(cur1.Diff, cur2.Diff));
    ret.Max = max(cur1.Max, cur2.Max);
    ret.Min = min(cur1.Min, cur2.Min);
    ret.Diff = max(ret.Diff, -cur1.Min + cur2.Max);
    return ret;
  }
} S;
const int MAX_N = 3 * 1000 * 1000 + 100;
double x[MAX_N];
double p[MAX_N];
int n, m;
double c;
double a[MAX_N];
double s[MAX_N];
int main() {
  cin >> n >> m >> c;
  for (int i = 0; i < n; i++) cin >> x[i];
  for (int i = 1; i < n; i++) cin >> p[i];
  a[0] = 0;
  for (int i = 1; i < n; i++) a[i] = (x[i] - x[i - 1]) / 2.0 - c * p[i] / 100.0;
  s[0] = 0;
  for (int i = 1; i < n; i++) s[i] = s[i - 1] + a[i];
  for (int i = 0; i < n; i++) S.update(0, 0, n, i, s[i]);
  S.update2(0, 0, n);
  double ans = 0;
  for (int i = 0; i < m; i++) {
    int x, y;
    cin >> x >> y;
    x--;
    y--;
    ans += S.read(0, 0, n, x, y).Diff;
  }
  cout << fixed << setprecision(8);
  cout << ans << endl;
  return 0;
}
