#include <bits/stdc++.h>
using namespace std;
// #define LD double
//每题的精度要求不同，在经过运算后能接受的误差eps也不同
//涉及到点的排序的时候理论上不应该比较eps
//点如果是输入的整点一般不会有问题，如果是算出来的，谨慎！！！
using LD = long double;
const LD eps=1e-14;
const LD epss=1e-7;
const LD PI=acos(-1.0);
int sgns(LD x){return (x>epss)-(x<-epss);}
int sgn(LD x){return (x>eps)-(x<-eps);}
LD sqr(LD x){return x*x;}

LD rad_to_deg(LD r){return r*180.0/PI;}
LD deg_to_rad(LD r){return r*PI/180.0;}

struct PT
{
    LD x,y;
    PT(){x=0;y=0;}
    PT(LD x,LD y):x(x),y(y){}
    PT operator -(const PT &a)const {return PT(x-a.x,y-a.y);}
    PT operator +(const PT &a)const {return PT(x+a.x,y+a.y);}

    PT operator *(const LD a)const {return PT(x*a,y*a);}
    friend PT operator *(const LD &a,const PT &b){return PT(a*b.x,a*b.y);}
    PT operator /(const LD a)const {return PT(x/a,y/a);}

    PT perp(){return PT(-y,x);}//逆时针90度
    LD arg(){return atan2(y,x); }//辐角(-pi,pi]
    LD norm(){return sqrt(x*x+y*y);}//模长 
    LD norm2(){return x*x+y*y;}//模长平方
    PT truncate(LD r)//长度变为r
    {
        LD k=norm();
        if(sgn(k)==0)return *this;
        r/=k;
        return PT(x*r,y*r);
    }
};
LD det(PT a,PT b){return a.x*b.y-a.y*b.x;}
LD dot(PT a,PT b){return a.x*b.x+a.y*b.y;}
LD Edis(PT a,PT b){return sqrt(sqr((a.x-b.x))+sqr((a.y-b.y)));}
LD Edis2(PT a,PT b){return sqr((a.x-b.x))+sqr((a.y-b.y));}
bool operator ==(PT a,PT b)
{
    return sgn(Edis2(a,b))==0;
}
int orientation(PT a, PT b, PT c) { return sgn(det(b-a,c-a));}
PT perp(PT a) { return PT(-a.y, a.x);}//逆时针90
PT perp3(PT a) { return PT(a.y, -a.x); }//顺时针90
PT rotatel(PT a, LD t) //逆时针
{
    return PT(a.x*cos(t)-a.y*sin(t),a.x*sin(t)+a.y*cos(t));
}
PT rotater(PT a, LD t) //顺时针
{
    return PT(a.x*cos(t)+a.y*sin(t),-a.x*sin(t)+a.y*cos(t));
}

const LD LS=-1.0;
const LD RS=1.0;
LD get_angle(PT a,PT b)//两向量夹角
{
    return acos(max(LS,min(RS,dot(a,b)/a.norm()/b.norm())));
}
PT midPT(PT a,PT b){return PT((a.x+b.x)/2.0,(a.y+b.y)/2.0);}//中点

LD S(PT a,PT b,PT c)//三角形面积
{
    return abs(det(a-b,a-c));
}
LD S(vector<PT>&a)//按逆时针顺序给出
{
    if(a.size()<3)return 0;
    LD ans=0;
    for(int i=0;i<a.size();i++)ans+=det(a[i],a[(i+1)%a.size()]);
    return ans;
}

bool turn_left(PT a,PT b,PT c)//ac 是不是 ab 左边
{
    return sgn(det(b-a,c-a))>0;
}
bool turn_left_2(PT a,PT b,PT c)
{
    return sgn(det(b-a,c-a))>=0;
}
bool turn_left(PT a,PT b)//向量b是不是在向量a左边
{
    return sgn(det(a,b))>0;
}

vector<PT>get_convex(vector<PT>a)//最好不要引用a，因为可能a的顺序有用
{
    if(a.size()<=2)return a;
    PT st=a[0];
    for(auto p:a)if(p.x<st.x||(p.x==st.x&&p.y<st.y))st=p;
    sort(a.begin(),a.end(),[&](PT u,PT v){
        int s=sgn(det(u-st,v-st));//1 为v在u左侧
        return s!=0?s>0:Edis(u,st)<Edis(v,st);//一条直线上的情况
    });
    vector<PT>ret;ret.clear();
    for(auto p:a)
    {
        for(;ret.size()>1&&!turn_left(ret[ret.size()-1]-ret[ret.size()-2],p-ret[ret.size()-2]);)ret.pop_back();
        ret.push_back(p);
    }
    return ret;
}

struct line//表示射线的时候a,b分别是起终
{
    PT s,t;
    line(){s=PT(0,0);t=PT(0,0);}
    line(PT s,PT t):s(s),t(t){}
};
//射线同或反方向
bool same_or_contro_dir(line l1,line l2)
{
    return sgn(det(l1.t-l1.s,l2.t-l2.s))==0;
}
//射线同方向
bool same_dir(line l1,line l2)
{
    return sgn(det(l1.t-l1.s,l2.t-l2.s))==0&&sgn(dot(l1.t-l1.s,l2.t-l2.s))>0;
}

