/*
 * 150C_107.cpp
 *
 *  Created on: Jan 29, 2013
 *      Author: shuo
 */

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 150011;

int L[N<<2], R[N<<2];
double lv[N<<2], rv[N<<2];
double sum[N<<2], ma[N<<2];

typedef struct node {
	double ma, ml, mr;
}qtype;

int cnt[N<<2];
double a[N], pr[N];
int v[N], n;
int c;

void build (int u, int x, int y) {
	L[u] = x; R[u] = y;
	if (x == y) {
		sum[u] = lv[u] = rv[u] = a[x];
		ma[u] = max (a[x], .0);
		return;
	}
	int mid = (x + y) / 2;
	build (u << 1, x, mid);
	build (u << 1 | 1, mid + 1, y);
	sum[u] = sum[u<<1] + sum[u<<1|1];
	ma[u] = max (max (ma[u<<1], ma[u<<1|1]),lv[u<<1|1] + rv[u<<1]);
	lv[u] = max (lv[u<<1], sum[u<<1] + lv[u<<1|1]);
	rv[u] = max (rv[u<<1|1], sum[u<<1|1] + rv[u<<1]);
}

// maximum consecutive sub-block
qtype query (int u, int x, int y) {
	if (x <= L[u] && y >= R[u]) {
		qtype ret = {ma[u], lv[u], rv[u]};
		return ret;
	}
	int mid = (L[u] + R[u]) / 2;
	qtype a = {-1e20, -1e20, -1e20}, b = {-1e20, -1e20, -1e20}, ret;
	if (x <= mid) a = query (u<<1, x, y);
	if (y > mid) b = query (u<<1|1, x, y);
	ret.ma = max (max (a.ma, b.ma), a.mr + b.ml);
	ret.ml = a.ml;
	if (x <= L[u] && y > mid)
		ret.ml = max (ret.ml, sum[u<<1] + b.ml);
	ret.mr = b.mr;
	if (y >= R[u] && x <= mid)
		ret.mr = max (ret.mr, sum[u<<1|1] + a.mr);

	return ret;
}

int main () {
	int i, j, k, m;
	scanf ("%d%d%d", &n, &m, &c);
	for (i = 1, k = 0; i <= n; ++i) {
		scanf ("%d", &v[i]);
		j = v[i] - k;
		k= v[i]; v[i] = j;
	}

	for (i = 2; i <= n; ++i) {
		scanf ("%lf", &pr[i]);
		pr[i] /= 100;
	}
	for (i = 2; i <= n; ++i)
		a[i] = .5 * v[i] - pr[i] * c;

	build (1, 2, n);
	double ans = .0;
	for (; m; --m) {
		int ai, bi;
		scanf ("%d%d", &ai, &bi);
		qtype ret = query (1, ai + 1, bi);
		ans += ret.ma;
	}

	printf ("%.15lf\n", ans);
	return 0;
}

/*
5 5 651
0 438 1449 2349 3194
67 6 98 38
3 5
1 3
4 5
1 3
2 3
1749.56
 */


#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <set>
#include <queue>
#include <bitset>
#include <list>
using namespace std;

int n,m;
double c;
double x[310000];
double p[310000];
double f[310000],sum[310000];
int a[310000],b[310000];
double ans;
int ac[100],cnt;
double g[100];

struct node
{
    int l,r;
    double ms,ls,rs,ss;
}tree[300000*4];

void build(int k,int l,int r)
{
    tree[k].l=l;
    tree[k].r=r;
    if(l+1==r)
    {
        tree[k].ss=f[r];
        tree[k].ms=0;
        tree[k].ms=min(tree[k].ms,f[r]);
        tree[k].ls=tree[k].rs=tree[k].ms;
        return;
    }
    build(2*k,l,(l+r)/2);
    build(2*k+1,(l+r)/2,r);
    tree[k].ss=tree[2*k].ss+tree[2*k+1].ss;
    tree[k].ls=tree[k].rs=tree[k].ms=0;
    tree[k].ms=min(tree[k].ms,tree[2*k].ms);
    tree[k].ms=min(tree[k].ms,tree[2*k+1].ms);
    tree[k].ms=min(tree[k].ms,tree[2*k].rs+tree[2*k+1].ls);
    tree[k].ls=min(tree[k].ls,tree[2*k].ls);
    tree[k].ls=min(tree[k].ls,tree[2*k+1].ls+tree[2*k].ss);
    tree[k].rs=min(tree[k].rs,tree[2*k+1].rs);
    tree[k].rs=min(tree[k].rs,tree[2*k+1].ss+tree[2*k].rs);
    return;
}

void query(int k,int l,int r)
{
    int mid=(tree[k].l+tree[k].r)/2;
    if((tree[k].l==l)&&(tree[k].r==r))
    {
        cnt++;
        ac[cnt]=k;
        return;
    }
    if(l<mid)
    {
        query(2*k,l,min(mid,r));
    }
    if(r>mid)
    {
        query(2*k+1,max(mid,l),r);
    }
    return;
}

int main()
{
    cin>>n>>m>>c;
    n--;
    for(int i=0;i<=n;i++)
    {
        scanf("%lf",x+i);
    }
    for(int i=1;i<=n;i++)
    {
        scanf("%lf",p+i);
        p[i]=p[i]/100.0;
    }
    for(int i=0;i<m;i++)
    {
        scanf("%d%d",a+i,b+i);
        a[i]--;
        b[i]--;
    }
    for(int i=1;i<=n;i++)
    {
        double dis=(x[i]-x[i-1])/2.0;
        f[i]=(1-p[i])*dis+p[i]*(dis-c);
        sum[i]=sum[i-1]+f[i];
    }
    build(1,0,n);
    double cwj=0;
    for(int i=0;i<m;i++)
    {
        cwj+=(sum[b[i]]-sum[a[i]]);
    }
    for(int i=0;i<m;i++)
    {
        ans=0;
        cnt=0;
        query(1,a[i],b[i]);
        double pre=0;
        for(int j=1;j<=cnt;j++)
        {
            ans=min(ans,tree[ac[j]].ms);
            ans=min(ans,pre+tree[ac[j]].ls);
            pre=min(pre+tree[ac[j]].ss,tree[ac[j]].rs);
        }
        cwj-=ans;
    }
    printf("%.9f\n",cwj);
    return 0;
}


#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <set>
#include <queue>
#include <bitset>
#include <list>
using namespace std;

int n,m;
double c;
double x[310000];
double p[310000];
double f[310000],sum[310000];
int a[310000],b[310000];
double ans;
int ac[100],cnt;

struct node
{
    int l,r;
    double ms,ls,rs,ss;
}tree[300000*4];

void build(int k,int l,int r)
{
    tree[k].l=l;
    tree[k].r=r;
    if(l+1==r)
    {
        tree[k].ss=f[r];
        tree[k].ms=0;
        tree[k].ms=max(tree[k].ms,f[r]);
        tree[k].ls=tree[k].rs=tree[k].ms;
        return;
    }
    build(2*k,l,(l+r)/2);
    build(2*k+1,(l+r)/2,r);
    tree[k].ss=tree[2*k].ss+tree[2*k+1].ss;
    tree[k].ls=tree[k].rs=tree[k].ms=0;
    tree[k].ms=max(tree[k].ms,tree[2*k].ms);
    tree[k].ms=max(tree[k].ms,tree[2*k+1].ms);
    tree[k].ms=max(tree[k].ms,tree[2*k].rs+tree[2*k+1].ls);
    tree[k].ls=max(tree[k].ls,tree[2*k].ls);
    tree[k].ls=max(tree[k].ls,tree[2*k+1].ls+tree[2*k].ss);
    tree[k].rs=max(tree[k].rs,tree[2*k+1].rs);
    tree[k].rs=max(tree[k].rs,tree[2*k+1].ss+tree[2*k].rs);
    return;
}

void query(int k,int l,int r)
{
    int mid=(tree[k].l+tree[k].r)/2;
    if((tree[k].l==l)&&(tree[k].r==r))
    {
        cnt++;
        ac[cnt]=k;
        return;
    }
    if(l<mid)
    {
        query(2*k,l,min(mid,r));
    }
    if(r>mid)
    {
        query(2*k+1,max(mid,l),r);
    }
    return;
}

int main()
{
    //freopen("c.txt","r",stdin);
    cin>>n>>m>>c;
    n--;
    for(int i=0;i<=n;i++)
    {
        scanf("%lf",x+i);
    }
    for(int i=1;i<=n;i++)
    {
        scanf("%lf",p+i);
        p[i]=p[i]/100.0;
    }
    for(int i=0;i<m;i++)
    {
        scanf("%d%d",a+i,b+i);
        a[i]--;
        b[i]--;
    }
    for(int i=1;i<=n;i++)
    {
        double dis=(x[i]-x[i-1])/2.0;
        f[i]=(1-p[i])*dis+p[i]*(dis-c);
        sum[i]=sum[i-1]+f[i];
    }
    build(1,0,n);
    double cwj=0;
    for(int i=0;i<m;i++)
    {
        ans=0;
        cnt=0;
        query(1,a[i],b[i]);
        double pre=0;
        for(int j=1;j<=cnt;j++)
        {
            ans=max(ans,tree[ac[j]].ms);
            ans=max(ans,pre+tree[ac[j]].ls);
            pre=max(pre+tree[ac[j]].ss,tree[ac[j]].rs);
        }
        cwj+=ans;
    }

    printf("%.9f\n",cwj);
    return 0;
}


#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <set>
#include <queue>
#include <bitset>
#include <list>
using namespace std;

int n,m;
double c;
double x[200000];
double p[200000];
double f[200000],sum[200000];
int a[310000],b[310000];
double ans;
int ac[100],cnt;
double g[100];

struct node
{
    int l,r;
    double ms,ls,rs,ss;
}tree[150000*4];

void build(int k,int l,int r)
{
    tree[k].l=l;
    tree[k].r=r;
    if(l+1==r)
    {
        tree[k].ss=f[r];
        tree[k].ms=0;
        tree[k].ms=min(tree[k].ms,f[r]);
        tree[k].ls=tree[k].rs=tree[k].ms;
        return;
    }
    build(2*k,l,(l+r)/2);
    build(2*k+1,(l+r)/2,r);
    tree[k].ss=tree[2*k].ss+tree[2*k+1].ss;
    tree[k].ls=tree[k].rs=tree[k].ms=0;
    tree[k].ms=min(tree[k].ms,tree[2*k].ms);
    tree[k].ms=min(tree[k].ms,tree[2*k+1].ms);
    tree[k].ms=min(tree[k].ms,tree[2*k].rs+tree[2*k+1].ls);
    tree[k].ls=min(tree[k].ls,tree[2*k].ls);
    tree[k].ls=min(tree[k].ls,tree[2*k+1].ls+tree[2*k].ss);
    tree[k].rs=min(tree[k].rs,tree[2*k+1].rs);
    tree[k].rs=min(tree[k].rs,tree[2*k+1].ss+tree[2*k].rs);
    return;
}

void query(int k,int l,int r)
{
    int mid=(tree[k].l+tree[k].r)/2;
    if((tree[k].l==l)&&(tree[k].r==r))
    {
        cnt++;
        ac[cnt]=k;
        return;
    }
    if(l<mid)
    {
        query(2*k,l,min(mid,r));
    }
    if(r>mid)
    {
        query(2*k+1,max(mid,l),r);
    }
    return;
}

int main()
{
    cin>>n>>m>>c;
    n--;
    for(int i=0;i<=n;i++)
    {
        scanf("%lf",x+i);
    }
    for(int i=1;i<=n;i++)
    {
        scanf("%lf",p+i);
        p[i]=p[i]/100.0;
    }
    for(int i=0;i<m;i++)
    {
        scanf("%d%d",a+i,b+i);
        a[i]--;
        b[i]--;
    }
    for(int i=1;i<=n;i++)
    {
        double dis=(x[i]-x[i-1])/2.0;
        f[i]=(1-p[i])*dis+p[i]*(dis-c);
        sum[i]=sum[i-1]+f[i];
    }
    build(1,0,n);
    double cwj=0;
    for(int i=0;i<m;i++)
    {
        cwj+=(sum[b[i]]-sum[a[i]]);
    }
    for(int i=0;i<m;i++)
    {
        ans=0;
        cnt=0;
        query(1,a[i],b[i]);
        double pre=0;
        for(int j=1;j<=cnt;j++)
        {
            ans=min(ans,tree[ac[j]].ms);
            ans=min(ans,pre+tree[ac[j]].ls);
            pre=min(pre+tree[ac[j]].ss,tree[ac[j]].rs);
        }
        cwj-=ans;
    }
    printf("%.9f\n",cwj);
    return 0;
}


#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <set>
#include <queue>
#include <bitset>
#include <list>
using namespace std;

int n,m;
double c;
double x[310000];
double p[310000];
double f[310000],sum[310000];
int a[310000],b[310000];
double ans;
int ac[100],cnt;

struct node
{
    int l,r;
    double ms,ls,rs,ss;
}tree[300000*4];

void build(int k,int l,int r)
{
    tree[k].l=l;
    tree[k].r=r;
    if(l+1==r)
    {
        tree[k].ss=f[r];
        tree[k].ms=0;
        tree[k].ms=max(tree[k].ms,f[r]);
        tree[k].ls=tree[k].rs=tree[k].ms;
        return;
    }
    build(2*k,l,(l+r)/2);
    build(2*k+1,(l+r)/2,r);
    tree[k].ss=tree[2*k].ss+tree[2*k+1].ss;
    tree[k].ls=tree[k].rs=tree[k].ms=0;
    tree[k].ms=max(tree[k].ms,tree[2*k].ms);
    tree[k].ms=max(tree[k].ms,tree[2*k+1].ms);
    tree[k].ms=max(tree[k].ms,tree[2*k].rs+tree[2*k+1].ls);
    tree[k].ls=max(tree[k].ls,tree[2*k].ls);
    tree[k].ls=max(tree[k].ls,tree[2*k+1].ls+tree[2*k].ss);
    tree[k].rs=max(tree[k].rs,tree[2*k+1].rs);
    tree[k].rs=max(tree[k].rs,tree[2*k+1].ss+tree[2*k].rs);
    return;
}

void query(int k,int l,int r)
{
    int mid=(tree[k].l+tree[k].r)/2;
    if((tree[k].l==l)&&(tree[k].r==r))
    {
        cnt++;
        ac[cnt]=k;
        return;
    }
    if(l<mid)
    {
        query(2*k,l,min(mid,r));
    }
    if(r>mid)
    {
        query(2*k+1,max(mid,l),r);
    }
    return;
}

int main()
{
    freopen("c.txt","r",stdin);
    cin>>n>>m>>c;
    n--;
    for(int i=0;i<=n;i++)
    {
        scanf("%lf",x+i);
    }
    for(int i=1;i<=n;i++)
    {
        scanf("%lf",p+i);
        p[i]=p[i]/100.0;
    }
    for(int i=0;i<m;i++)
    {
        scanf("%d%d",a+i,b+i);
        a[i]--;
        b[i]--;
    }
    for(int i=1;i<=n;i++)
    {
        double dis=(x[i]-x[i-1])/2.0;
        f[i]=(1-p[i])*dis+p[i]*(dis-c);
        sum[i]=sum[i-1]+f[i];
    }
    build(1,0,n);
    double cwj=0;
    for(int i=0;i<m;i++)
    {
        ans=0;
        cnt=0;
        query(1,a[i],b[i]);
        double pre=0;
        for(int j=1;j<=cnt;j++)
        {
            ans=max(ans,tree[ac[j]].ms);
            ans=max(ans,pre+tree[ac[j]].ls);
            pre=max(pre+tree[ac[j]].ss,tree[ac[j]].rs);
        }
        cwj+=ans;
    }

    printf("%.9f\n",cwj);
    return 0;
}


#include <stdio.h>
#include <algorithm>
using namespace std;

int n,m,c;
int x[150005];
int p[150005];
double f[150005];

typedef struct {
	double pre,suf,sum,best;
} node;

node t[19][1<<18];

void merge(node &nd, node &l, node &r) {
	nd.sum = l.sum + r.sum;
	nd.pre = max(l.pre, l.sum+r.pre);
	nd.suf = max(r.suf, r.sum+l.suf);
	nd.best = max(max(l.best, r.best), l.suf+r.pre);
}

