#include<stdio.h>
#include<algorithm>
#include<numeric>
#include<cassert>
#include<vector>
#include<iostream>
int edge[500005][3];
namespace tree {
    struct edge {
        int v,next;
    };
    edge e[1000005];
    int en,last[500005];
    inline void _add_edge(const int &u,const int &v) {
        e[++en]={v,last[u]};
        last[u]=en;
    }
    inline void add_edge(const int &u,const int &v) {
        _add_edge(u,v),_add_edge(v,u);
    }
    int fa[500005];
    int size[500005],dep[500005];
    int son[500005],top[500005];
    void dfs1(const int &u) {
        dep[u]=dep[fa[u]]+1;
        size[u]=1;
        for(int i=last[u];i;i=e[i].next) {
            const int v(e[i].v);
            if(v==fa[u]) {
                continue;
            }
            fa[v]=u,dfs1(v);
            size[u]+=size[v];
            if(size[v]>size[son[u]]) {
                son[u]=v;
            }
        }
    }
    void dfs2(const int &u) {
        if(!top[u]) {
            top[u]=u;
        }
        if(son[u]) {
            top[son[u]]=top[u];
        }
        for(int i=last[u];i;i=e[i].next) {
            const int v(e[i].v);
            if(v!=fa[u]) {
                dfs2(v);
            }
        }
    }
    inline int LCA(int u,int v) {
        while(top[u]!=top[v]) {
            if(dep[top[u]]>dep[top[v]]) {
                u=fa[top[u]];
            }
            else {
                v=fa[top[v]];
            }
        }
        return dep[u]<dep[v]?u:v;
    }
}
int path[500005][3];
namespace dsu {
    template<int N>
    struct dsu {
        int fa[N+5];
        inline void clear(const int &n) {
            std::iota(fa+1,fa+n+1,1);
        }
        int getf(const int &x) {
            return fa[x]==x?x:fa[x]=getf(fa[x]);
        }
        inline void merge(const int &x,const int &y) {
            fa[getf(y)]=getf(x);
        }
    };
    dsu<500000> t,s[2];
}
namespace heap {
    struct node {
        int fa;
        union {
            struct{int ls,rs;};
            int son[2];
        };
        int dis;
        int val;
        template<typename _CharT,typename _Traits>
        inline friend std::basic_ostream<_CharT,_Traits> &operator<<(std::basic_ostream<_CharT,_Traits> &__out,const node &__n) {
            __out<<'('<<__n.fa<<", ("<<__n.ls<<", "<<__n.rs<<"), "<<__n.dis<<", "<<__n.val<<')';
            return __out;
        }
    };
    node tr[1500005];
    inline int son_type(const int &x) {
        return x==tr[tr[x].fa].rs;
    }
    int merge(int x,int y) {
        if(!x) {
            return y;
        }
        if(!y) {
            return x;
        }
        if(tr[x].val<tr[y].val) {
            std::swap(x,y);
        }
        tr[x].rs=merge(tr[x].rs,y);
        tr[tr[x].rs].fa=x;
        if(tr[tr[x].ls].dis<tr[tr[x].rs].dis) {
            std::swap(tr[x].ls,tr[x].rs);
        }
        tr[x].dis=tr[tr[x].rs].dis+1;
        return x;
    }
    int pop(const int &x) {
        return merge(tr[x].ls,tr[x].rs);
    }
    int get_root(int x) {
        while(tr[x].fa) {
            x=tr[x].fa;
        }
        return x;
    }
    int erase(const int &x,int y) {
        if(x==y) {
            y=pop(x),tr[y].fa=0;
            return y;
        }
        // assert(get_root(y)==x);
        tr[tr[tr[y].fa].son[son_type(y)]=pop(y)].fa=tr[y].fa;
        for(y=tr[y].fa;y&&tr[tr[y].ls].dis<tr[tr[y].rs].dis;y=tr[y].fa) {
            std::swap(tr[y].ls,tr[y].rs);
            tr[y].dis=tr[tr[y].rs].dis+1;
        }
        return x;
    }
    inline void check(const int &n) {
        for(int i=1;i<=n;i++) {
            assert(tr[i].ls==0||tr[i].ls!=tr[i].rs);
        }
    }
    void output(const int &x) {
        if(tr[x].ls) {
            output(tr[x].ls);
        }
        std::cerr<<"tr["<<x<<"] = "<<tr[x]<<'\n';
        if(tr[x].rs) {
            output(tr[x].rs);
        }
    }
}
namespace execute {
    int dir[500005];
    std::vector<int> vec;
    int root1[500005],root2[500005],root3[500005],shift;
    inline void insert3(const int &,const int &);
    inline void clear(const int &n,const int &m) {
        std::fill(dir+1,dir+n+1,-1);
        vec.clear();
        std::fill(root1+1,root1+n+1,0);
        std::fill(root2+1,root2+n+1,0);
        std::fill(root3+1,root3+n+1,0);
        shift=m<<1;
        for(int i=1;i<=n;i++) {
            insert3(tree::fa[i],shift+i);
        }
    }
    inline void schedule(const int &x) {
        vec.emplace_back(x);
    }
    inline void insert1(const int &u,const int &x) {
        // std::cerr<<"> insert1 "<<u<<' '<<x<<'\n';
        root1[u]=heap::merge(root1[u],x);
    }
    inline void pop1(const int &u) {
        // std::cerr<<"> pop1 "<<u<<'\n';
        root1[u]=heap::pop(root1[u]);
    }
    inline void erase1(const int &u,const int &x) {
        // std::cerr<<"> erase1 "<<u<<' '<<x<<'\n';
        root1[u]=heap::erase(root1[u],x);
    }
    inline void merge1(const int &u,const int &v) {
        // std::cerr<<"> merge1 "<<u<<' '<<v<<'\n';
        root1[u]=heap::merge(root1[u],root1[v]);
    }
    inline void insert3(const int &u,const int &x) {
        // std::cerr<<"> insert3 "<<u<<' '<<x<<'\n';
        root3[u]=heap::merge(root3[u],x);
    }
    inline void pop3(const int &u) {
        // std::cerr<<"> pop3 "<<u<<'\n';
        root3[u]=heap::pop(root3[u]);
    }
    inline void erase3(const int &u,const int &x) {
        // std::cerr<<"> erase3 "<<u<<' '<<x<<'\n';
        root3[u]=heap::erase(root3[u],x);
    }
    inline void merge3(const int &u,const int &v) {
        // std::cerr<<"> merge3 "<<u<<' '<<v<<'\n';
        root3[u]=heap::merge(root3[u],root3[v]);
    }
    inline void insert2(const int &u,const int &x) {
        // std::cerr<<"> insert2 "<<u<<' '<<x<<'\n';
        const int w(dsu::t.getf(tree::fa[u]));
        erase3(w,shift+u);
        // heap::output(root1[2]);
        // std::cerr<<"---\n";
        // std::cerr<<"root2[u] = "<<root2[u]<<'\n';
        // heap::output(root2[u]);
        root2[u]=heap::merge(root2[u],x);
        // std::cerr<<"root2[u] = "<<root2[u]<<'\n';
        // heap::output(root2[u]);
        // std::cerr<<"root1[2] = "<<root1[2]<<'\n';
        // heap::output(root1[2]);
        heap::tr[shift+u]={0,0,0,0,heap::tr[root2[u]].val};
        insert3(w,shift+u);
    }
    inline void pop2(const int &u) {
        // std::cerr<<"> pop2 "<<u<<'\n';
        const int w(dsu::t.getf(tree::fa[u]));
        erase3(w,shift+u);
        root2[u]=heap::pop(root2[u]);
        heap::tr[shift+u]={0,0,0,0,heap::tr[root2[u]].val};
        insert3(w,shift+u);
    }
    inline void erase2(const int &u,const int &x) {
        // std::cerr<<"> erase2 "<<u<<' '<<x<<'\n';
        root2[u]=heap::erase(root2[u],x);
    }
    inline void merge2(const int &u,const int &v) {
        // std::cerr<<"> merge2 "<<u<<' '<<v<<'\n';
        const int w(dsu::t.getf(tree::fa[u]));
        erase3(w,shift+u);
        root2[u]=heap::merge(root2[u],root2[v]);
        heap::tr[shift+u]={0,0,0,0,heap::tr[root2[u]].val};
        insert3(w,shift+u);
    }
    inline int get_root(const int &x) {
        return dsu::t.getf(path[x+1>>1][x&1^1]);
    }
    inline void orient(const int &u,const int &d) {
        // std::cerr<<" orient "<<u<<' '<<d<<'\n';
        assert(dir[u]==-1);
        dir[u]=d;
        assert(dsu::t.fa[u]==u);
        const int v(dsu::t.getf(tree::fa[u]));
        dsu::t.fa[u]=v;
        assert(dsu::s[d].fa[u]==u);
        dsu::s[d].merge(tree::fa[u],u);
        // std::cerr<<" v = "<<v<<'\n';
        while(root1[u]&&heap::tr[root1[u]].val>=tree::dep[v]) {
            // std::cerr<<"  root1\n";
            const int x(root1[u]),y((x-1^1)+1);
            // std::cerr<<"  x = "<<x<<", y = "<<y<<'\n';
            // std::cerr<<"  root1[u] = "<<root1[u]<<'\n';
            // heap::output(root1[u]);
            pop1(u);
            // std::cerr<<"  root1[u] = "<<root1[u]<<'\n';
            // heap::output(root1[u]);
            const int _u(get_root(y));
            assert(u!=_u);
            // std::cerr<<"  _u = "<<_u<<'\n';
            // std::cerr<<"  root1[_u] = "<<root1[_u]<<'\n';
            // heap::output(root1[_u]);
            erase1(_u,y);
            // std::cerr<<"  root1[_u] = "<<root1[_u]<<'\n';
            // heap::output(root1[_u]);
            if(heap::tr[y].val>=tree::dep[dsu::t.getf(tree::fa[_u])]) {
                // std::cerr<<"  schedule "<<(y+1>>1)<<'\n';
                schedule(y+1>>1);
            }
            else {
                // std::cerr<<"  insert2 "<<_u<<' '<<y<<'\n';
                heap::tr[y]={0,0,0,0,heap::tr[y].val};
                insert2(_u,y);
            }
        }
        while(root2[u]&&heap::tr[root2[u]].val>=tree::dep[dsu::t.getf(tree::fa[v])]) {
            // std::cerr<<"  root2\n";
            // std::cerr<<"  x = "<<root2[u]<<'\n';
            schedule(root2[u]+1>>1),pop2(u);
        }
        while(root3[u]&&heap::tr[root3[u]].val>=tree::dep[v]) {
            // std::cerr<<"  root3\n";
            const int w(root3[u]-shift);
            // std::cerr<<"  w = "<<w<<'\n';
            pop3(u);
            const int x(root2[w]);
            // std::cerr<<"  x = "<<x<<'\n';
            erase2(w,x);
            schedule(x+1>>1);
            heap::tr[shift+w]={0,0,0,0,heap::tr[root2[w]].val};
            insert3(u,shift+w);
        }
        // std::cerr<<" merge "<<v<<' '<<u<<'\n';
        merge1(v,u),merge2(v,u);
        erase3(v,shift+u),merge3(v,u);
        // std::cerr<<" end_orient\n";
    }
    inline bool check(const int &u,const int &v,const int &d) {
        return tree::dep[dsu::s[d].getf(u)]<=tree::dep[v];
    }
    inline void fix(const int &x) {
        // std::cerr<<" fix "<<x<<'\n';
        const int &u(path[x][0]),_u(dsu::t.getf(u));
        // std::cerr<<"  u = "<<u<<", _u = "<<_u<<'\n';
        const int &v(path[x][1]),_v(dsu::t.getf(v));
        // std::cerr<<"  v = "<<v<<", _v = "<<_v<<'\n';
        const int &w(path[x][2]);
        // std::cerr<<"  w = "<<w<<'\n';
        assert(tree::dep[_u]<=tree::dep[w]||tree::dep[_v]<=tree::dep[w]);
        assert(tree::dep[_u]<=tree::dep[w]||tree::dep[dsu::t.getf(tree::fa[_u])]<=tree::dep[w]);
        assert(tree::dep[_v]<=tree::dep[w]||tree::dep[dsu::t.getf(tree::fa[_v])]<=tree::dep[w]);
        // std::cerr<<"  "<<(tree::dep[_u]<=tree::dep[w]?check(u,w,0):check(u,_u,0)&&check(tree::fa[_u],w,0))<<'\n';
        // std::cerr<<"  "<<(tree::dep[_v]<=tree::dep[w]?check(v,w,1):check(v,_v,1)&&check(tree::fa[_v],w,1))<<'\n';
        if((tree::dep[_u]<=tree::dep[w]?check(u,w,0):check(u,_u,0)&&check(tree::fa[_u],w,0))&&
           (tree::dep[_v]<=tree::dep[w]?check(v,w,1):check(v,_v,1)&&check(tree::fa[_v],w,1))) {
            assert(tree::dep[_u]>tree::dep[w]||tree::dep[_v]>tree::dep[w]);
            if(tree::dep[_u]>tree::dep[w]) {
                orient(_u,1);
            }
            if(tree::dep[_v]>tree::dep[w]) {
                orient(_v,0);
            }
        }
    }
    inline void work() {
        // std::cerr<<"work\n";
        while(!vec.empty()) {
            const int x(vec.back());
            vec.pop_back(),fix(x);
        }
    }
    inline int query(const int &x) {
        return dir[edge[x][0]];
    }
}
char ans[500005];
int main() {
    int n,m;
    scanf("%*d%d%d",&n,&m);
    for(int i=1;i<n;i++) {
        scanf("%d%d",edge[i],edge[i]+1);
        tree::add_edge(edge[i][0],edge[i][1]);
    }
    tree::dfs1(1);
    tree::dfs2(1);
    for(int i=1;i<n;i++) {
        if(tree::fa[edge[i][1]]==edge[i][0]) {
            std::swap(edge[i][0],edge[i][1]);
            edge[i][2]=1;
        }
    }
    dsu::t.clear(n);
    dsu::s[0].clear(n);
    dsu::s[1].clear(n);
    execute::clear(n,m);
    for(int i=1;i<=m;i++) {
        scanf("%d%d",path[i],path[i]+1);
        path[i][2]=tree::LCA(path[i][0],path[i][1]);
        // std::cerr<<"path "<<i<<":\n";
        // std::cerr<<' '<<path[i][0]<<" --- "<<path[i][2]<<" --- "<<path[i][1]<<'\n';
        if(tree::fa[path[i][0]]==path[i][1]||tree::fa[path[i][1]]==path[i][0]) {
            // std::cerr<<" scheduled\n";
            execute::schedule(i);
        }
        else {
            heap::tr[(i<<1)-1]={0,0,0,0,tree::dep[path[i][2]]};
            heap::tr[i<<1]={0,0,0,0,tree::dep[path[i][2]]};
            if(path[i][0]==path[i][2]) {
                // std::cerr<<" insert2 "<<path[i][1]<<' '<<(i<<1)<<'\n';
                execute::insert2(path[i][1],i<<1);
            }
            else if(path[i][1]==path[i][2]) {
                // std::cerr<<" insert2 "<<path[i][0]<<' '<<(i<<1)-1<<'\n';
                execute::insert2(path[i][0],(i<<1)-1);
            }
            else {
                // std::cerr<<" insert2 "<<path[i][0]<<' '<<(i<<1)-1<<'\n';
                // std::cerr<<" insert2 "<<path[i][1]<<' '<<(i<<1)<<'\n';
                execute::insert1(path[i][0],(i<<1)-1);
                execute::insert1(path[i][1],i<<1);
            }
        }
    }
    execute::work();
    for(int i=1;i<n;i++) {
        if(execute::query(i)==-1) {
            // std::cerr<<"greed "<<i<<'\n';
            execute::orient(edge[i][0],edge[i][2]);
            // heap::check((m<<1)+n);
            execute::work();
        }
    }
    for(int i=1;i<n;i++) {
        ans[i]=execute::query(i)^edge[i][2]^48;
    }
    ans[n]=0,puts(ans+1);
    return 0;
}