//点在直线上
bool point_on_line(PT p,line l)
{
    return sgn(det(p-l.s,p-l.t))==0;
}
//点在线段上
bool point_on_segment(PT p,line l)
{
    return sgn(det(p-l.s,p-l.t))==0&&sgn(dot(p-l.s,p-l.t))<=0;
}
//两点在直线两端(不在直线上)
bool two_side(PT p1,PT p2,line l)
{
    return sgn(det(p1-l.s,l.t-l.s))*sgn(det(p2-l.s,l.t-l.s))<0;
}
//线段判交
bool segment_cross(line l1,line l2)
{
    if(point_on_segment(l1.s,l2)||point_on_segment(l1.t,l2)||point_on_segment(l2.s,l1)||point_on_segment(l2.t,l1))
    return true;
    return two_side(l1.s,l1.t,l2)&&two_side(l2.s,l2.t,l1);
}
//线段判交（不在端点）
bool segment_cross_2(line l1,line l2)
{
    return two_side(l1.s,l1.t,l2)&&two_side(l2.s,l2.t,l1);
}
//直线判交，0不交，1交 ,2重合
int line_cross(line l1,line l2)
{
    if(same_or_contro_dir(l1,l2))
    {
        if(point_on_line(l1.s,l2))return 2;
        return 0;
    }
    return 1;
}
//重合的情况要特殊考虑一下（比如特殊的线段和射线）
PT line_cross_PT(line l1,line l2)
{
    LD u=det(l1.t-l1.s,l2.s-l1.s);
    LD v=-det(l1.t-l1.s,l2.t-l1.s);
    return (l2.s*v+l2.t*u)/(u+v);
}

//射线判交，0不交，1交 ,2重合

PT ray_cross_tmp;
int ray_cross(line l1,line l2)
{
    int s=line_cross(l1,l2);
    if(s==0)return s;
    if(s==2)
    {
        if(sgn(dot(l1.s-l2.s,l2.t-l2.s))<0&&sgn(dot(l2.s-l1.s,l1.t-l1.s))<0)
        return 0;
        return 2;
    }
    ray_cross_tmp=line_cross_PT(l1,l2);
    //在两条射线方向上
    return sgn(dot(ray_cross_tmp-l1.s,l1.t-l1.s))>=0&&sgn(dot(ray_cross_tmp-l2.s,l2.t-l2.s))>=0;
}


//下面是对于凸包的问题
vector<PT>a;
//切线
int search(auto f)
{
    int l=0,r=(int)a.size();
    if(f(a[0],a.back()))
    {
        while(l+1<r)
        {
            int mid=l+r>>1;
            if(f(a[mid],a[l])&&f(a[mid],a[mid-1]))l=mid;
            else r=mid;
        }
        return l;
    }
    else 
    {
        while(l+1<r)
        {
            int mid=l+r>>1;
            if(f(a[mid],a[r])&&f(a[mid],a[mid+1]))r=mid;
            else l=mid;
        }
        return r;
    }
}
vector<PT> get_tan(PT u)
{
    return {a[search([&](auto x,auto y){return turn_left(u,y,x);})],
            a[search([&](auto x,auto y){return turn_left(u,x,y);})]};
}

//切凸包
vector<PT> cut(const vector<PT> &c,line l)
{
    vector<PT> ret;
    for(int i=0;i<(int)c.size();i++)
    {
        int j=(i+1)%(int)c.size();
        if(turn_left_2(l.s,l.t,c[i]))
            ret.push_back(c[i]);
        if(two_side(c[i],c[j],l))
            ret.push_back(line_cross_PT(l,{c[i],c[j]}));
    }
    return ret;
}

int half(PT a){return a.y>0||(a.y==0&&a.x>0)?1:0;}
bool turn_left(line a,line b,line c){return turn_left(a.s,a.t,line_cross_PT(b,c));}
bool is_para(line a,line b){return !sgn(det(a.t-a.s,b.t-b.s));}
bool cmp(line a,line b)
{
    int sign=half(a.t-a.s)-half(b.t-b.s);
    int dir=sgn(det(a.t-a.s,b.t-b.s));
    if(!dir&&!sign)return sgn(det(a.t-a.s,b.t-b.s))<0;
    else return sign?sign>0:dir>0;
}
vector<PT>hpi(vector<line>h)
{
    sort(h.begin(),h.end(),cmp);
    vector<line> q(h.size());
    int l=0,r=-1;
    for(auto &i:h)
    {
        while(l<r&&!turn_left(i,q[r-1],q[r]))r--;
        while(l<r&&!turn_left(i,q[l],q[l+1]))l++;
        if(l<=r&&is_para(i,q[r]))continue;
        q[++r]=i;
    }
    while(r-l>1&&!turn_left(q[l],q[r-1],q[r]))r--;
    while(r-l>1&&!turn_left(q[r],q[l],q[l+1]))l++;
    if(r-l<2)return {};
    vector<PT>ret(r-l+1);
    for(int i=l;i<=r;i++)ret[i-l]=line_cross_PT(q[i],q[i==r?l:i+1]);
    return ret;
}


const int N=1e2+3;
int dx,dy;
int n;
PT b[N];
int p[N];
int main()
{
    scanf("%d%d%d",&dx,&dy,&n);
    for(int i=1;i<=n;i++)
    {
        int x,y;scanf("%d%d",&x,&y);
        b[i]=PT(x,y);
    }
    for(int i=1;i<=n;i++)scanf("%d",&p[i]);

    a.clear();
    a.push_back(PT(0,0));
    a.push_back(PT(dx,0));
    a.push_back(PT(dx,dy));
    a.push_back(PT(0,dy));
    for(int i=1;i<n;i++)for(int j=i+1;j<=n;j++)
    {
        a=cut(a,line(b[p[j]],b[p[i]]));
        // printf("i:%d %d\n",i,a.size());
    }

    LD ans=0;
    for(int i=1;i<int(a.size())-1;i++)ans+=S(a[0],a[i],a[i+1]);
    printf("%.12Lf\n",ans/2);
    return 0;
}