void build(int lev=18, int id=0) {
	node &nd = t[lev][id];
	if (lev==0) {
		nd.sum=f[id];
		nd.pre=max(0.0,f[id]);
		nd.suf=max(0.0,f[id]);
		nd.best=max(0.0,f[id]);
	} else {
		build(lev-1, id*2);
		build(lev-1, id*2+1);
		merge(nd, t[lev-1][id*2], t[lev-1][id*2+1]);
	}
}

node empty = (node){0,0,0,0};

node query(int a, int b, int lev=18, int id=0) {
	int left = id*(1<<lev), right = (id+1)*(1<<lev)-1;
	if (b<left || right<a) return empty;
	if (a<=left && right<=b) return t[lev][id];
	node l = query(a,b,lev-1,id*2);
	node r = query(a,b,lev-1,id*2+1);
	node nd;
	merge(nd,l,r);
	return nd;
}

int main() {
	scanf("%d %d %d",&n,&m,&c);
	for (int i=0;i<n;i++) scanf("%d",&x[i]);
	for (int i=0;i<n-1;i++) scanf("%d",&p[i]);
	for (int i=0;i<n-1;i++) {
		f[i]=(x[i+1]-x[i])/2.0-p[i]*c/100.0;
	}
	build();
	double r=0;
	for (int i=0;i<m;i++) {
		int a,b;
		scanf("%d %d",&a,&b);
		a--; b--;
		node nd = query(a,b-1);
		r+=nd.best;
	}
	printf("%.9lf\n",r);
	return 0;
}


#include <stdio.h>
#include <algorithm>
using namespace std;

int n,m,c;
int x[150005];
int p[150005];
int f[150005];

typedef struct {
	int pre,suf,sum,best;
} node;

node t[19][1<<18];

void merge(node &nd, node &l, node &r) {
	nd.sum = l.sum + r.sum;
	nd.pre = max(l.pre, l.sum+r.pre);
	nd.suf = max(r.suf, r.sum+l.suf);
	nd.best = max(max(l.best, r.best), l.suf+r.pre);
}

void build(int lev=18, int id=0) {
	node &nd = t[lev][id];
	if (lev==0) {
		nd.sum=f[id];
		nd.pre=max(0,f[id]);
		nd.suf=max(0,f[id]);
		nd.best=max(0,f[id]);
	} else {
		build(lev-1, id*2);
		build(lev-1, id*2+1);
		merge(nd, t[lev-1][id*2], t[lev-1][id*2+1]);
	}
}

node empty = (node){0,0,0,0};

node query(int a, int b, int lev=18, int id=0) {
	int left = id*(1<<lev), right = (id+1)*(1<<lev)-1;
	if (b<left || right<a) return empty;
	if (a<=left && right<=b) return t[lev][id];
	node l = query(a,b,lev-1,id*2);
	node r = query(a,b,lev-1,id*2+1);
	node nd;
	merge(nd,l,r);
	return nd;
}

int main() {
	scanf("%d %d %d",&n,&m,&c);
	for (int i=0;i<n;i++) scanf("%d",&x[i]);
	for (int i=0;i<n-1;i++) scanf("%d",&p[i]);
	for (int i=0;i<n-1;i++) {
		f[i]=(x[i+1]-x[i])*50-p[i]*c;
	}
	build();
	double r=0;
	for (int i=0;i<m;i++) {
		int a,b;
		scanf("%d %d",&a,&b);
		a--; b--;
		node nd = query(a,b-1);
		r+=nd.best/100.0;
	}
	printf("%.9lf\n",r);
	return 0;
}


#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;

double F[150000],P[150000];
double Fmn[150000],Fmx[150000],Fans[150000];
int p[150000];

