#include<iostream>

#include<cstdio>

#include<cstring>

#include<vector>

#include<queue>

using namespace std;

const int maxn=;

const int oo=;

int n,m,c;

int ans=;

int g[][];

int gf[][];

int a[maxn],b[maxn];

struct Edge{

    int from,to,cap,flow;

};

vector<int>G[maxn];

vector<Edge>edges;

void Addedge(int x,int y,int z){

    Edge e;

    e.from=x;e.to=y;e.cap=z;e.flow=;

    edges.push_back(e);

    e.from=y;e.to=x;e.cap=;e.flow=;

    edges.push_back(e);

    int cc=edges.size();

    G[x].push_back(cc-);

    G[y].push_back(cc-);

}

int s,t;

int vis[maxn];

int d[maxn];

queue<int>q;

int Bfs(){

    memset(vis,,sizeof(vis));

    vis[s]=;d[s]=;q.push(s);

    while(!q.empty()){

        int x=q.front();q.pop();

        for(int i=;i<G[x].size();++i){

            Edge e=edges[G[x][i]];

            if((!vis[e.to])&&(e.cap>e.flow)){

                d[e.to]=d[x]+;

                vis[e.to]=;

                q.push(e.to);

            }

        }

    }

    return vis[t];

}

int cur[maxn];

int Dfs(int x,int a){

    if((x==t)||(a==))return a;

    int nowflow=,f=;

    for(int i=cur[x];i<G[x].size();++i){

        cur[x]=i;

        Edge e=edges[G[x][i]];

        if((d[x]+==d[e.to])&&((f=Dfs(e.to,min(a,e.cap-e.flow)))>)){

            nowflow+=f;

            a-=f;

            edges[G[x][i]].flow+=f;

            edges[G[x][i]^].flow-=f;

            if(a==)break;

        }

    }

    return nowflow;

}

int Maxflow(){

    int flow=;

    while(Bfs()){

        memset(cur,,sizeof(cur));

        flow+=Dfs(s,oo);

    }

    return flow;

}

void Dinicinit(){

}

int Getsize(int x){

    int ret=;

    while(x){

        ++ret;

        x^=(x&(-x));

    }

    return ret;

}

int main(){

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

    for(int i=;i<=n;++i)scanf("%d",&a[i]);

    for(int i=;i<=m;++i)scanf("%d",&b[i]);

    while(c--){

        int x,y;

        scanf("%d%d",&x,&y);

        g[x][y]=;

    }

    for(int i=;i<=m;++i){

        for(int j=;j<=m;++j){

            if(i==j)continue;

            if(Getsize(b[i]|b[j])%)g[i][j]=;

        }

    }

    s=n+m+;t=s+;

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

        for(int j=i;j<=n;++j){

            if(!((a[i]^a[j])&))continue;

            Dinicinit();

            for(int k=;k<=m;++k){

                if((!g[i][k])||(!g[j][k]))continue;

                if(k%)Addedge(s,k,);

                else Addedge(k,t,);

            }

            for(int x=;x<=m;++x){

                if(b[x]%==)continue;

                for(int y=;y<=m;++y){

                    if(b[x]%)continue;

                    if(!g[x][y])Addedge(x,y,);

                }

            }

            int flow=Maxflow();

            ans=max(ans,m-flow+-(i==j));

        }

    }

    Dinicinit();

    for(int i=;i<=m;++i){

        if(b[i]%)Addedge(s,i,);

        else Addedge(i,t,);

    }

    for(int i=;i<=m;++i){

        if(b[i]%==)continue;

        for(int j=;j<=m;++j){

            if(b[j]%)continue;

            if(!g[i][j])Addedge(i,j,);

        }

    }

    ans=max(ans,m-Maxflow());

    cout<<ans<<endl;

    return ;

}