#include<bits/stdc++.h>
using namespace std;

#define int long long

using tii=tuple<int,int,int>;

const int N=511,M=998244353;

int qpow(int a,int b)
{
    int ret=1;
    while(b)
    {
        if(b&1)
            ret=1ll*ret*a%M;
        b>>=1;
        a=1ll*a*a%M;
    }
    return ret;
}

int n,m,S;

int f[N][5],val[N][4];

struct P{
    int x,y;
}a[N],b[N];

P operator +(const P &a,const P &b)
{
    return {a.x+b.x,a.y+b.y};
}

P operator -(const P &a,const P &b)
{
    return {a.x-b.x,a.y-b.y};
}

int operator *(const P &a,const P &b)
{
    return a.x*b.y-a.y*b.x;
}

int sgn(const P &a)
{
    if(a.x!=0)
        return a.x>0?-1:1;
    return a.y>0?-1:1;
}

bool operator <(const P &a,const P &b)
{
    if(sgn(a)!=sgn(b))
        return sgn(a)<sgn(b);
    return a*b>0;
}

vector<tii>E;

int ty(const P &a)
{
    if(a.x>0)
        return 1;
    if(a.x<0)
        return 3;
    if(a.y>0)
        return 2;
    return 4;
}

signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>n>>m>>S;
    S=S*qpow(100,M-2)%M;
    for(int i=1;i<=n;i++)
        cin>>a[i].x>>a[i].y;
    for(int i=1;i<=m;i++)
        cin>>b[i].x>>b[i].y;
    sort(b+1,b+m+1,[&](const P &a,const P &b){
        return a.x<b.x||(a.x==b.x&&a.y<b.y);
    });
    for(int i=1;i<=m;i++)
        for(int j=1;j<=m;j++)
        {
            if(i==j)
                continue;
            P v=b[j]-b[i];
            bool ok=1;
            for(int k=1;k<=n;k++)
            {
                if(v*(a[k]-b[i])<0)
                    ok=0;
            }
            if(!ok)
                continue;
            int p=1;
            int lx=b[i].x,rx=b[j].x;
            if(lx<=rx)
                rx--;
            else
                rx++,swap(lx,rx);
            if(b[i].x!=b[j].x)
            {
                for(int k=1;k<=m;k++)
                {
                    if(k==i||k==j)
                        continue;
                    if(b[k].x<lx||b[k].x>rx)
                        continue;
                    if(v*(b[k]-b[i])>0)
                        continue;
                    p=p*(M+1-S)%M;
                }
            }
            else
            {
                int ly=b[i].x,ry=b[j].x;
                if(ry<=ry)
                    ry--;
                else
                    ry++,swap(ly,ry);
                for(int k=1;k<=m;k++)
                {
                    if(k==i||k==j)
                        continue;
                    if(b[k].y<ly||b[k].y>ry)
                        continue;
                    if(v*(b[k]-b[i])>0)
                        continue;
                    p=p*(M+1-S)%M;
                }

            }
            E.push_back({i,j,p});
        }
    sort(E.begin(),E.end(), [&](const tii &x,const tii &y) {
        auto [ai,aj,ap]=x;
        auto [bi,bj,bp]=y;
        auto da=b[aj]-b[ai],db=b[bj]-b[bi];
        if(da<db||db<da)
            return da<db;
        if(sgn(da)<0)
            return ai<bi;
        else
            return ai>bi;
    });
    for(int i=1;i<=m;i++)
    {
        for(int j=0;j<5;j++)
            val[i][j]=1;
        for(int j=1;j<=m;j++)
        {
            if(b[j].x<b[i].x&&b[j].y<=b[i].y)
                val[i][0]=(val[i][0]*(M+1-S))%M;
            if(b[j].x>=b[i].x&&b[j].y<b[i].y)
                val[i][1]=(val[i][1]*(M+1-S))%M;
            if(b[j].x>b[i].x&&b[j].y>=b[i].y)
                val[i][2]=(val[i][2]*(M+1-S))%M;
            if(b[j].x<=b[i].x&&b[j].y>b[i].y)
                val[i][3]=(val[i][3]*(M+1-S))%M;
        }
    }
    int ans=0;
    for(int i=1;i<=m;i++)
    {
        for(int t=0;t<5;t++)
            for(int j=1;j<=m;j++)
                f[j][t]=(t==0&&j==i);
        // cerr<<endl;
        for(auto [u,v,p]:E)
        {
            if(u<i||v<i)
                continue;
            int r=ty(b[v]-b[u]);
            // cerr<<r<<endl;
            for(int k=0;k<=r;k++)
            {
                int coe=1;
                for(int t=k;t<r;t++)
                    coe=coe*val[u][t]%M;
                f[v][r]=(f[v][r]+f[u][k]*coe%M*p%M*S)%M;
            }
            // f[v]=(f[v]+f[u]*p%M*S)%M;
            // f[v]=(f[v]+f[u]%M)%M;
        }
        // cerr<<b[i].x<<" "<<b[i].y<<" "<<f[i]<<endl;
        for(int j=3;j<5;j++)
            ans=(ans+f[i][j])%M;
    }
    cout<<ans<<endl;
}