int main(){
    int n,m,C;

    scanf("%d %d %d",&n,&m,&C);

    int x[n];

    for(int i = 0;i < n;++i) scanf("%d",&x[i]);
    for(int i = 1;i < n;++i) scanf("%d",&p[i]);

    P[0] = 0;
    for(int i = 1;i < n;++i)
        P[i] = P[i - 1] + p[i] / 100.0;

    for(int i = 0;i < n;++i)
        F[i] = x[i] / 2.0 - C * P[i];

    int sz = (int)floor(sqrt(n));

    for(int i = 0;sz*i < n;i++){
        Fmn[i] = F[sz*i];
        Fmx[i] = F[sz*i];
        Fans[i] = 0;
        double mn = F[sz*i];

        for(int j = 0;j < sz && sz*i + j  < n;++j){
            Fmn[i] = min(Fmn[i],F[sz*i + j]);
            Fmx[i] = max(Fmx[i],F[sz*i + j]);

            mn = min(mn,F[sz*i + j]);
            Fans[i] = max(Fans[i],F[sz*i + j] - mn);
        }
    }

    double ans = 0;

    for(int i = 0,xa,xb;i < m;++i){
        scanf("%d %d",&xa,&xb);
        --xa; --xb;

        double aux = 0;
        int l = (xa + sz - 1) / sz,r = xb / sz;

        if(l <= r){
            for(int j = l;j < r;++j)
                aux = max(aux,Fans[j]);

            int x1 = min(sz * l,xb);
            double mn = F[xa];

            for(int j = xa;j < x1;++j){
                mn = min(mn,F[j]);
                aux = max(aux,F[j] - mn);
            }

            for(int j = l;j < r;++j){
                aux = max(aux,Fmx[j] - mn);
                mn = min(mn,Fmn[j]);

            int x2 = max(sz * r,xa);

            for(int j = x2;j <= xb;++j){
                mn = min(mn,F[j]);
                aux = max(aux,F[j] - mn);
            }
        }else{
            double mn = F[xa];

            for(int j = xa;j <= xb;++j){
                mn = min(mn,F[j]);
                aux = max(aux,F[j] - mn);
            }
        }

        ans += aux;
    }

    printf("%.8f\n",ans);

    return 0;
}


#include <cstdio>
#include <algorithm>

using namespace std;

double F[150000],P[150000];
double Fmn[150000],Fmx[150000],Fans[150000];
int p[150000];

int main(){
    int n,m,C;

    scanf("%d %d %d",&n,&m,&C);

    int x[n];

    for(int i = 0;i < n;++i) scanf("%d",&x[i]);
    for(int i = 1;i < n;++i) scanf("%d",&p[i]);

    P[0] = 0;
    for(int i = 1;i < n;++i)
        P[i] = P[i - 1] + p[i] / 100.0;

    for(int i = 0;i < n;++i)
        F[i] = x[i] / 2.0 - C * P[i];

    int sz = (int)floor(sqrt(n));

    for(int i = 0;sz*i < n;i++){
        Fmn[i] = F[sz*i];
        Fmx[i] = F[sz*i];
        Fans[i] = 0;
        double mn = F[sz*i];

        for(int j = 0;j < sz && sz*i + j  < n;++j){
            Fmn[i] = min(Fmn[i],F[sz*i + j]);
            Fmx[i] = max(Fmx[i],F[sz*i + j]);

            mn = min(mn,F[sz*i + j]);
            Fans[i] = max(Fans[i],F[sz*i + j] - mn);
        }
    }

    double ans = 0;

    for(int i = 0,xa,xb;i < m;++i){
        scanf("%d %d",&xa,&xb);
        --xa; --xb;

        double aux = 0;
        int l = (xa + sz - 1) / sz,r = xb / sz;

        if(l <= r){
            for(int j = l;j < r;++j)
                aux = max(aux,Fans[j]);

            int x1 = min(sz * l,xb);
            double mn = F[xa];

            for(int j = xa;j < x1;++j){
                mn = min(mn,F[j]);
                aux = max(aux,F[j] - mn);
            }

            for(int j = l;j < r;++j){
                aux = max(aux,Fmx[j] - mn);
                mn = min(mn,Fmn[j]);

            int x2 = max(sz * r,xa);

            for(int j = x2;j <= xb;++j){
                mn = min(mn,F[j]);
                aux = max(aux,F[j] - mn);
            }
        }else{
            double mn = F[xa];

            for(int j = xa;j <= xb;++j){
                mn = min(mn,F[j]);
                aux = max(aux,F[j] - mn);
            }
        }

        ans += aux;
    }

    printf("%.8f\n",ans);

    return 0;
}


#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>
#include <set>

using namespace std;

double F[150000],P[150000];
double Fmn[150000],Fmx[150000],Fans[150000];
int p[150000];

int main(){
    int n,m,C;

    scanf("%d %d %d",&n,&m,&C);

    int x[n];

    for(int i = 0;i < n;++i) scanf("%d",&x[i]);
    for(int i = 1;i < n;++i) scanf("%d",&p[i]);

    P[0] = 0;
    for(int i = 1;i < n;++i)
        P[i] = P[i - 1] + p[i] / 100.0;

    for(int i = 0;i < n;++i)
        F[i] = x[i] / 2.0 - C * P[i];

    int sz = (int)floor(sqrt(n));

    for(int i = 0;sz*i < n;i++){
        Fmn[i] = F[sz*i];
        Fmx[i] = F[sz*i];
        Fans[i] = 0;
        double mn = F[sz*i];

        for(int j = 0;j < sz && sz*i + j  < n;++j){
            Fmn[i] = min(Fmn[i],F[sz*i + j]);
            Fmx[i] = max(Fmx[i],F[sz*i + j]);

            mn = min(mn,F[sz*i + j]);
            Fans[i] = max(Fans[i],F[sz*i + j] - mn);
        }
    }

    double ans = 0;

    for(int i = 0,xa,xb;i < m;++i){
        scanf("%d %d",&xa,&xb);
        --xa; --xb;

        double aux = 0;
        int l = (xa + sz - 1) / sz,r = xb / sz;

        for(int j = l;j < r;++j)
            aux = max(aux,Fans[j]);

        int x1 = sz * l;
        double mn = F[xa];

        for(int j = xa;j < x1;++j){
            mn = min(mn,F[j]);
            aux = max(aux,F[j] - mn);
        }

        for(int j = l;j < r;++j){
            aux = max(aux,Fmx[j] - mn);
            mn = min(mn,Fmn[j]);
        }

        int x2 = sz * r;

        for(int j = x2;j <= xb;++j){
            mn = min(mn,F[j]);
            aux = max(aux,F[j] - mn);
        }

        ans += aux;
    }

    printf("%.8f\n",ans);

    return 0;
}


#include <cstdio>
#include <algorithm>

using namespace std;

#define MAXN 150000

double F[MAXN],P[MAXN];
double Fmn[18][MAXN],Fmx[18][MAXN],Fans[18][MAXN];
int x[MAXN],p[MAXN];

int main(){
    int n,m,C;

    scanf("%d %d %d",&n,&m,&C);

    for(int i = 0;i < n;++i) scanf("%d",&x[i]);
    for(int i = 1;i < n;++i) scanf("%d",&p[i]);

    P[0] = 0;
    for(int i = 1;i < n;++i)
        P[i] = P[i - 1] + p[i] / 100.0;

    for(int i = 0;i < n;++i)
        F[i] = x[i] / 2.0 - C * P[i];

    for(int i = 0;i < n;++i){
        Fmn[0][i] = F[i];
        Fmx[0][i] = F[i];
        Fans[0][i] = 0;
    }

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

        for(int j = 0;j < n;j += sz){
            Fmn[i][j] = F[j];
            Fmx[i][j] = F[j];
            Fans[i][j] = 0;

            for(int k = j;k < j + sz;++k){
                Fmn[i][j] = min(Fmn[i][j],F[k]);
                Fmx[i][j] = max(Fmx[i][j],F[k]);
                Fans[i][j] = max(Fans[i][j],F[k] - Fmn[i][j]);
            }
        }
    }

    double ans = 0;

    for(int i = 0,xa,xb;i < m;++i){
        scanf("%d %d",&xa,&xb);
        --xa; --xb;

        int len = xb - xa + 1;
        double aux = 0,mn = F[xa];

        while(xa <= xb){
            int lg = xa? __builtin_ctz(xa) : 31 - __builtin_clz(xb - xa + 1);
            while(xa + (1 << lg) - 1 > xb) --lg;

            aux = max(aux,Fans[lg][xa]);
            aux = max(aux,Fmx[lg][xa] - mn);
            mn = min(mn,Fmn[lg][xa]);

            xa += (1 << lg);
        }

        ans += aux;
    }

    printf("%.8f\n",ans);

    return 0;
}


#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;

double F[150000],P[150000];
double Fmn[150000],Fmx[150000],Fans[150000];
int p[150000];

int main(){
    int n,m,C;

    scanf("%d %d %d",&n,&m,&C);

    int x[n];

    for(int i = 0;i < n;++i) scanf("%d",&x[i]);
    for(int i = 1;i < n;++i) scanf("%d",&p[i]);

    P[0] = 0;
    for(int i = 1;i < n;++i)
        P[i] = P[i - 1] + p[i] / 100.0;

    for(int i = 0;i < n;++i)
        F[i] = x[i] / 2.0 - C * P[i];

    int sz = (int)floor(sqrt(n));

    for(int i = 0;sz*i < n;i++){
        Fmn[i] = F[sz*i];
        Fmx[i] = F[sz*i];
        Fans[i] = 0;
        double mn = F[sz*i];

        for(int j = 0;j < sz && sz*i + j  < n;++j){
            Fmn[i] = min(Fmn[i],F[sz*i + j]);
            Fmx[i] = max(Fmx[i],F[sz*i + j]);

            mn = min(mn,F[sz*i + j]);
            Fans[i] = max(Fans[i],F[sz*i + j] - mn);
        }
    }

    double ans = 0;

    for(int i = 0,xa,xb;i < m;++i){
        scanf("%d %d",&xa,&xb);
        --xa; --xb;

        double aux = 0;
        int l = (xa + sz - 1) / sz,r = xb / sz;

        if(l <= r){
            for(int j = l;j < r;++j)
                aux = max(aux,Fans[j]);

            int x1 = min(sz * l,xb);
            double mn = F[xa];

            for(int j = xa;j < x1;++j){
                mn = min(mn,F[j]);
                aux = max(aux,F[j] - mn);
            }

            for(int j = l;j < r;++j){
                aux = max(aux,Fmx[j] - mn);
                mn = min(mn,Fmn[j]);
            }

            int x2 = max(sz * r,xa);

            for(int j = x2;j <= xb;++j){
                mn = min(mn,F[j]);
                aux = max(aux,F[j] - mn);
            }
        }else{
            double mn = F[xa];

            for(int j = xa;j <= xb;++j){
                mn = min(mn,F[j]);
                aux = max(aux,F[j] - mn);
            }
        }

        ans += aux;
    }

    printf("%.8f\n",ans);

    return 0;
}


#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>
#include <set>

using namespace std;

double F[150000],P[150000];
int p[150000];

int main(){
    int n,m,C;

    scanf("%d %d %d",&n,&m,&C);

    int x[n];

    for(int i = 0;i < n;++i) scanf("%d",&x[i]);
    for(int i = 1;i < n;++i) scanf("%d",&p[i]);

    P[0] = 0;
    for(int i = 1;i < n;++i)
        P[i] = P[i - 1] + p[i] / 100.0;

    for(int i = 0;i < n;++i)
        F[i] = x[i] / 2.0 - C * P[i];

    double ans = 0;

    for(int i = 0,xa,xb;i < m;++i){
        scanf("%d %d",&xa,&xb);
        --xa; --xb;

        double aux = 0,mn = F[xa];

        for(int j = xa;j <= xb;++j){
            mn = min(mn,F[j]);
            aux = max(aux,F[j] - mn);
        }

        ans += aux;
    }

    printf("%.8f\n",ans);

    return 0;
}


#include <cstdio>
#include <algorithm>

using namespace std;

#define MAXN 150000

double F[MAXN],P[MAXN];
double Fmn[4 * MAXN + 1],Fmx[4 * MAXN + 1],Fans[4 * MAXN + 1];
int x[MAXN],p[MAXN];

void build(int node, int l, int r){
    if(l == r){
        Fmn[node] = Fmx[node] = F[l];
        Fans[node] = 0;
    }else{
        int mi = (l + r) >> 1;

        build((node << 1),l,mi);
        build((node << 1) ^ 1,mi + 1,r);

        Fmn[node] = min(Fmn[(node << 1)],Fmn[(node << 1) ^ 1]);
        Fmx[node] = max(Fmx[(node << 1)],Fmx[(node << 1) ^ 1]);
        Fans[node] = max(Fmx[(node << 1) ^ 1] - Fmn[(node << 1)],max(Fans[(node << 1)],Fans[(node << 1) ^ 1]));
    }
}

int QL[MAXN],sz;

void query(int node, int l, int r, int ql, int qr){
    if(r < ql || l > qr) return;

    if(ql <= l && r <= qr){
        QL[sz++] = node;
    }else{
        int mi = (l + r) >> 1;

        query((node << 1),l,mi,ql,qr);
        query((node << 1) ^ 1,mi + 1,r,ql,qr);
    }
}

int main(){
    int n,m,C;

    scanf("%d %d %d",&n,&m,&C);

    for(int i = 0;i < n;++i) scanf("%d",&x[i]);
    for(int i = 1;i < n;++i) scanf("%d",&p[i]);

    P[0] = 0;
    for(int i = 1;i < n;++i)
        P[i] = P[i - 1] + p[i] / 100.0;

    for(int i = 0;i < n;++i)
        F[i] = x[i] / 2.0 - C * P[i];

    build(1,0,n - 1);

    double ans = 0;

    for(int i = 0,xa,xb;i < m;++i){
        scanf("%d %d",&xa,&xb);
        --xa; --xb;

        double aux = 0,mn = F[xa];

        sz = 0;
        query(1,0,n - 1,xa,xb);

        for(int i = 0;i < sz;++i){
            aux = max(aux,Fans[ QL[i] ]);
            aux = max(aux,Fmx[ QL[i] ] - mn);
            mn = min(mn,Fmn[ QL[i] ]);
        }

        ans += aux;
    }

    printf("%.8f\n",ans);

    return 0;
}


#include <cstdio>
#include <algorithm>

using namespace std;

#define MAXN 150000

double F[MAXN],P[MAXN];
double Fmn[18][MAXN],Fmx[18][MAXN],Fans[18][MAXN];
int x[MAXN],p[MAXN];

int main(){
    int n,m,C;

    scanf("%d %d %d",&n,&m,&C);

    for(int i = 0;i < n;++i) scanf("%d",&x[i]);
    for(int i = 1;i < n;++i) scanf("%d",&p[i]);

    P[0] = 0;
    for(int i = 1;i < n;++i)
        P[i] = P[i - 1] + p[i] / 100.0;

    for(int i = 0;i < n;++i)
        F[i] = x[i] / 2.0 - C * P[i];

    for(int i = 0;i < n;++i){
        Fmn[0][i] = F[i];
        Fmx[0][i] = F[i];
        Fans[0][i] = 0;
    }

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

        for(int j = 0;j < n;j += sz){
            Fmn[i][j] = F[j];
            Fmx[i][j] = F[j];
            Fans[i][j] = 0;

            for(int k = j;k < j + sz && k < n;++k){
                Fmn[i][j] = min(Fmn[i][j],F[k]);
                Fmx[i][j] = max(Fmx[i][j],F[k]);
                Fans[i][j] = max(Fans[i][j],F[k] - Fmn[i][j]);
            }
        }
    }

    double ans = 0;

    for(int i = 0,xa,xb;i < m;++i){
        scanf("%d %d",&xa,&xb);
        --xa; --xb;

        int len = xb - xa + 1;
        double aux = 0,mn = F[xa];

        while(xa <= xb){
            int lg = xa? __builtin_ctz(xa) : 31 - __builtin_clz(xb - xa + 1);
            while(xa + (1 << lg) - 1 > xb) --lg;

            aux = max(aux,Fans[lg][xa]);
            aux = max(aux,Fmx[lg][xa] - mn);
            mn = min(mn,Fmn[lg][xa]);

            xa += (1 << lg);
        }

        ans += aux;
    }

    printf("%.8f\n",ans);

    return 0;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#define N 150005
using namespace std;

struct node{
	int x, y;
	double mn, mx, md;
};
struct ans{
	double mn, mx, md;
	ans(){}
	ans(double mn, double mx, double md):mn(mn), mx(mx), md(md){}
};

ans res;
node T[N*4];
int n, m, x, y, fine;
double ret;
double pos[N], prob[N], s[N], S[N];

void bd(int d, int x, int y){
	T[d].x = x, T[d].y = y;
	if (x != y){
		bd(d<<1, x, (x+y)/2);
		bd(1+(d<<1), (x+y)/2+1, y);
		T[d].mn = min(T[d<<1].mn, T[1+(d<<1)].mn);
		T[d].mx = max(T[d<<1].mx, T[1+(d<<1)].mx);
		T[d].md = max(T[1+(d<<1)].mx - T[d<<1].mn, max(T[d<<1].md, T[1+(d<<1)].md));
	}
	else T[d].mn = T[d].mx = T[d].md = S[x];
}

ans qry(int d, int x, int y){
	if (x <= T[d].x && y >= T[d].y){
		return ans(T[d].mn, T[d].mx, T[d].md);
	}

	if (y <= T[d<<1].y) return qry(d<<1, x, y);
	else if (x >= T[1+(d<<1)].x) return qry(1+(d<<1), x, y);
	else{
		ans l, r;
		l = qry(d<<1, x, y);
		r = qry(1+(d<<1), x, y);
		return ans(min(l.mn, r.mn), max(l.mx, r.mx), max(r.mx - l.mn, max(l.md, r.md)));
	}
}

int main(){
	scanf("%d%d%d", &n, &m, &fine);
	for (int i=1; i<=n; i++) scanf("%lf", &pos[i]);
	for (int i=2; i<=n; i++) scanf("%lf", &prob[i]), prob[i] /= 100.;

	S[1] = 0.;
	for (int i=2; i<=n; i++){
		S[i] = S[i-1] + pos[i] - pos[i-1] - prob[i] * fine * 2;
	}

	bd(1, 1, n);
	ret = 0.;
	while (m--){
		scanf("%d%d", &x, &y);
		res = qry(1, x, y);
		ret += res.md * .5;
	}
	printf("%.8f\n", ret + 1e-11);
	return 0;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#define N 150005
using namespace std;

struct node{
	int x, y;
	double mn, mx, md;
};
struct ans{
	double mn, mx, md;
	ans(){}
	ans(double mn, double mx, double md):mn(mn), mx(mx), md(md){}
};

ans res;
node T[N*4];
int n, m, x, y;
double fine, ret;
double pos[N], prob[N], s[N], S[N];

void bd(int d, int x, int y){
	T[d].x = x, T[d].y = y;
	if (x != y){
		bd(d<<1, x, (x+y)/2);
		bd(1+(d<<1), (x+y)/2+1, y);
		T[d].mn = min(T[d<<1].mn, T[1+(d<<1)].mn);
		T[d].mx = max(T[d<<1].mx, T[1+(d<<1)].mx);
		T[d].md = max(T[1+(d<<1)].mx - T[d<<1].mn, max(T[d<<1].md, T[1+(d<<1)].md));
	}
	else T[d].mn = T[d].mx = S[x], T[d].md = 0.;
}

ans qry(int d, int x, int y){
	if (x <= T[d].x && y >= T[d].y){
		return ans(T[d].mn, T[d].mx, T[d].md);
	}

	if (y <= T[d<<1].y) return qry(d<<1, x, y);
	else if (x >= T[1+(d<<1)].x) return qry(1+(d<<1), x, y);
	else{
		ans l, r;
		l = qry(d<<1, x, y);
		r = qry(1+(d<<1), x, y);
		return ans(min(l.mn, r.mn), max(l.mx, r.mx), max(r.mx - l.mn, max(l.md, r.md)));
	}
}

int main(){
	scanf("%d%d%lf", &n, &m, &fine);
	for (int i=1; i<=n; i++) scanf("%lf", &pos[i]);
	for (int i=2; i<=n; i++) scanf("%lf", &prob[i]), prob[i] /= 100.;

	S[1] = 0.;
	for (int i=2; i<=n; i++){
		S[i] = S[i-1] + pos[i] - pos[i-1] - prob[i] * fine * 2.;
	}

	bd(1, 1, n);
	ret = 0.;
	while (m--){
		scanf("%d%d", &x, &y);
		res = qry(1, x, y);
		if (res.md > 0) ret += res.md * .5;
	}
	printf("%.8f\n", ret + 1e-11);
	return 0;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#define N 150005
using namespace std;

struct node{
	int x, y;
	double mn, mx, md;
};
struct ans{
	double mn, mx, md;
	ans(){}
	ans(double mn, double mx, double md):mn(mn), mx(mx), md(md){}
};

ans res;
node T[N*4];
int n, m, x, y;
double fine, ret;
double pos[N], prob[N], s[N], S[N];

void bd(int d, int x, int y){
	T[d].x = x, T[d].y = y;
	if (x != y){
		bd(d<<1, x, (x+y)/2);
		bd(1+(d<<1), (x+y)/2+1, y);
		T[d].mn = min(T[d<<1].mn, T[1+(d<<1)].mn);
		T[d].mx = max(T[d<<1].mx, T[1+(d<<1)].mx);
		T[d].md = max(T[1+(d<<1)].mx - T[d<<1].mn, max(T[d<<1].md, T[1+(d<<1)].md));
	}
	else T[d].mn = T[d].mx = T[d].md = S[x];
}

ans qry(int d, int x, int y){
	if (x <= T[d].x && y >= T[d].y){
		return ans(T[d].mn, T[d].mx, T[d].md);
	}

	if (y <= T[d<<1].y) return qry(d<<1, x, y);
	else if (x >= T[1+(d<<1)].x) return qry(1+(d<<1), x, y);
	else{
		ans l, r;
		l = qry(d<<1, x, y);
		r = qry(1+(d<<1), x, y);
		return ans(min(l.mn, r.mn), max(l.mx, r.mx), max(r.mx - l.mn, max(l.md, r.md)));
	}
}

int main(){
	scanf("%d%d%lf", &n, &m, &fine);
	for (int i=1; i<=n; i++) scanf("%lf", &pos[i]);
	for (int i=2; i<=n; i++) scanf("%lf", &prob[i]), prob[i] /= 100.;

	S[1] = 0.;
	for (int i=2; i<=n; i++){
		S[i] = S[i-1] + pos[i] - pos[i-1] - prob[i] * fine * 2.;
	}

	bd(1, 1, n);
	ret = 0.;
	while (m--){
		scanf("%d%d", &x, &y);
		res = qry(1, x, y);
		if (res.md > 0) ret += res.md * .5;
	}
	printf("%.8f\n", ret + 1e-11);
	return 0;
}


#include <iostream>
#include <stdio.h>
#define LL(x) (x << 1)
#define RR(x) (x << 1 | 1)
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
#define N 150000

using namespace std;

struct TType
{
    double max, lmax, rmax;
};

double profit[N], s[N];
TType T[N >> 2];

inline void PushUP(int l, int r, int rt)
{
    int m = (l + r) >> 1;
    T[rt].max = max(T[LL(rt)].rmax + T[RR(rt)].lmax, max(T[LL(rt)].max, T[RR(rt)].max));
    T[rt].lmax = max(T[LL(rt)].lmax, s[m] - s[l - 1] + T[RR(rt)].lmax);
    T[rt].rmax = max(T[RR(rt)].rmax, T[LL(rt)].rmax + s[r] - s[m]);
}

void build(int l, int r, int rt)
{
    if (l == r) {
        T[rt].max = T[rt].lmax = T[rt].rmax = profit[l];
        return;
    }
    int m = (l + r) >> 1;
    build(lson);
    build(rson);
    PushUP(l, r, rt);
}

TType query(int L, int R, int l, int r, int rt)
{
    if (L <= l && r <= R) return T[rt];
    int m = (l + r) >> 1;
    if (R <= m) return query(L, R, lson);
    if (L > m) return query(L, R, rson);
    TType ans1, ans2, ans;
    ans1 = query(L, m, lson);
    ans2 = query(m + 1, R, rson);
    ans.max = max(ans1.rmax + ans2.lmax, max(ans1.max, ans2.max));
    ans.lmax = max(ans1.lmax, s[m] - s[L - 1] + ans2.lmax);
    ans.rmax = max(ans2.rmax, s[R] - s[m] + ans1.rmax);
    return ans;
}

int main()
{
    int n, m, cc, last, now;
    scanf("%d%d%d", &n, &m, &cc);
    scanf("%d", &last);
    for (int i = 1; i < n; i++) {
        scanf("%d", &now);
        profit[i] = (now - last) * 0.5;
        last = now;
    }
    int p;
    for (int i = 1; i < n; i++) {
        scanf("%d", &p);
        profit[i] -= cc * p / 100.0, s[i] = s[i - 1] + profit[i];
    }
    build(1, n - 1, 1);
    double ans = 0;
    for (int i = 0; i < m; i++) {
        int a, b;
        scanf("%d%d", &a, &b);
        TType temp = query(a, b - 1, 1, n - 1, 1);
        if (temp.max > 0) ans += temp.max;
    }
    printf("%.9lf\n", ans);
    return 0;
}


#include <iostream>
#include <stdio.h>
#define LL(x) (x << 1)
#define RR(x) (x << 1 | 1)
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
#define N 150000

using namespace std;

struct TType
{
    double max, lmax, rmax;
};

double profit[N], s[N];
TType T[524288];

inline void PushUP(int l, int r, int rt)
{
    int m = (l + r) >> 1;
    T[rt].max = max(T[LL(rt)].rmax + T[RR(rt)].lmax, max(T[LL(rt)].max, T[RR(rt)].max));
    T[rt].lmax = max(T[LL(rt)].lmax, s[m] - s[l - 1] + T[RR(rt)].lmax);
    T[rt].rmax = max(T[RR(rt)].rmax, T[LL(rt)].rmax + s[r] - s[m]);
}

void build(int l, int r, int rt)
{
    if (l == r) {
        T[rt].max = T[rt].lmax = T[rt].rmax = profit[l];
        return;
    }
    int m = (l + r) >> 1;
    build(lson);
    build(rson);
    PushUP(l, r, rt);
}

TType query(int L, int R, int l, int r, int rt)
{
    if (L <= l && r <= R) return T[rt];
    int m = (l + r) >> 1;
    if (R <= m) return query(L, R, lson);
    if (L > m) return query(L, R, rson);
    TType ans1, ans2, ans;
    ans1 = query(L, m, lson);
    ans2 = query(m + 1, R, rson);
    ans.max = max(ans1.rmax + ans2.lmax, max(ans1.max, ans2.max));
    ans.lmax = max(ans1.lmax, s[m] - s[L - 1] + ans2.lmax);
    ans.rmax = max(ans2.rmax, s[R] - s[m] + ans1.rmax);
    return ans;
}

int main()
{
    int n, m, cc, last, now;
    scanf("%d%d%d", &n, &m, &cc);
    scanf("%d", &last);
    for (int i = 1; i < n; i++) {
        scanf("%d", &now);
        profit[i] = (now - last) * 0.5;
        last = now;
    }
    int p;
    for (int i = 1; i < n; i++) {
        scanf("%d", &p);
        profit[i] -= cc * p / 100.0, s[i] = s[i - 1] + profit[i];
    }
    build(1, n - 1, 1);
    double ans = 0;
    for (int i = 0; i < m; i++) {
        int a, b;
        scanf("%d%d", &a, &b);
        TType temp = query(a, b - 1, 1, n - 1, 1);
        if (temp.max > 0) ans += temp.max;
    }
    printf("%.9lf\n", ans);
    return 0;
}


#include <iostream>
#include <stdio.h>
#define LL(x) (x << 1)
#define RR(x) (x << 1 | 1)
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
#define N 150000

using namespace std;

struct TType
{
    double max, lmax, rmax;
};

double profit[N], s[N];
TType T[N << 2];

inline void PushUP(int l, int r, int rt)
{
    int m = (l + r) >> 1;
    T[rt].max = max(T[LL(rt)].rmax + T[RR(rt)].lmax, max(T[LL(rt)].max, T[RR(rt)].max));
    T[rt].lmax = max(T[LL(rt)].lmax, s[m] - s[l - 1] + T[RR(rt)].lmax);
    T[rt].rmax = max(T[RR(rt)].rmax, T[LL(rt)].rmax + s[r] - s[m]);
}

void build(int l, int r, int rt)
{
    if (l == r) {
        T[rt].max = T[rt].lmax = T[rt].rmax = profit[l];
        return;
    }
    int m = (l + r) >> 1;
    build(lson);
    build(rson);
    PushUP(l, r, rt);
}

TType query(int L, int R, int l, int r, int rt)
{
    if (L <= l && r <= R) return T[rt];
    int m = (l + r) >> 1;
    if (R <= m) return query(L, R, lson);
    if (L > m) return query(L, R, rson);
    TType ans1, ans2, ans;
    ans1 = query(L, m, lson);
    ans2 = query(m + 1, R, rson);
    ans.max = max(ans1.rmax + ans2.lmax, max(ans1.max, ans2.max));
    ans.lmax = max(ans1.lmax, s[m] - s[L - 1] + ans2.lmax);
    ans.rmax = max(ans2.rmax, s[R] - s[m] + ans1.rmax);
    return ans;
}

int main()
{
    int n, m, cc, last, now;
    scanf("%d%d%d", &n, &m, &cc);
    scanf("%d", &last);
    for (int i = 1; i < n; i++) {
        scanf("%d", &now);
        profit[i] = (now - last) * 0.5;
        last = now;
    }
    int p;
    for (int i = 1; i < n; i++) {
        scanf("%d", &p);
        profit[i] -= cc * p / 100.0, s[i] = s[i - 1] + profit[i];
    }
    build(1, n - 1, 1);
    double ans = 0;
    for (int i = 0; i < m; i++) {
        int a, b;
        scanf("%d%d", &a, &b);
        TType temp = query(a, b - 1, 1, n - 1, 1);
        if (temp.max > 0) ans += temp.max;
    }
    printf("%.9lf\n", ans);
    return 0;
}


#include <iostream>
#include <stdio.h>
#define LL(x) (x << 1)
#define RR(x) (x << 1 | 1)
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
#define N 150000

using namespace std;

struct TType
{
    double max, lmax, rmax;
};

double profit[N], s[N];
TType T[N << 1];

inline void PushUP(int l, int r, int rt)
{
    int m = (l + r) >> 1;
    T[rt].max = max(T[LL(rt)].rmax + T[RR(rt)].lmax, max(T[LL(rt)].max, T[RR(rt)].max));
    T[rt].lmax = max(T[LL(rt)].lmax, s[m] - s[l - 1] + T[RR(rt)].lmax);
    T[rt].rmax = max(T[RR(rt)].rmax, T[LL(rt)].rmax + s[r] - s[m]);
}

void build(int l, int r, int rt)
{
    if (l == r) {
        T[rt].max = T[rt].lmax = T[rt].rmax = profit[l];
        return;
    }
    int m = (l + r) >> 1;
    build(lson);
    build(rson);
    PushUP(l, r, rt);
}

TType query(int L, int R, int l, int r, int rt)
{
    if (L <= l && r <= R) return T[rt];
    int m = (l + r) >> 1;
    if (R <= m) return query(L, R, lson);
    if (L > m) return query(L, R, rson);
    TType ans1, ans2, ans;
    ans1 = query(L, m, lson);
    ans2 = query(m + 1, R, rson);
    ans.max = max(ans1.rmax + ans2.lmax, max(ans1.max, ans2.max));
    ans.lmax = max(ans1.lmax, s[m] - s[L - 1] + ans2.lmax);
    ans.rmax = max(ans2.rmax, s[R] - s[m] + ans1.rmax);
    return ans;
}

int main()
{
    int n, m, cc, last, now;
    scanf("%d%d%d", &n, &m, &cc);
    scanf("%d", &last);
    for (int i = 1; i < n; i++) {
        scanf("%d", &now);
        profit[i] = (now - last) * 0.5;
        last = now;
    }
    int p;
    for (int i = 1; i < n; i++) {
        scanf("%d", &p);
        profit[i] -= cc * p / 100.0, s[i] = s[i - 1] + profit[i];
    }
    build(1, n - 1, 1);
    double ans = 0;
    for (int i = 0; i < m; i++) {
        int a, b;
        scanf("%d%d", &a, &b);
        TType temp = query(a, b - 1, 1, n - 1, 1);
        if (temp.max > 0) ans += temp.max;
    }
    printf("%.9lf\n", ans);
    return 0;
}


#include <iostream>
#include <stdio.h>
#define LL(x) (x << 1)
#define RR(x) (x << 1 | 1)
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
#define N 150000

using namespace std;

struct TType
{
    double max, lmax, rmax;
};

double profit[N], s[N];
TType T[N >> 2 + 1];

inline void PushUP(int l, int r, int rt)
{
    int m = (l + r) >> 1;
    T[rt].max = max(T[LL(rt)].rmax + T[RR(rt)].lmax, max(T[LL(rt)].max, T[RR(rt)].max));
    T[rt].lmax = max(T[LL(rt)].lmax, s[m] - s[l - 1] + T[RR(rt)].lmax);
    T[rt].rmax = max(T[RR(rt)].rmax, T[LL(rt)].rmax + s[r] - s[m]);
}

void build(int l, int r, int rt)
{
    if (l == r) {
        T[rt].max = T[rt].lmax = T[rt].rmax = profit[l];
        return;
    }
    int m = (l + r) >> 1;
    build(lson);
    build(rson);
    PushUP(l, r, rt);
}

TType query(int L, int R, int l, int r, int rt)
{
    if (L <= l && r <= R) return T[rt];
    int m = (l + r) >> 1;
    if (R <= m) return query(L, R, lson);
    if (L > m) return query(L, R, rson);
    TType ans1, ans2, ans;
    ans1 = query(L, m, lson);
    ans2 = query(m + 1, R, rson);
    ans.max = max(ans1.rmax + ans2.lmax, max(ans1.max, ans2.max));
    ans.lmax = max(ans1.lmax, s[m] - s[L - 1] + ans2.lmax);
    ans.rmax = max(ans2.rmax, s[R] - s[m] + ans1.rmax);
    return ans;
}

int main()
{
    int n, m, cc, last, now;
    scanf("%d%d%d", &n, &m, &cc);
    scanf("%d", &last);
    for (int i = 1; i < n; i++) {
        scanf("%d", &now);
        profit[i] = (now - last) * 0.5;
        last = now;
    }
    int p;
    for (int i = 1; i < n; i++) {
        scanf("%d", &p);
        profit[i] -= cc * p / 100.0, s[i] = s[i - 1] + profit[i];
    }
    build(1, n - 1, 1);
    double ans = 0;
    for (int i = 0; i < m; i++) {
        int a, b;
        scanf("%d%d", &a, &b);
        TType temp = query(a, b - 1, 1, n - 1, 1);
        if (temp.max > 0) ans += temp.max;
    }
    printf("%.9lf\n", ans);
    return 0;
}


#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <algorithm>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <cstdlib>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cassert>
#include <climits>
//#include <ext/hash_map>

using namespace std;
using namespace __gnu_cxx;

#define REP(i,n) for(int i = 0; i < int(n); ++i)
#define REPV(i, n) for (int i = (n) - 1; (int)i >= 0; --i)
#define FOR(i, a, b) for(int i = (int)(a); i < (int)(b); ++i)

#define FE(i,t) for (__typeof((t).begin())i=(t).begin();i!=(t).end();++i)
#define FEV(i,t) for (__typeof((t).rbegin())i=(t).rbegin();i!=(t).rend();++i)

#define two(x) (1LL << (x))
#define ALL(a) (a).begin(), (a).end()

#define pb push_back
#define ST first
#define ND second
#define MP(x,y) make_pair(x, y)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<string> vs;

template<class T> void checkmin(T &a, T b){if (b<a)a=b;}
template<class T> void checkmax(T &a, T b){if (b>a)a=b;}
template<class T> void out(T t[], int n){REP(i, n)cout<<t[i]<<" "; cout<<endl;}
template<class T> void out(vector<T> t, int n=-1){for (int i=0; i<(n==-1?t.size():n); ++i) cout<<t[i]<<" "; cout<<endl;}
inline int count_bit(int n){return (n==0)?0:1+count_bit(n&(n-1));}
inline int low_bit(int n){return (n^n-1)&n;}
inline int ctz(int n){return (n==0?-1:ctz(n>>1)+1);}
int toInt(string s){int a; istringstream(s)>>a; return a;}
string toStr(int a){ostringstream os; os<<a; return os.str();}

const int maxn=1<<20;
const int leaf=maxn>>1;
const double inf=1e10;
int n, m, c;
int px[maxn];
int x[maxn];

double tree[maxn][3];//io,i,o
double sum[maxn];
int T[maxn], H[maxn];

void init(int p, int a, int b){
    T[p]=a; H[p]=b;
    if (a+1==b){
        sum[p]=-2*c*px[a]/100.;
        tree[p][0]=max(0.,sum[p]+x[b]-x[a]);
        tree[p][1]=max(-x[a]+sum[p],-1.*x[b]);
        tree[p][2]=max(x[b]+sum[p],1.*x[a]);
        return;
    }
    int M=(a+b)/2;
    init(2*p,a,M);
    init(2*p+1,M,b);
    double *x=tree[2*p], *y=tree[2*p+1];
    double *u=tree[p];
    sum[p]=sum[2*p]+sum[2*p+1];
    u[1]=max(x[1]+sum[2*p+1], y[1]);
    u[2]=max(y[2]+sum[2*p], x[2]);
    u[0]=x[1]+y[2];
    checkmax(u[0],x[0]);
    checkmax(u[0],y[0]);
}
double querys(int p, int a, int b){
    if (a>=H[p]||b<=T[p]) return 0.;
    if (a<=T[p]&&b>=H[p]) return sum[p];
    return querys(2*p,a,b)+querys(2*p+1,a,b);

}

double query(int p, int a, int b, int cnd){
    if (a>=H[p]||b<=T[p]) return -inf;
    if (a<=T[p]&&b>=H[p]){
        return tree[p][cnd];
    }
    int u=2*p, v=u+1;
    double res;
    if (cnd==0){
        res=max(query(u,a,b,1)+query(v,a,b,2),max(query(u,a,b,0),query(v,a,b,0)));
    }
    else if (cnd==1) res=max(query(u,a,b,1)+querys(v,a,b),query(v,a,b,1));
    else{ res=max(query(v,a,b,2)+querys(u,a,b),query(u,a,b,2));
    }

    return res;

}

int main(){
    cin>>n>>m>>c;
    REP(i,n) scanf("%d", x+i);
    REP(i,n-1) scanf("%d", px+i);

    init(1,0,n-1);
    double res=0.;

    REP(step,m){
        int a, b; scanf("%d%d", &a,&b); --a; --b;
        double v=query(1,a,b,0)/2.;
        res+=v;
    }
    printf("%.10lf\n", res);
    return 0;
}


#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <algorithm>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <cstdlib>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cassert>
#include <climits>
//#include <ext/hash_map>

using namespace std;
using namespace __gnu_cxx;

#define REP(i,n) for(int i = 0; i < int(n); ++i)
#define REPV(i, n) for (int i = (n) - 1; (int)i >= 0; --i)
#define FOR(i, a, b) for(int i = (int)(a); i < (int)(b); ++i)

#define FE(i,t) for (__typeof((t).begin())i=(t).begin();i!=(t).end();++i)
#define FEV(i,t) for (__typeof((t).rbegin())i=(t).rbegin();i!=(t).rend();++i)

#define two(x) (1LL << (x))
#define ALL(a) (a).begin(), (a).end()

#define pb push_back
#define ST first
#define ND second
#define MP(x,y) make_pair(x, y)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<string> vs;

template<class T> void checkmin(T &a, T b){if (b<a)a=b;}
template<class T> void checkmax(T &a, T b){if (b>a)a=b;}
template<class T> void out(T t[], int n){REP(i, n)cout<<t[i]<<" "; cout<<endl;}
template<class T> void out(vector<T> t, int n=-1){for (int i=0; i<(n==-1?t.size():n); ++i) cout<<t[i]<<" "; cout<<endl;}
inline int count_bit(int n){return (n==0)?0:1+count_bit(n&(n-1));}
inline int low_bit(int n){return (n^n-1)&n;}
inline int ctz(int n){return (n==0?-1:ctz(n>>1)+1);}
int toInt(string s){int a; istringstream(s)>>a; return a;}
string toStr(int a){ostringstream os; os<<a; return os.str();}

const int maxn=1<<18;
const int leaf=1<<17;
const double inf=1e10;
int n, m, c;
int px[maxn];
int x[maxn];

double tree[maxn][3];//io,i,o
double sum[maxn];
int T[maxn], H[maxn];

void init(int p, int a, int b){
    T[p]=a; H[p]=b;
    if (a+1==b){
        sum[p]=-2*c*px[a]/100.;
        tree[p][0]=max(0.,sum[p]+x[b]-x[a]);
        tree[p][1]=max(-x[a]+sum[p],-1.*x[b]);
        tree[p][2]=max(x[b]+sum[p],1.*x[a]);
        return;
    }
    int M=(a+b)/2;
    init(2*p,a,M);
    init(2*p+1,M,b);
    double *x=tree[2*p], *y=tree[2*p+1];
    double *u=tree[p];
    sum[p]=sum[2*p]+sum[2*p+1];
    u[1]=max(x[1]+sum[2*p+1], y[1]);
    u[2]=max(y[2]+sum[2*p], x[2]);
    u[0]=x[1]+y[2];
    checkmax(u[0],x[0]);
    checkmax(u[0],y[0]);
}
double querys(int p, int a, int b){
    if (a>=H[p]||b<=T[p]) return 0.;
    if (a<=T[p]&&b>=H[p]) return sum[p];
    return querys(2*p,a,b)+querys(2*p+1,a,b);

}

double query(int p, int a, int b, int cnd){
    if (a>=H[p]||b<=T[p]) return -inf;
    if (a<=T[p]&&b>=H[p]){
        return tree[p][cnd];
    }
    int u=2*p, v=u+1;
    double res;
    if (cnd==0){
        res=max(query(u,a,b,1)+query(v,a,b,2),max(query(u,a,b,0),query(v,a,b,0)));
    }
    else if (cnd==1) res=max(query(u,a,b,1)+querys(v,a,b),query(v,a,b,1));
    else{ res=max(query(v,a,b,2)+querys(u,a,b),query(u,a,b,2));
    }

    return res;

}

int main(){
    cin>>n>>m>>c;
    REP(i,n) scanf("%d", x+i);
    REP(i,n-1) scanf("%d", px+i);

    init(1,0,n-1);
    double res=0.;

    REP(step,m){
        int a, b; scanf("%d%d", &a,&b); --a; --b;
        double v=query(1,a,b,0)/2.;
        res+=v;
    }
    printf("%.10lf\n", res);
    return 0;
}


#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <algorithm>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <cstdlib>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cassert>
#include <climits>
//#include <ext/hash_map>

using namespace std;
using namespace __gnu_cxx;

#define REP(i,n) for(int i = 0; i < int(n); ++i)
#define REPV(i, n) for (int i = (n) - 1; (int)i >= 0; --i)
#define FOR(i, a, b) for(int i = (int)(a); i < (int)(b); ++i)

#define FE(i,t) for (__typeof((t).begin())i=(t).begin();i!=(t).end();++i)
#define FEV(i,t) for (__typeof((t).rbegin())i=(t).rbegin();i!=(t).rend();++i)

#define two(x) (1LL << (x))
#define ALL(a) (a).begin(), (a).end()

#define pb push_back
#define ST first
#define ND second
#define MP(x,y) make_pair(x, y)

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<string> vs;

template<class T> void checkmin(T &a, T b){if (b<a)a=b;}
template<class T> void checkmax(T &a, T b){if (b>a)a=b;}
template<class T> void out(T t[], int n){REP(i, n)cout<<t[i]<<" "; cout<<endl;}
template<class T> void out(vector<T> t, int n=-1){for (int i=0; i<(n==-1?t.size():n); ++i) cout<<t[i]<<" "; cout<<endl;}
inline int count_bit(int n){return (n==0)?0:1+count_bit(n&(n-1));}
inline int low_bit(int n){return (n^n-1)&n;}
inline int ctz(int n){return (n==0?-1:ctz(n>>1)+1);}
int toInt(string s){int a; istringstream(s)>>a; return a;}
string toStr(int a){ostringstream os; os<<a; return os.str();}

const int maxn=1<<20;
const int leaf=maxn>>1;
const double inf=1e10;
int n, m, c;
int px[maxn];
int x[maxn];

double tree[maxn][3];//io,i,o
double sum[maxn];
int T[maxn], H[maxn];

void init(int p, int a, int b){
    T[p]=a; H[p]=b;
    if (a+1==b){
        double k=-2*c*px[a]/100.;
        tree[p][0]=max(0.,k+x[b]-x[a]);
        tree[p][1]=max(-x[a]+k,-1.*x[b]);
        tree[p][2]=max(x[b]+k,1.*x[a]);
        return;
    }
    int M=(a+b)/2;
    init(2*p,a,M);
    init(2*p+1,M,b);
    double *x=tree[2*p], *y=tree[2*p+1];
    double *u=tree[p];
    u[1]=max(x[1]+sum[b]-sum[M], y[1]);
    u[2]=max(y[2]+sum[M]-sum[a], x[2]);
    u[0]=x[1]+y[2];
    checkmax(u[0],x[0]);
    checkmax(u[0],y[0]);
}
double querys(int p, int a, int b){
    checkmax(a,T[p]);
    checkmin(b,H[p]);
    if (a>=b) return 0.;
    return sum[b]-sum[a];

}

double query(int p, int a, int b, int cnd){
    if (a>=H[p]||b<=T[p]) return -inf;
    if (a<=T[p]&&b>=H[p]){
        return tree[p][cnd];
    }
    int u=2*p, v=u+1;
    double res;
    if (cnd==0){
        res=max(query(u,a,b,1)+query(v,a,b,2),max(query(u,a,b,0),query(v,a,b,0)));
    }
    else if (cnd==1) res=max(query(u,a,b,1)+querys(v,a,b),query(v,a,b,1));
    else{ res=max(query(v,a,b,2)+querys(u,a,b),query(u,a,b,2)); }

    return res;

}

int main(){
    cin>>n>>m>>c;
    REP(i,n) scanf("%d", x+i);
    REP(i,n-1) scanf("%d", px+i);
    sum[0]=0.;
    REP(i,n-1) sum[i+1]=sum[i]-2*c*px[i]/100.;

    init(1,0,n-1);
    double res=0.;

    REP(step,m){
        int a, b; scanf("%d%d", &a,&b); --a; --b;
        double v=query(1,a,b,0)/2.;
        res+=v;
    }
    printf("%.10lf\n", res);
    return 0;
}


#include<iostream>
using namespace std;
#include<cstdio>
#include<cstdlib>
#define N 160000
#define inf 1000000000ll
#define rson mid+1,r,rt<<1|1
#define lson l,mid,rt<<1
int n,m;
long long p[N],x[N],c;
long long mx[N*4],lx[4*N],rx[N*4];
struct node{
    long long lx,mx,rx,s;
    node(){lx=rx=mx=-inf;s=0;}
    node(long long a,long long b,long long c,long long d):lx(a),rx(b),mx(c),s(d){}
};
void build(int l,int r,int rt)
{
    if(l<r){
        int mid=(l+r)/2;
        build(lson);
        build(rson);
        mx[rt]=max(rx[rt<<1]+lx[rt<<1|1],max(mx[rt<<1],mx[rt<<1|1]));
        lx[rt]=max(lx[rt<<1|1]-p[l-1]+p[mid],lx[rt<<1]);
        rx[rt]=max(rx[rt<<1]-p[mid]+p[r],rx[rt<<1|1]);
    }
    else
        mx[rt]=lx[rt]=rx[rt]=p[l]-p[l-1];
}
node query(int l,int r,int rt,int ll,int rr)
{
    //cout<<rt<<" "<<l<<" "<<r<<" "<<ll<<rr<<endl;
    //system("pause");
    if(ll<=l&&rr>=r)
        return node(lx[rt],rx[rt],mx[rt],p[r]-p[l-1]);
    int mid=(l+r)/2;
    node t1,t2,res;
    if(ll<=mid)
        t1=query(lson,ll,rr);
    if(rr>mid)
        t2=query(rson,ll,rr);
    res.lx=max(t1.lx,t2.lx+t1.s);
    res.rx=max(t2.rx,t1.rx+t2.s);
    res.s=p[r]-p[l-1];
    res.mx=max(t1.mx,t2.mx);
    res.mx=max(res.mx,t1.rx+t2.lx);
    return res;
}
int main()
{
    while(scanf("%d%d",&n,&m)!=-1)
    {
         double ans=0.0;
         int i,a,b;
         scanf("%I64d",&c);
         for(i=1;i<=n;i++){ scanf("%I64d",&x[i]); }
         x[0]=p[0]=0;
         for(i=1;i<n;i++){
             scanf("%I64d",&p[i]);
             p[i]=p[i-1]+(x[i+1]-x[i])*50-p[i]*c;
         }
         build(1,n-1,1);
         for(i=1;i<=m;i++) {
             scanf("%d%d",&a,&b);
             long long tm=query(1,n-1,1,a,b-1).mx;
             if(tm>0)
                ans+=tm;
         }
         printf("%.8lf\n",ans/100.0);
    }
}
/*
3 3 10
0 10 100
100 0
1 2
2 3
1 3
10 8 187
0 10 30 70 150 310 630 1270 2550 51100
13 87 65 0 100 44 67 3 4
1 10
2 9
3 8
1 5
6 10
2 7
4 10
4 5
*/


#include<iostream>
using namespace std;
#include<cstdio>
#define N 160000
#define rson mid+1,r,rt<<1|1
#define lson l,mid,rt<<1
int n,m;
long long p[N],x[N],c,t1,t2;
long long mx[N*4],lx[4*N],rx[N*4];
void build(int l,int r,int rt)
{
    if(l<r){
        int mid=(l+r)/2;
        build(lson);
        build(rson);
        mx[rt]=max(rx[rt<<1]+lx[rt<<1|1],max(mx[rt<<1],mx[rt<<1|1]));
        lx[rt]=max(lx[rt<<1|1]-p[l-1]+p[mid],lx[rt<<1]);
        rx[rt]=max(rx[rt<<1]-p[mid]+p[r],rx[rt<<1|1]);
    }
    else
        mx[rt]=lx[rt]=rx[rt]=p[l]-p[l-1];
}
long long query(int l,int r,int rt,int ll,int rr)
{
    if(ll<=l&&rr>=r)
        return mx[rt];
    int mid=(l+r)/2;
    if(ll>mid)
        return query(rson,ll,rr);
    else if(rr<=mid)
        return query(lson,ll,rr);
    else{
        long long t3,t4;
        t3=query(lson,ll,mid);
        t4=query(rson,mid+1,rr);
        t1=min(t4,lx[rt<<1|1]);
        t2=min(t3,rx[rt<<1]);
        return max(t1+t2,max(t3,t4));
    }

}
int main()
{
    while(scanf("%d%d",&n,&m)!=-1)
    {
         double ans=0.0;
         int i,a,b;
         scanf("%I64d",&c);
         for(i=1;i<=n;i++){ scanf("%I64d",&x[i]); }
         x[0]=p[0]=0;
         for(i=1;i<n;i++){
             scanf("%I64d",&p[i]);
             p[i]=p[i-1]+(x[i+1]-x[i])*50-p[i]*c;
         }
         /*for(i=1;i<n;i++){
             x[i]=p[i]-p[i-1];
             if(x[i]>0) x[i]+=x[i-1];
             else x[i]=x[i-1];
         }*/
         build(1,n-1,1);
         for(i=1;i<=m;i++) {
             scanf("%d%d",&a,&b);
             t1=t2=0;
             long long tm=query(1,n-1,1,a,b-1);
             if(tm>0)
                ans+=tm;
         }
         printf("%.8lf\n",ans/100.0);
    }
}
/*
3 3 10
0 10 100
100 0
1 2
2 3
1 3
10 8 187
0 10 30 70 150 310 630 1270 2550 51100
13 87 65 0 100 44 67 3 4
1 10
2 9
3 8
1 5
6 10
2 7
4 10
4 5
*/


#include<iostream>
using namespace std;
#include<cstdio>
#include<cstdlib>
#define N 160000
#define inf 1000000000000000000ll
#define rson mid+1,r,rt<<1|1
#define lson l,mid,rt<<1
int n,m;
long long p[N],x[N],c;
long long mx[N*4],lx[4*N],rx[N*4];
struct node{
    long long lx,mx,rx,s;
    node(){lx=rx=mx=-inf;s=0;}
    node(long long a,long long b,long long c,long long d):lx(a),rx(b),mx(c),s(d){}
};
void build(int l,int r,int rt)
{
    if(l<r){
        int mid=(l+r)/2;
        build(lson);
        build(rson);
        mx[rt]=max(rx[rt<<1]+lx[rt<<1|1],max(mx[rt<<1],mx[rt<<1|1]));
        lx[rt]=max(lx[rt<<1|1]-p[l-1]+p[mid],lx[rt<<1]);
        rx[rt]=max(rx[rt<<1]-p[mid]+p[r],rx[rt<<1|1]);
    }
    else
        mx[rt]=lx[rt]=rx[rt]=p[l]-p[l-1];
}
node query(int l,int r,int rt,int ll,int rr)
{
    //cout<<rt<<" "<<l<<" "<<r<<" "<<ll<<rr<<endl;
    //system("pause");
    if(ll<=l&&rr>=r)
        return node(lx[rt],rx[rt],mx[rt],p[r]-p[l-1]);
    int mid=(l+r)/2;
    node t1,t2,res;
    if(ll<=mid)
        t1=query(lson,ll,rr);
    if(rr>mid)
        t2=query(rson,ll,rr);
    res.lx=max(t1.lx,t2.lx+t1.s);
    res.rx=max(t2.rx,t1.rx+t2.s);
    res.s=p[r]-p[l-1];
    res.mx=max(t1.mx,t2.mx);
    res.mx=max(res.mx,t1.rx+t2.lx);
    return res;
}
int main()
{
    while(scanf("%d%d",&n,&m)!=-1)
    {
         double ans=0.0;
         int i,a,b;
         scanf("%I64d",&c);
         for(i=1;i<=n;i++){ scanf("%I64d",&x[i]); }
         x[0]=p[0]=0;
         for(i=1;i<n;i++){
             scanf("%I64d",&p[i]);
             p[i]=p[i-1]+(x[i+1]-x[i])*50-p[i]*c;
         }
         build(1,n-1,1);
         for(i=1;i<=m;i++) {
             scanf("%d%d",&a,&b);
             long long tm=query(1,n-1,1,a,b-1).mx;
             if(tm>0)
                ans+=tm;
         }
         printf("%.8lf\n",ans/100.0);
    }
}
/*
3 3 10
0 10 100
100 0
1 2
2 3
1 3
10 8 187
0 10 30 70 150 310 630 1270 2550 51100
13 87 65 0 100 44 67 3 4
1 10
2 9
3 8
1 5
6 10
2 7
4 10
4 5
*/


#include<iostream>
using namespace std;
#include<cstdio>
#define N 160000
#define rson mid+1,r,rt<<1|1
#define lson l,mid,rt<<1
int n,m;
long long p[N],x[N],c,t1,t2;
long long mx[N*4],lx[4*N],rx[N*4];
void build(int l,int r,int rt)
{
    if(l<r){
        int mid=(l+r)/2;
        build(lson);
        build(rson);
        mx[rt]=max(rx[rt<<1]+lx[rt<<1|1],max(mx[rt<<1],mx[rt<<1|1]));
        lx[rt]=max(lx[rt<<1|1]-p[l-1]+p[mid],lx[rt<<1]);
        rx[rt]=max(rx[rt<<1]-p[mid]+p[r],rx[rt<<1|1]);
    }
    else
        mx[rt]=lx[rt]=rx[rt]=p[l]-p[l-1];
}
long long query(int l,int r,int rt,int ll,int rr)
{
    if(ll<=l&&rr>=r)
        return mx[rt];
    int mid=(l+r)/2;
    if(ll>mid)
        return query(rson,ll,rr);
    else if(rr<=mid)
        return query(lson,ll,rr);
    else{
        long long t3,t4;
        t3=query(lson,ll,mid);
        t4=query(rson,mid+1,rr);
        t1=min(t4,lx[rt<<1|1]);
        t2=min(t3,rx[rt<<1]);
        return max(t1+t2,max(t3,t4));
    }
}
int main()
{
    while(scanf("%d%d",&n,&m)!=-1)
    {
         double ans=0.0;
         int i,a,b;
         scanf("%I64d",&c);
         for(i=1;i<=n;i++){ scanf("%I64d",&x[i]); }
         x[0]=p[0]=0;
         for(i=1;i<n;i++){
             scanf("%I64d",&p[i]);
             p[i]=p[i-1]+(x[i+1]-x[i])*50-p[i]*c;
         }
         /*for(i=1;i<n;i++){
             x[i]=p[i]-p[i-1];
             if(x[i]>0) x[i]+=x[i-1];
             else x[i]=x[i-1];
         }*/
         build(1,n-1,1);
         for(i=1;i<=m;i++) {
             scanf("%d%d",&a,&b);
             t1=t2=0;
             long long tm=query(1,n-1,1,a,b-1);
             //if(tm>0)
                ans+=tm;
         }
         printf("%.8lf\n",ans/100.0);
    }
}
/*
3 3 10
0 10 100
100 0
1 2
2 3
1 3
10 8 187
0 10 30 70 150 310 630 1270 2550 51100
13 87 65 0 100 44 67 3 4
1 10
2 9
3 8
1 5
6 10
2 7
4 10
4 5
*/


#include <bits/stdc++.h>
#define rep(x,n) for(int x = 0; x < n; ++x)
#define print(x) cout << x << endl
#define dbg(x) cerr << #x << " == " << x << endl
#define _ << " , " <<
#define mp make_pair
#define X first
#define Y second
using namespace std;

template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }

typedef long long ll;
typedef pair<int,int> pii;

const int maxn = 2e5 + 10;
int x[maxn], n;
int p[maxn];
int a[maxn], b[maxn], m;
int c;

const double inf = 1e55;

double _min(double x, double y) {
	return x <= y ? x : y;
}

double _max(double x, double y) {
	return x >= y ? x : y;
}

struct T {
	double suffix, prefix, all, best;
	T operator+(T t) const {
		if(t.all == -inf) return *this; else if(all == -inf) return t;
		T sum = { _max(suffix, all + t.suffix), _max(t.prefix, prefix + t.all), all + t.all, _max(_max(best,t.best), prefix + t.suffix) };
		return sum;
	}
} tree[4*maxn], nil = { -inf, -inf, -inf, -inf };

double r[maxn];

void bu(int no = 1, int ini = 1, int fim = n) {
	if(ini == fim)
		return tree[no] = (T) { r[ini], r[ini], r[ini], r[ini] }, void();
	int med = (ini + fim) / 2;
	bu(2*no, ini, med);
	bu(2*no+1, med+1, fim);
	tree[no] = tree[2*no] + tree[2*no+1];
}

T q(int i, int j, int no = 1, int ini = 1, int fim = n) {
	if(j < ini || fim < i)
		return nil;
	if(i <= ini && fim <= j)
		return tree[no];
	int med = (ini + fim) / 2;
	return q(i,j,2*no, ini, med) + q(i,j,2*no+1, med+1, fim);
}

int main() {
	scanf("%d%d%d",&n,&m,&c);
	rep(i,n)
		scanf("%d",x+i+1);
	rep(i,n-1)
		scanf("%d",p+i+1);
	rep(i,m)
		scanf("%d%d",a+i,b+i);
	for(int i = 1; i < n; i++)
		r[i] = ((x[i+1] - x[i]) / 2.0) - (p[i] * c) / 100.0;
	bu();
	double ans = 0;
	rep(i,m)
		ans += _max(0.0,q(a[i],b[i]-1).best);
	printf("%.6lf\n", ans );
	return 0;
}


#include <bits/stdc++.h>
#define rep(x,n) for(int x = 0; x < n; ++x)
#define print(x) cout << x << endl
#define dbg(x) cerr << #x << " == " << x << endl
#define _ << " , " <<
#define mp make_pair
#define X first
#define Y second
using namespace std;

template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }

typedef long long ll;
typedef pair<int,int> pii;

const int maxn = 2e5 + 10;
int x[maxn], n;
int p[maxn];
int a[maxn], b[maxn], m;
int c;

double _min(double x, double y) {
    return x <= y ? x : y;
}

double _max(double x, double y) {
    return x >= y ? x : y;
}

struct T {
    double suffix, prefix, all, best;
    T operator+(T t) const {
        T sum = { _max(suffix, all + t.suffix), _max(t.prefix, prefix + t.all), all + t.all, _max(_max(best,t.best), prefix + t.suffix) };
        return sum;
    }
} tree[4*maxn];

double r[maxn];

void bu(int no = 1, int ini = 1, int fim = n) {
    if(ini == fim)
        return tree[no] = (T) { _max(r[ini],0.0), _max(r[ini],0.0), r[ini], _max(r[ini],0.0) }, void();
    int med = (ini + fim) / 2;
    bu(2*no, ini, med);
    bu(2*no+1, med+1, fim);
    tree[no] = tree[2*no] + tree[2*no+1];
}

T q(int i, int j, int no = 1, int ini = 1, int fim = n) {
    if(i <= ini && fim <= j)
        return tree[no];
    assert(ini != fim);
    int med = (ini + fim) / 2;
    if(j <= med)
        return q(i,j,2*no, ini, med);
    else if(i > med)
        return q(i,j,2*no+1, med+1, fim);
    else
        return q(i,j,2*no, ini, med) + q(i,j,2*no+1, med+1, fim);
}

int main() {
    scanf("%d%d%d",&n,&m,&c);
    rep(i,n)
        scanf("%d",x+i+1);
    rep(i,n-1)
        scanf("%d",p+i+1);
    rep(i,m)
        scanf("%d%d",a+i,b+i);
    for(int i = 1; i < n; i++)
        r[i] = ((x[i+1] - x[i]) / 2.0) - ((p[i] * c) / 100.0);
    bu();
    double ans = 0;
    rep(i,m)
        ans += q(a[i],b[i]-1).best;
    printf("%.6lf\n", ans );
    return 0;
}
// -499910000000063480000000000000000000000000000000000000000000.000000


#include <bits/stdc++.h>
#define rep(x,n) for(int x = 0; x < n; ++x)
#define print(x) cout << x << endl
#define dbg(x) cerr << #x << " == " << x << endl
#define _ << " , " <<
#define mp make_pair
#define X first
#define Y second
using namespace std;

template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }

typedef long long ll;
typedef pair<int,int> pii;

const int maxn = 3e5 + 10;
int x[maxn], n;
int p[maxn];
int a[maxn], b[maxn], m;
int c;

double _min(double x, double y) {
	return x <= y ? x : y;
}

double _max(double x, double y) {
	return x >= y ? x : y;
}

struct T {
	double suffix, prefix, all, best;
	T operator+(T t) const {
		T sum = { _max(suffix, all + t.suffix), _max(t.prefix, prefix + t.all), all + t.all, _max(_max(best,t.best), prefix + t.suffix) };
		return sum;
	}
} tree[4*maxn];

double r[maxn];

void bu(int no = 1, int ini = 1, int fim = n) {
	if(ini == fim)
		return tree[no] = (T) { _max(r[ini],0.0), _max(r[ini],0.0), r[ini], _max(r[ini],0.0) }, void();
	int med = (ini + fim) / 2;
	bu(2*no, ini, med);
	bu(2*no+1, med+1, fim);
	tree[no] = tree[2*no] + tree[2*no+1];
}

T q(int i, int j, int no = 1, int ini = 1, int fim = n) {
	if(i <= ini && fim <= j)
		return tree[no];
	assert(ini != fim);
	int med = (ini + fim) / 2;
	if(j <= med)
		return q(i,j,2*no, ini, med);
	else if(i > med)
		return q(i,j,2*no+1, med+1, fim);
	else
		return q(i,j,2*no, ini, med) + q(i,j,2*no+1, med+1, fim);
}

int main() {
	scanf("%d%d%d",&n,&m,&c);
	rep(i,n)
		scanf("%d",x+i+1);
	rep(i,n-1)
		scanf("%d",p+i+1);
	rep(i,m)
		scanf("%d%d",a+i,b+i);
	for(int i = 1; i < n; i++)
		r[i] = ((x[i+1] - x[i]) / 2.0) - ((p[i] * c) / 100.0);
	bu();
	double ans = 0;
	rep(i,m)
		ans += q(a[i],b[i]-1).best;
	printf("%.6lf\n", ans );
	return 0;
}
// -499910000000063480000000000000000000000000000000000000000000.000000


#include <bits/stdc++.h>
#define rep(x,n) for(int x = 0; x < n; ++x)
#define print(x) cout << x << endl
#define dbg(x) cerr << #x << " == " << x << endl
#define _ << " , " <<
#define mp make_pair
#define X first
#define Y second
using namespace std;

template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }

typedef long long ll;
typedef pair<int,int> pii;

const int maxn = 2e5 + 10;
int x[maxn], n;
int p[maxn];
int a[maxn], b[maxn], m;
int c;

double _min(double x, double y) {
    return x <= y ? x : y;
}

double _max(double x, double y) {
    return x >= y ? x : y;
}

struct T {
    double suffix, prefix, all, best;
    T operator+(T t) const {
        T sum = { _max(suffix, all + t.suffix), _max(t.prefix, prefix + t.all), all + t.all, _max(_max(best,t.best), prefix + t.suffix) };
        return sum;
    }
} tree[4*maxn];

double r[maxn];

void bu(int no = 1, int ini = 1, int fim = n) {
    if(ini == fim)
        return tree[no] = (T) { _max(r[ini],0.0), _max(r[ini],0.0), r[ini], _max(r[ini],0.0) }, void();
    int med = (ini + fim) / 2;
    bu(2*no, ini, med);
    bu(2*no+1, med+1, fim);
    tree[no] = tree[2*no] + tree[2*no+1];
}

T q(int i, int j, int no = 1, int ini = 1, int fim = n) {
    if(i <= ini && fim <= j)
        return tree[no];
    assert(ini != j);
    int med = (ini + fim) / 2;
    if(j <= med)
        return q(i,j,2*no, ini, med);
    else if(i > med)
        return q(i,j,2*no+1, med+1, fim);
    else
        return q(i,j,2*no, ini, med) + q(i,j,2*no+1, med+1, fim);
}

int main() {
    scanf("%d%d%d",&n,&m,&c);
    rep(i,n)
        scanf("%d",x+i+1);
    rep(i,n-1)
        scanf("%d",p+i+1);
    rep(i,m)
        scanf("%d%d",a+i,b+i);
    for(int i = 1; i < n; i++)
        r[i] = ((x[i+1] - x[i]) / 2.0) - ((p[i] * c) / 100.0);
    bu();
    double ans = 0;
    rep(i,m)
        ans += q(a[i],b[i]-1).best;
    printf("%.6lf\n", ans );
    return 0;
}
// -499910000000063480000000000000000000000000000000000000000000.000000


#include <bits/stdc++.h>
#define rep(x,n) for(int x = 0; x < n; ++x)
#define print(x) cout << x << endl
#define dbg(x) cerr << #x << " == " << x << endl
#define _ << " , " <<
#define mp make_pair
#define X first
#define Y second
using namespace std;

template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }

typedef long long ll;
typedef pair<int,int> pii;

const int maxn = 2e5 + 10;
int x[maxn], n;
int p[maxn];
int a[maxn], b[maxn], m;
int c;

const double inf = 1e55;

double _min(double x, double y) {
	return x <= y ? x : y;
}

double _max(double x, double y) {
	return x >= y ? x : y;
}

struct T {
	double suffix, prefix, all, best;
	T operator+(T t) const {
		if(t.all == -inf) return *this; else if(all == -inf) return t;
		T sum = { _max(suffix, all + t.suffix), _max(t.prefix, prefix + t.all), all + t.all, _max(_max(best,t.best), prefix + t.suffix) };
		return sum;
	}
} tree[4*maxn], nil = { -inf, -inf, -inf, -inf };

double r[maxn];

void bu(int no = 1, int ini = 1, int fim = n) {
	if(ini == fim)
		return tree[no] = (T) { _max(r[ini],0.0), _max(r[ini],0.0), r[ini], _max(r[ini],0.0) }, void();
	int med = (ini + fim) / 2;
	bu(2*no, ini, med);
	bu(2*no+1, med+1, fim);
	tree[no] = tree[2*no] + tree[2*no+1];
}

T q(int i, int j, int no = 1, int ini = 1, int fim = n) {
	if(j < ini || fim < i)
		return nil;
	if(i <= ini && fim <= j)
		return tree[no];
	int med = (ini + fim) / 2;
	return q(i,j,2*no, ini, med) + q(i,j,2*no+1, med+1, fim);
}

int main() {
	scanf("%d%d%d",&n,&m,&c);
	rep(i,n)
		scanf("%d",x+i+1);
	rep(i,n-1)
		scanf("%d",p+i+1);
	rep(i,m)
		scanf("%d%d",a+i,b+i);
	for(int i = 1; i < n; i++)
		r[i] = (x[i+1] - x[i]) / 2.0 - (p[i] * c) / 100.0;
	bu();
	double ans = 0;
	rep(i,m)
		ans += q(a[i],b[i]-1).best;
	printf("%.6lf\n", ans );
	return 0;
}


#include <bits/stdc++.h>
#define rep(x,n) for(int x = 0; x < n; ++x)
#define print(x) cout << x << endl
#define dbg(x) cerr << #x << " == " << x << endl
#define _ << " , " <<
#define mp make_pair
#define X first
#define Y second
using namespace std;

template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }

typedef long long ll;
typedef pair<int,int> pii;

const int maxn = 2e5 + 10;
int x[maxn], n;
int p[maxn];
int a[maxn], b[maxn], m;
int c;

const double inf = 1e100;

double _min(double x, double y) {
    return x <= y ? x : y;
}

double _max(double x, double y) {
    return x >= y ? x : y;
}

struct T {
    double suffix, prefix, all, best;
    T operator+(T t) const {
        if(t.all == -inf) return *this; else if(all == -inf) return t;
        T sum = { _max(suffix, all + t.suffix), _max(t.prefix, prefix + t.all), all + t.all, _max(_max(best,t.best), prefix + t.suffix) };
        return sum;
    }
} tree[4*maxn], nil = { -inf, -inf, -inf, -inf };

double r[maxn];

void bu(int no = 1, int ini = 1, int fim = n) {
    if(ini == fim)
        return tree[no] = (T) { _max(r[ini],0.0), _max(r[ini],0.0), r[ini], _max(r[ini],0.0) }, void();
    int med = (ini + fim) / 2;
    bu(2*no, ini, med);
    bu(2*no+1, med+1, fim);
    tree[no] = tree[2*no] + tree[2*no+1];
}

T q(int i, int j, int no = 1, int ini = 1, int fim = n) {
    if(j < ini || fim < i)
        return nil;
    if(i <= ini && fim <= j)
        return tree[no];
    int med = (ini + fim) / 2;
    return q(i,j,2*no, ini, med) + q(i,j,2*no+1, med+1, fim);
}

int main() {
    scanf("%d%d%d",&n,&m,&c);
    rep(i,n)
        scanf("%d",x+i+1);
    rep(i,n-1)
        scanf("%d",p+i+1);
    rep(i,m)
        scanf("%d%d",a+i,b+i);
    for(int i = 1; i < n; i++)
        r[i] = ((x[i+1] - x[i]) / 2.0) - ((p[i] * c) / 100.0);
    bu();
    double ans = 0;
    rep(i,m)
        ans += q(a[i],b[i]-1).best;
    printf("%.6lf\n", ans );
    return 0;
}
// -499910000000063480000000000000000000000000000000000000000000.000000


#include <bits/stdc++.h>
#define rep(x,n) for(int x = 0; x < n; ++x)
#define print(x) cout << x << endl
#define dbg(x) cerr << #x << " == " << x << endl
#define _ << " , " <<
#define mp make_pair
#define X first
#define Y second
using namespace std;

template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }

typedef long long ll;
typedef pair<int,int> pii;

const int maxn = 2e5 + 10;
int x[maxn], n;
int p[maxn];
int a[maxn], b[maxn], m;
int c;

const double inf = 1 << 30;

double _min(double x, double y) {
    return x <= y ? x : y;
}

double _max(double x, double y) {
    return x >= y ? x : y;
}

struct T {
    double suffix, prefix, all, best;
    T operator+(T t) const {
        if(t.all == -inf) return *this; else if(all == -inf) return t;
        T sum = { _max(suffix, all + t.suffix), _max(t.prefix, prefix + t.all), all + t.all, _max(_max(best,t.best), prefix + t.suffix) };
        return sum;
    }
} tree[4*maxn], nil = { 0.0, 0.0, -inf, 0.0 };

double r[maxn];

void bu(int no = 1, int ini = 1, int fim = n) {
    if(ini == fim)
        return tree[no] = (T) { _max(r[ini],0.0), _max(r[ini],0.0), r[ini], _max(r[ini],0.0) }, void();
    int med = (ini + fim) / 2;
    bu(2*no, ini, med);
    bu(2*no+1, med+1, fim);
    tree[no] = tree[2*no] + tree[2*no+1];
}

T q(int i, int j, int no = 1, int ini = 1, int fim = n) {
    if(j < ini || fim < i)
        return nil;
    if(i <= ini && fim <= j)
        return tree[no];
    int med = (ini + fim) / 2;
    return q(i,j,2*no, ini, med) + q(i,j,2*no+1, med+1, fim);
}

int main() {
    scanf("%d%d%d",&n,&m,&c);
    rep(i,n)
        scanf("%d",x+i+1);
    rep(i,n-1)
        scanf("%d",p+i+1);
    rep(i,m)
        scanf("%d%d",a+i,b+i);
    for(int i = 1; i < n; i++)
        r[i] = ((x[i+1] - x[i]) / 2.0) - ((p[i] * c) / 100.0);
    bu();
    double ans = 0;
    rep(i,m)
        ans += q(a[i],b[i]-1).best;
    printf("%.9f\n", ans );
    return 0;
}
// -499910000000063480000000000000000000000000000000000000000000.000000


#include <bits/stdc++.h>
#define rep(x,n) for(int x = 0; x < n; ++x)
#define print(x) cout << x << endl
#define dbg(x) cerr << #x << " == " << x << endl
#define _ << " , " <<
#define mp make_pair
#define X first
#define Y second
using namespace std;

template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }

typedef long long ll;
typedef pair<int,int> pii;

const int maxn = 2e5 + 10;
int x[maxn], n;
int p[maxn];
int a[maxn], b[maxn], m;
int c;

const double inf = 1e55;

double _min(double x, double y) {
	return x <= y ? x : y;
}

double _max(double x, double y) {
	return x >= y ? x : y;
}

struct T {
	double suffix, prefix, all, best;
	T operator+(T t) const {
		if(t.all == -inf) return *this; else if(all == -inf) return t;
		T sum = { _max(suffix, all + t.suffix), _max(t.prefix, prefix + t.all), all + t.all, _max(_max(best,t.best), prefix + t.suffix) };
		return sum;
	}
} tree[4*maxn], nil = { -inf, -inf, -inf, -inf };

int tree2[4*maxn];

void inc(int i, int j, int no = 1, int ini = 1, int fim = n) {
	if(j < ini || fim < i)
		return;
	if(i <= ini && fim <= j) {
		tree2[no]++;
		return;
	}
	int med = (ini + fim) / 2;
	inc(i,j,2*no,ini,med);
	inc(i,j,2*no+1,med+1,fim);
}

int qsum(int i, int no = 1, int ini = 1, int fim = n) {
	if(i < ini || fim < i)
		return 0;
	int q = tree2[no];
	if(ini != fim) {
		int med = (ini + fim) / 2;
		q += qsum(i,2*no,ini,med);
		q += qsum(i,2*no+1,med+1,fim);
	}
	return q;
}

double r[maxn];

void bu(int no = 1, int ini = 1, int fim = n) {
	if(ini == fim)
		return tree[no] = (T) { r[ini], r[ini], r[ini], r[ini] }, void();
	int med = (ini + fim) / 2;
	bu(2*no, ini, med);
	bu(2*no+1, med+1, fim);
	tree[no] = tree[2*no] + tree[2*no+1];
}

T q(int i, int j, int no = 1, int ini = 1, int fim = n) {
	if(j < ini || fim < i)
		return nil;
	if(i <= ini && fim <= j)
		return tree[no];
	int med = (ini + fim) / 2;
	return q(i,j,2*no, ini, med) + q(i,j,2*no+1, med+1, fim);
}

int main() {
	scanf("%d%d%d",&n,&m,&c);
	rep(i,n)
		scanf("%d",x+i+1);
	rep(i,n-1)
		scanf("%d",p+i+1);
	rep(i,m)
		scanf("%d%d",a+i,b+i);

	rep(i,m)
		inc(a[i],b[i]-1);

	double w=0;

	for(int i = 1; i < n; i++) {
		r[i] = qsum(i) * ((x[i+1] - x[i]) / 2.0 - (p[i] * c) / 100.0);
		//dbg(i _ qsum(i) _ r[i] _ p[i]);
		if(r[i]>0)
		w+=r[i];
	}

	//dbg(w);

	bu();

	pv(r,r+n+1);

	printf("%.6lf\n", _max(0.0, q(1,n).best) );

	return 0;
}


#include <bits/stdc++.h>
#define rep(x,n) for(int x = 0; x < n; ++x)
#define print(x) cout << x << endl
#define dbg(x) cerr << #x << " == " << x << endl
#define _ << " , " <<
#define mp make_pair
#define X first
#define Y second
using namespace std;

template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }

typedef long long ll;
typedef pair<int,int> pii;

const int maxn = 2e5 + 10;
int x[maxn], n;
int p[maxn];
int a[maxn], b[maxn], m;
int c;

const double inf = 1e55;

double _min(double x, double y) {
	return x <= y ? x : y;
}

double _max(double x, double y) {
	return x >= y ? x : y;
}

struct T {
	double suffix, prefix, all, best;
	T operator+(T t) const {
		if(t.all == -inf) return *this; else if(all == -inf) return t;
		T sum = { _max(suffix, all + t.suffix), _max(t.prefix, prefix + t.all), all + t.all, _max(_max(best,t.best), prefix + t.suffix) };
		return sum;
	}
} tree[4*maxn], nil = { -inf, -inf, -inf, -inf };

double r[maxn];

void bu(int no = 1, int ini = 1, int fim = n) {
	if(ini == fim)
		return tree[no] = (T) { r[ini], r[ini], r[ini], r[ini] }, void();
	int med = (ini + fim) / 2;
	bu(2*no, ini, med);
	bu(2*no+1, med+1, fim);
	tree[no] = tree[2*no] + tree[2*no+1];
}

T q(int i, int j, int no = 1, int ini = 1, int fim = n) {
	if(j < ini || fim < i)
		return nil;
	if(i <= ini && fim <= j)
		return tree[no];
	int med = (ini + fim) / 2;
	return q(i,j,2*no, ini, med) + q(i,j,2*no+1, med+1, fim);
}

int main() {
	scanf("%d%d%d",&n,&m,&c);
	rep(i,n)
		scanf("%d",x+i+1);
	rep(i,n-1)
		scanf("%d",p+i+1);
	rep(i,m)
		scanf("%d%d",a+i,b+i);
	for(int i = 1; i < n; i++)
		r[i] = (x[i+1] - x[i]) / 2.0 - p[i] / 100.0 * c;
	bu();
	double ans = 0;
	rep(i,m)
		ans += _max(0.0,q(a[i],b[i]-1).best);
	printf("%.6lf\n", ans );
	return 0;
}


#include <bits/stdc++.h>
#define rep(x,n) for(int x = 0; x < n; ++x)
#define print(x) cout << x << endl
#define dbg(x) cerr << #x << " == " << x << endl
#define _ << " , " <<
#define mp make_pair
#define X first
#define Y second
using namespace std;

template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }

typedef long long ll;
typedef pair<int,int> pii;

const int maxn = 2e5 + 10;
int x[maxn], n;
int p[maxn];
int a[maxn], b[maxn], m;
int c;

const double inf = 1e55;

double _min(double x, double y) {
	return x <= y ? x : y;
}

double _max(double x, double y) {
	return x >= y ? x : y;
}

struct T {
	double suffix, prefix, all, best;
	T operator+(T t) const {
		if(t.all == -inf) return *this; else if(all == -inf) return t;
		T sum = { _max(suffix, all + t.suffix), _max(t.prefix, prefix + t.all), all + t.all, _max(_max(best,t.best), prefix + t.suffix) };
		return sum;
	}
} tree[4*maxn], nil = { -inf, -inf, -inf, -inf };

double r[maxn];

void bu(int no = 1, int ini = 1, int fim = n) {
	if(ini == fim)
		return tree[no] = (T) { r[ini], r[ini], r[ini], r[ini] }, void();
	int med = (ini + fim) / 2;
	bu(2*no, ini, med);
	bu(2*no+1, med+1, fim);
	tree[no] = tree[2*no] + tree[2*no+1];
}

T q(int i, int j, int no = 1, int ini = 1, int fim = n) {
	if(j < ini || fim < i)
		return nil;
	if(i <= ini && fim <= j)
		return tree[no];
	int med = (ini + fim) / 2;
	return q(i,j,2*no, ini, med) + q(i,j,2*no+1, med+1, fim);
}

int main() {
	scanf("%d%d%d",&n,&m,&c);
	rep(i,n)
		scanf("%d",x+i+1);
	rep(i,n-1)
		scanf("%d",p+i+1);
	rep(i,m)
		scanf("%d%d",a+i,b+i);
	for(int i = 1; i < n; i++)
		r[i] = (x[i+1] - x[i]) / 2.0 - (p[i] * c) / 100.0;
	bu();
	double ans = 0;
	rep(i,m)
		ans += q(a[i],b[i]-1).best;
	printf("%.6lf\n", ans );
	return 0;
}


#include <bits/stdc++.h>
#define rep(x,n) for(int x = 0; x < n; ++x)
#define print(x) cout << x << endl
#define dbg(x) cerr << #x << " == " << x << endl
#define _ << " , " <<
#define mp make_pair
#define X first
#define Y second
using namespace std;

template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }

typedef long long ll;
typedef pair<int,int> pii;

const int maxn = 2e5 + 10;
int x[maxn], n;
int p[maxn];
int a[maxn], b[maxn], m;
int c;

double _min(double x, double y) {
    return x <= y ? x : y;
}

double _max(double x, double y) {
    return x >= y ? x : y;
}

struct T {
    double suffix, prefix, all, best;
    T operator+(T t) const {
        T sum = { _max(suffix, all + t.suffix), _max(t.prefix, prefix + t.all), all + t.all, _max(_max(best,t.best), prefix + t.suffix) };
        return sum;
    }
} tree[4*maxn];

double r[maxn];

void bu(int no = 1, int ini = 1, int fim = n) {
    if(ini == fim)
        return tree[no] = (T) { _max(r[ini],0.0), _max(r[ini],0.0), r[ini], _max(r[ini],0.0) }, void();
    int med = (ini + fim) / 2;
    bu(2*no, ini, med);
    bu(2*no+1, med+1, fim);
    tree[no] = tree[2*no] + tree[2*no+1];
}

T q(int i, int j, int no = 1, int ini = 1, int fim = n) {
    if(i <= ini && fim <= j)
        return tree[no];
    int med = (ini + fim) / 2;
    if(j <= med)
        return q(i,j,2*no, ini, med);
    else if(i > med)
        return q(i,j,2*no+1, med+1, fim);
    else
        return q(i,j,2*no, ini, med) + q(i,j,2*no+1, med+1, fim);
}

int main() {
    scanf("%d%d%d",&n,&m,&c);
    rep(i,n)
        scanf("%d",x+i+1);
    rep(i,n-1)
        scanf("%d",p+i+1);
    rep(i,m)
        scanf("%d%d",a+i,b+i);
    for(int i = 1; i < n; i++)
        r[i] = ((x[i+1] - x[i]) / 2.0) - ((p[i] * c) / 100.0);
    bu();
    double ans = 0;
    rep(i,m)
        ans += q(a[i],b[i]-1).best;
    printf("%.6lf\n", ans );
    return 0;
}
// -499910000000063480000000000000000000000000000000000000000000.000000


#include <bits/stdc++.h>
#define rep(x,n) for(int x = 0; x < n; ++x)
#define print(x) cout << x << endl
#define dbg(x) cerr << #x << " == " << x << endl
#define _ << " , " <<
#define mp make_pair
#define X first
#define Y second
using namespace std;

template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }

typedef long long ll;
typedef pair<int,int> pii;

const int maxn = 2e5 + 10;
int x[maxn], n;
int p[maxn];
int a[maxn], b[maxn], m;
int c;

const double inf = 1e55;

double _min(double x, double y) {
    return x <= y ? x : y;
}

double _max(double x, double y) {
    return x >= y ? x : y;
}

struct T {
    double suffix, prefix, all, best;
    T operator+(T t) const {
        if(t.all == -inf) return *this; else if(all == -inf) return t;
        T sum = { _max(suffix, all + t.suffix), _max(t.prefix, prefix + t.all), all + t.all, _max(_max(best,t.best), prefix + t.suffix) };
        return sum;
    }
} tree[4*maxn], nil = { -inf, -inf, -inf, -inf };

double r[maxn];

void bu(int no = 1, int ini = 1, int fim = n) {
    if(ini == fim)
        return tree[no] = (T) { _max(r[ini],0.0), _max(r[ini],0.0), r[ini], _max(r[ini],0.0) }, void();
    int med = (ini + fim) / 2;
    bu(2*no, ini, med);
    bu(2*no+1, med+1, fim);
    tree[no] = tree[2*no] + tree[2*no+1];
}

T q(int i, int j, int no = 1, int ini = 1, int fim = n) {
    if(j < ini || fim < i)
        return nil;
    if(i <= ini && fim <= j)
        return tree[no];
    int med = (ini + fim) / 2;
    return q(i,j,2*no, ini, med) + q(i,j,2*no+1, med+1, fim);
}

int main() {
    scanf("%d%d%d",&n,&m,&c);
    rep(i,n)
        scanf("%d",x+i+1);
    rep(i,n-1)
        scanf("%d",p+i+1);
    rep(i,m)
        scanf("%d%d",a+i,b+i);
    for(int i = 1; i < n; i++)
        r[i] = (x[i+1] - x[i]) / 2.0 - (p[i] * c) / 100.0;
    bu();
    double ans = 0;
    rep(i,m)
        ans += q(a[i],b[i]-1).best;
    printf("%.9f\n", ans );
    return 0;
}


#include <bits/stdc++.h>
#define rep(x,n) for(int x = 0; x < n; ++x)
#define print(x) cout << x << endl
#define dbg(x) cerr << #x << " == " << x << endl
#define _ << " , " <<
#define mp make_pair
#define X first
#define Y second
using namespace std;

template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }

typedef long long ll;
typedef pair<int,int> pii;

const int maxn = 2e5 + 10;
int x[maxn], n;
int p[maxn];
int a[maxn], b[maxn], m;
int c;

const double inf = 1e55;

double _min(double x, double y) {
	return x <= y ? x : y;
}

double _max(double x, double y) {
	return x >= y ? x : y;
}

struct T {
	double suffix, prefix, all, best;
	T operator+(T t) const {
		if(t.all == -inf) return *this; else if(all == -inf) return t;
		T sum = { _max(suffix, all + t.suffix), _max(t.prefix, prefix + t.all), all + t.all, _max(_max(best,t.best), prefix + t.suffix) };
		return sum;
	}
} tree[4*maxn], nil = { -inf, -inf, -inf, -inf };

int tree2[4*maxn];

void inc(int i, int j, int no = 1, int ini = 1, int fim = n) {
	if(j < ini || fim < i)
		return;
	if(i <= ini && fim <= j) {
		tree2[no]++;
		return;
	}
	int med = (ini + fim) / 2;
	inc(i,j,2*no,ini,med);
	inc(i,j,2*no+1,med+1,fim);
}

int qsum(int i, int no = 1, int ini = 1, int fim = n) {
	if(i < ini || fim < i)
		return 0;
	int q = tree2[no];
	if(ini != fim) {
		int med = (ini + fim) / 2;
		q += qsum(i,2*no,ini,med);
		q += qsum(i,2*no+1,med+1,fim);
	}
	return q;
}

double r[maxn];

void bu(int no = 1, int ini = 1, int fim = n) {
	if(ini == fim)
		return tree[no] = (T) { r[ini], r[ini], r[ini], r[ini] }, void();
	int med = (ini + fim) / 2;
	bu(2*no, ini, med);
	bu(2*no+1, med+1, fim);
	tree[no] = tree[2*no] + tree[2*no+1];
}

T q(int i, int j, int no = 1, int ini = 1, int fim = n) {
	if(j < ini || fim < i)
		return nil;
	if(i <= ini && fim <= j)
		return tree[no];
	int med = (ini + fim) / 2;
	return q(i,j,2*no, ini, med) + q(i,j,2*no+1, med+1, fim);
}

int main() {
	scanf("%d%d%d",&n,&m,&c);
	rep(i,n)
		scanf("%d",x+i+1);
	rep(i,n-1)
		scanf("%d",p+i+1);
	rep(i,m)
		scanf("%d%d",a+i,b+i);

	rep(i,m)
		inc(a[i],b[i]-1);

	double w=0;

	for(int i = 1; i < n; i++) {
		r[i] = qsum(i) * ((x[i+1] - x[i]) / 2.0 - (p[i] * c) / 100.0);
		//dbg(i _ qsum(i) _ r[i] _ p[i]);
		if(r[i]>0)
		w+=r[i];
	}

	//dbg(w);

	bu();

	//pv(r,r+n+1);

	printf("%.6lf\n", _max(0.0, q(1,n).best) );

	return 0;
}


#include <bits/stdc++.h>
#define rep(x,n) for(int x = 0; x < n; ++x)
#define print(x) cout << x << endl
#define dbg(x) cerr << #x << " == " << x << endl
#define _ << " , " <<
#define mp make_pair
#define X first
#define Y second
using namespace std;

template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }

typedef long long ll;
typedef pair<int,int> pii;

const int maxn = 2e5 + 10;
int x[maxn], n;
int p[maxn];
int a[maxn], b[maxn], m;
int c;

const double inf = 1e55;

double _min(double x, double y) {
    return x <= y ? x : y;
}

double _max(double x, double y) {
    return x >= y ? x : y;
}

struct T {
    double suffix, prefix, all, best;
    T operator+(T t) const {
        if(t.all == -inf) return *this; else if(all == -inf) return t;
        T sum = { _max(suffix, all + t.suffix), _max(t.prefix, prefix + t.all), all + t.all, _max(_max(best,t.best), prefix + t.suffix) };
        return sum;
    }
} tree[4*maxn], nil = { -inf, -inf, -inf, 0 };

double r[maxn];

void bu(int no = 1, int ini = 1, int fim = n) {
    if(ini == fim)
        return tree[no] = (T) { _max(r[ini],0.0), _max(r[ini],0.0), r[ini], _max(r[ini],0.0) }, void();
    int med = (ini + fim) / 2;
    bu(2*no, ini, med);
    bu(2*no+1, med+1, fim);
    tree[no] = tree[2*no] + tree[2*no+1];
}

T q(int i, int j, int no = 1, int ini = 1, int fim = n) {
    if(j < ini || fim < i)
        return nil;
    if(i <= ini && fim <= j)
        return tree[no];
    int med = (ini + fim) / 2;
    return q(i,j,2*no, ini, med) + q(i,j,2*no+1, med+1, fim);
}

int main() {
    scanf("%d%d%d",&n,&m,&c);
    rep(i,n)
        scanf("%d",x+i+1);
    rep(i,n-1)
        scanf("%d",p+i+1);
    rep(i,m)
        scanf("%d%d",a+i,b+i);
    for(int i = 1; i < n; i++)
        r[i] = (x[i+1] - x[i]) / 2.0 - (p[i] * c) / 100.0;
    bu();
    double ans = 0;
    rep(i,m)
        ans += q(a[i],b[i]-1).best;
    printf("%.9f\n", ans );
    return 0;
}


#include <bits/stdc++.h>
#define rep(x,n) for(int x = 0; x < n; ++x)
#define print(x) cout << x << endl
#define dbg(x) cerr << #x << " == " << x << endl
#define _ << " , " <<
#define mp make_pair
#define X first
#define Y second
using namespace std;

template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }

typedef long long ll;
typedef pair<int,int> pii;

const int maxn = 2e5 + 10;
int x[maxn], n;
int p[maxn];
int a[maxn], b[maxn], m;
int c;

const double inf = 1e55;

double _min(double x, double y) {
	return x <= y ? x : y;
}

double _max(double x, double y) {
	return x >= y ? x : y;
}

struct T {
	double suffix, prefix, all, best;
	T operator+(T t) const {
		if(t.all == -inf) return *this; else if(all == -inf) return t;
		T sum = { _max(suffix, all + t.suffix), _max(t.prefix, prefix + t.all), all + t.all, _max(_max(best,t.best), prefix + t.suffix) };
		return sum;
	}
} tree[4*maxn], nil = { -inf, -inf, -inf, -inf };

double r[maxn];

void bu(int no = 1, int ini = 1, int fim = n) {
	if(ini == fim)
		return tree[no] = (T) { r[ini], r[ini], r[ini], r[ini] }, void();
	int med = (ini + fim) / 2;
	bu(2*no, ini, med);
	bu(2*no+1, med+1, fim);
	tree[no] = tree[2*no] + tree[2*no+1];
}

T q(int i, int j, int no = 1, int ini = 1, int fim = n) {
	if(j < ini || fim < i)
		return nil;
	if(i <= ini && fim <= j)
		return tree[no];
	int med = (ini + fim) / 2;
	return q(i,j,2*no, ini, med) + q(i,j,2*no+1, med+1, fim);
}

int main() {
	scanf("%d%d%d",&n,&m,&c);
	rep(i,n)
		scanf("%d",x+i+1);
	rep(i,n-1)
		scanf("%d",p+i+1);
	rep(i,m)
		scanf("%d%d",a+i,b+i);
	for(int i = 1; i < n; i++)
		r[i] = (x[i+1] - x[i]) / 2.0 - (p[i] * c) / 100.0;
	bu();
	double ans = 0;
	rep(i,m)
		ans += _max(0.0,q(a[i]-1,b[i]-1).best);
	printf("%.6lf\n", ans );
	return 0;
}


//program task_c

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>

using namespace std;

struct AnsType
{
  double Sum,LMax,RMax,Max;
};

double X[200000],P[200000],Data[200000];
int Left[600000],Right[600000],Mid[600000];
double Sum[600000],LMax[600000],RMax[600000],Max[600000];

void BuildTree(int P,int L,int R)
{
  Left[P]=L;Right[P]=R;Mid[P]=(L+R)/2;
  if(L==R)
    {
      Sum[P]=Data[L];
      LMax[P]=RMax[P]=Max[P]=max(Data[L],0.0);
    }
  else
    {
      BuildTree(P*2,L,Mid[P]);BuildTree(P*2+1,Mid[P]+1,R);
      Sum[P]=Sum[P*2]+Sum[P*2+1];
      LMax[P]=max(LMax[P*2],Sum[P*2]+LMax[P*2+1]);
      RMax[P]=max(RMax[P*2+1],Sum[P*2+1]+RMax[P*2]);
      Max[P]=max(max(Max[P*2],Max[P*2+1]),RMax[P*2]+LMax[P*2+1]);
    }
}

AnsType Query(int P,int L,int R)
{
  AnsType T;
  if(L==Left[P]&&R==Right[P]){T.Sum=Sum[P];T.LMax=LMax[P];T.RMax=RMax[P];T.Max=Max[P];return T;}
  if(R<=Mid[P])return Query(P*2,L,R);
  if(L>Mid[P])return Query(P*2+1,L,R);
  AnsType T1=Query(P*2,L,Mid[P]),T2=Query(P*2+1,Mid[P]+1,R);
  T.Sum=T1.Sum+T2.Sum;
  T.LMax=max(T1.LMax,T1.Sum+T2.LMax);
  T.RMax=max(T2.RMax,T2.Sum+T1.RMax);
  T.Max=max(max(T1.Max,T2.Max),T1.RMax+T2.LMax);
  return T;
}

int main()
{
  int N,M,C;cin>>N>>M>>C;N--;
  for(int i=0;i<=N;i++)scanf("%lf",&X[i]);
  for(int i=0;i<N;i++){scanf("%lf",&P[i]);P[i]/=100;}
  for(int i=0;i<N;i++){Data[i]=(X[i+1]-X[i])/2-P[i]*C;}
  BuildTree(1,0,N-1);double Ans=0;
  while(M--){int L,R;cin>>L>>R;Ans+=Query(1,L-1,R-2).Max;}
  printf("%0.10lf\n",Ans);
  return 0;
}


//program 150C

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>

using namespace std;

struct QueryType
{
  double Sum,LMax,RMax,Max;
};

double X[150000],Data[150000];
QueryType A[600000];

QueryType Update(QueryType X,QueryType Y)
{
  QueryType T;
  T.Sum=X.Sum+Y.Sum;
  T.LMax=max(X.LMax,X.Sum+Y.LMax);
  T.RMax=max(Y.RMax,Y.Sum+X.RMax);
  T.Max=max(max(X.Max,Y.Max),X.RMax+Y.LMax);
  return T;
}

void BuildTree(int P,int L,int R)
{
  if(L==R)
    A[P].LMax=A[P].RMax=A[P].Max=max(A[P].Sum=Data[L],0.0);
  else
    {
      int Mid=(L+R)/2;
      BuildTree(P*2,L,Mid);
      BuildTree(P*2+1,Mid+1,R);
      A[P]=Update(A[P*2],A[P*2+1]);
    }
}

QueryType Query(int P,int Left,int Right,int L,int R)
{
  if(Left==L&&Right==R)return A[P];
  int Mid=(Left+Right)/2;
  if(R<=Mid)return Query(P*2,Left,Mid,L,R);
  if(L>Mid)return Query(P*2+1,Mid+1,Right,L,R);
  return Update(Query(P*2,Left,Mid,L,Mid),Query(P*2+1,Mid+1,Right,Mid+1,R));
}

int main()
{
  int N,M;double C;cin>>N>>M>>C;N--;
  for(int i=0;i<=N;i++)cin>>X[i];
  for(int i=0;i<N;i++){double P;cin>>P;Data[i]=(X[i+1]-X[i])/2-P/100*C;}
  BuildTree(1,0,N-1);
  double Ans=0;
  while(M--){int L,R;cin>>L>>R;Ans+=Query(1,0,N-1,L-1,R-2).Max;}
  printf("%0.10lf\n",Ans);
  return 0;
}


//program task_c

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>

using namespace std;

struct AnsType
{
  double Sum,LMax,RMax,Max;
};

double X[200000],P[200000],Data[200000];
int Left[400000],Right[400000],Mid[400000];
double Sum[400000],LMax[400000],RMax[400000],Max[400000];

void BuildTree(int P,int L,int R)
{
  Left[P]=L;Right[P]=R;Mid[P]=(L+R)/2;
  if(L==R)
    {
      Sum[P]=Data[L];
      LMax[P]=RMax[P]=Max[P]=max(Data[L],0.0);
    }
  else
    {
      BuildTree(P*2,L,Mid[P]);BuildTree(P*2+1,Mid[P]+1,R);
      Sum[P]=Sum[P*2]+Sum[P*2+1];
      LMax[P]=max(LMax[P*2],Sum[P*2]+LMax[P*2+1]);
      RMax[P]=max(RMax[P*2+1],Sum[P*2+1]+RMax[P*2]);
      Max[P]=max(max(Max[P*2],Max[P*2+1]),RMax[P*2]+LMax[P*2+1]);
    }
}

AnsType Query(int P,int L,int R)
{
  AnsType T;
  if(L==Left[P]&&R==Right[P]){T.Sum=Sum[P];T.LMax=LMax[P];T.RMax=RMax[P];T.Max=Max[P];return T;}
  if(R<=Mid[P])return Query(P*2,L,R);
  if(L>Mid[P])return Query(P*2+1,L,R);
  AnsType T1=Query(P*2,L,Mid[P]),T2=Query(P*2+1,Mid[P]+1,R);
  T.Sum=T1.Sum+T2.Sum;
  T.LMax=max(T1.LMax,T1.Sum+T2.LMax);
  T.RMax=max(T2.RMax,T2.Sum+T1.RMax);
  T.Max=max(max(T1.Max,T2.Max),T1.RMax+T2.LMax);
  return T;
}

int main()
{
  int N,M,C;cin>>N>>M>>C;N--;
  for(int i=0;i<=N;i++)scanf("%lf",&X[i]);
  for(int i=0;i<N;i++){scanf("%lf",&P[i]);P[i]/=100;}
  for(int i=0;i<N;i++){Data[i]=(X[i+1]-X[i])/2-P[i]*C;}
  BuildTree(1,0,N-1);double Ans=0;
  while(M--){int L,R;cin>>L>>R;Ans+=Query(1,L-1,R-2).Max;}
  printf("%0.10lf\n",Ans);
  return 0;
}


#include<iostream>
#include<string.h>
#include<stdio.h>
#define la (2*N+1)
#define ra (2*N+3)
using namespace std;
double s[600000];
double lm[600000];
double rm[600000];
double mx[600000];
int a[600000];
double p[600000];
double ans;
int i,n,m,N,x,y,c;
void mg(int z,int x,int y)
{
	mx[z]=max(max(mx[x],mx[y]),rm[x]+lm[y]);
	lm[z]=max(lm[x],s[x]+lm[y]);
	rm[z]=max(rm[y],s[y]+rm[x]);
	s[z]=s[x]+s[y];
}
void clr(int x)
{
	lm[x]=rm[x]=mx[x]=s[x]=0;
}
double qy(int l,int r)
{
	clr(0);
	clr(la);
	clr(ra);
	for(l+=N-1,r+=N+1;l^r^1;l>>=1,r>>=1)
	{
		if(~l&1)
			mg(la,la,l^1);
		if(r&1)
			mg(ra,r^1,ra);
	}
	mg(0,la,ra);
	return mx[0];
}
int main()
{
	scanf("%d %d %d",&n,&m,&c);
	for(N=n;N!=(N&-N);N+=N&-N);
	for(i=N+1;i<=N+n;i++)
	{
		scanf("%d",&a[i]);
	}
	for(i=N+1;i<N+n;i++)
	{
		scanf("%lf",&p[i]);
		p[i]*=0.01;
		lm[i]=rm[i]=mx[i]=max(s[i]=(a[i+1]-a[i])*0.5-c*p[i],.0);
	}
	for(i=N-1;i>0;i--)
		mg(i,i*2,i*2+1);
	while(m--)
	{
		scanf("%d %d",&x,&y);
		y--;
		ans+=qy(x,y);
	}
	printf("%.10lf",ans);
	return 0;
}


       IDENTIFICATION DIVISION.
       PROGRAM-ID. Caesar-Cipher.

       DATA DIVISION.
       FILE SECTION.
       WORKING-STORAGE SECTION.
       01 plaintext PIC X(10) VALUE ZEROES.
       01 offset    PIC 99.
       01 i         PIC 9(3).
       01 len       PIC 9(2).
       PROCEDURE DIVISION.
       MAIN-PROCEDURE.

        ACCEPT plaintext
        ACCEPT offset

        INSPECT plaintext TALLYING len
          FOR CHARACTERS BEFORE INITIAL ' '

        PERFORM VARYING i FROM 1 BY 1 UNTIL i > len

         DISPLAY FUNCTION CHAR(FUNCTION MOD(FUNCTION
            ORD(plaintext (i:1))
            - 66 + FUNCTION NUMVAL(offset), 26) + 66) WITH NO ADVANCING

        END-PERFORM
        .

        STOP RUN.
       END PROGRAM Caesar-Cipher.


#include<stdio.h>
#include<algorithm>
using namespace std;
struct cyin{
    int lc,rc;
    long long c;
};
struct treeaa{
    int tl,tr;
    cyin cc;
}t[1000000];
int x[150010];
long long ans,d[150010],sum[150010];
int n,m,c;
void cal(int i){
    int sl,sr;
    sl=i*2;sr=i*2+1;
    t[i].cc.c=0;
    if (t[sl].cc.c>0&&t[i].cc.c<t[sl].cc.c){
        t[i].cc=t[sl].cc;
    }
    if (t[sr].cc.c>0&&t[i].cc.c<t[sr].cc.c){
        t[i].cc=t[sr].cc;
    }
    if (t[sl].cc.c>0&&t[sr].cc.c>0&&t[i].cc.c<sum[t[sr].cc.rc]-sum[t[sl].cc.lc-1]){
        t[i].cc.c=sum[t[sr].cc.rc]-sum[t[sl].cc.lc-1];
        t[i].cc.lc=t[sl].cc.lc;
        t[i].cc.rc=t[sr].cc.rc;
    }
}
void build_tree(int i,int l,int r){
    int mid=(l+r)/2;
    t[i].tl=l;
    t[i].tr=r;
    if (l==r){
        if (d[l]<0) t[i].cc.c=0;
        else{
            t[i].cc.c=d[l];
            t[i].cc.lc=l;
            t[i].cc.rc=r;
        }
        return;
    }else {
        build_tree(i*2,l,mid);
        build_tree(i*2+1,mid+1,r);
    }
    cal(i);
}
cyin check(int i,int l,int r){
  //  printf("%d %d %d\n",i,l,r);
    if (t[i].tl==l&&t[i].tr==r){
       // printf("%d %d %d\n",i,l,r);
        return t[i].cc;
    }
    int mid=(t[i].tl+t[i].tr)/2;
    if (r<=mid) return check(i*2,l,r);
    else if (l>mid) return check(i*2+1,l,r);
    else {
        cyin tt;
        cyin t1=check(i*2,l,mid);
        cyin t2=check(i*2+1,mid+1,r);
        tt.c=0;
        if (t1.c>0&&tt.c<t1.c) tt=t1;
        if (t2.c>0&&tt.c<t2.c) tt=t2;
        if (t1.c>0&&t2.c>0&&tt.c<sum[t2.rc]-sum[t1.lc-1]){
            tt.c=sum[t2.rc]-sum[t1.lc-1];
            tt.lc=t1.lc;
            tt.rc=t2.rc;
        }
        return tt;
    }
}

int main(){
   // freopen("c.in","r",stdin);
    int i,j,l,r;
    int p;
    scanf("%d%d%d",&n,&m,&c);
    for (i=0;i<n;i++) scanf("%d",&x[i]);
    sum[0]=0;
    for (i=0;i<n-1;i++){
        scanf("%d",&p);
        d[i+1]=(long long)(x[i+1]-x[i])*50-p*c;
       // printf("%.2lf ",d[i+1]);
        sum[i+1]=sum[i]+d[i+1];
    }
   // printf("\n");
    build_tree(1,1,n-1);
    ans=0;
    for (i=0;i<m;i++){
        scanf("%d%d",&l,&r);
        r--;
        ans+=check(1,l,r).c;
      //  printf("%.2lf %d %d\n",check(1,l,r).c,check(1,l,r).lc,check(1,l,r).rc);
       // printf("%lf\n",sum[r]-sum[l-1]-check(1,l,r).c);
    }
    printf("%lf\n",ans/100.0);
    return 0;
}


#include<stdio.h>
#include<algorithm>
using namespace std;
struct cyin{
    int lc,rc;
    long long c;
};
struct treeaa{
    int tl,tr;
    cyin cc;
}t[1000000];
int x[150010];
long long ans,d[150010],sum[150010];
int n,m,c;
void cal(int i){
    int sl,sr;
    sl=i*2;sr=i*2+1;
    t[i].cc.c=0;
    if (t[sl].cc.c>0&&t[i].cc.c<t[sl].cc.c){
        t[i].cc=t[sl].cc;
    }
    if (t[sr].cc.c>0&&t[i].cc.c<t[sr].cc.c){
        t[i].cc=t[sr].cc;
    }
    if (t[sl].cc.c>0&&t[sr].cc.c>0&&t[i].cc.c<sum[t[sr].cc.rc]-sum[t[sl].cc.lc-1]){
        t[i].cc.c=sum[t[sr].cc.rc]-sum[t[sl].cc.lc-1];
        t[i].cc.lc=t[sl].cc.lc;
        t[i].cc.rc=t[sr].cc.rc;
    }
}
void build_tree(int i,int l,int r){
    int mid=(l+r)/2;
    t[i].tl=l;
    t[i].tr=r;
    if (l==r){
        if (d[l]<=0) t[i].cc.c=0;
        else{
            t[i].cc.c=d[l];
            t[i].cc.lc=l;
            t[i].cc.rc=r;
        }
        return;
    }else {
        build_tree(i*2,l,mid);
        build_tree(i*2+1,mid+1,r);
    }
    cal(i);
}
cyin check(int i,int l,int r){
    if (t[i].tl==l&&t[i].tr==r) return t[i].cc;
    int mid=(t[i].tl+t[i].tr)/2;
    if (r<=mid) return check(i*2,l,r);
    else if (l>mid) return check(i*2+1,l,r);
    else {
        cyin tt;
        cyin t1=check(i*2,l,mid);
        cyin t2=check(i*2+1,mid+1,r);
        tt.c=0;
        if (t1.c>0&&tt.c<t1.c) tt=t1;
        if (t2.c>0&&tt.c<t2.c) tt=t2;
        if (t1.c>0&&t2.c>0&&tt.c<sum[t2.rc]-sum[t1.lc-1]){
            tt.c=sum[t2.rc]-sum[t1.lc-1];
            tt.lc=t1.lc;
            tt.rc=t2.rc;
        }
        return tt;
    }
}

int main(){
    int i,l,r;
    int p;
    scanf("%d%d%d",&n,&m,&c);
    for (i=0;i<n;i++) scanf("%d",&x[i]);
    sum[0]=0;
    for (i=0;i<n-1;i++){
        scanf("%d",&p);
        d[i+1]=(long long)(x[i+1]-x[i])*50-p*c;
        sum[i+1]=sum[i]+d[i+1];
    }
    build_tree(1,1,n-1);
    ans=0;
    for (i=0;i<m;i++){
        scanf("%d%d",&l,&r);
        r--;
        ans+=check(1,l,r).c;
    }
    printf("%lf\n",ans/100.0);
    return 0;
}