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

#define int long long

#define INF (int)1e8

struct P{
	int x,y;
};

struct L{
	P l,h;
};

bool operator==(P a,P b){
	return a.x==b.x&&a.y==b.y;
}

bool operator<(P a,P b){
	return a.x<b.x||a.x==b.x&&a.y<b.y;
}

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

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

istream&operator>>(istream&is,P&p){
	return is>>p.x>>p.y;
}

ostream&operator<<(ostream&os,P p){
	return os<<'('<<p.x<<','<<p.y<<')';
}

int sign(int x){
	return (x>0)-(x<0);
}

int dot(P a,P b){
	return a.x*b.x+a.y*b.y;
}

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

int orient(P a,P b,P c){
	return sign(cross(a-b,c-b));
}

int right(P a,P b,P c){
	return cross(a-b,c-b)>=0;
}

int test(L a,P b){
	return cross(a.h-a.l,b-a.l)==0&&dot(a.h-a.l,b-a.l)>dot(a.h-a.l,a.l-a.l)&&dot(a.h-a.l,b-a.l)<dot(a.h-a.l,a.h-a.l);
}

int test(L a,L b){
	if(a.l==b.l){
		return test(a,b.h)||test(b,a.h);
	}
	if(a.l==b.h){
		return test(a,b.l)||test(b,a.h);
	}
	if(a.h==b.l){
		return test(a,b.h)||test(b,a.l);
	}
	if(a.h==b.h){
		return test(a,b.l)||test(b,a.l);
	}
	int o1=orient(a.l,a.h,b.l);
	int o2=orient(a.l,a.h,b.h);
	int o3=orient(b.l,b.h,a.l);
	int o4=orient(b.l,b.h,a.h);
	return o1!=o2&&o3!=o4;
}

bool operator<(L a,L b){
	if(a.l==b.h){
		return false;
	}
	if(a.h==b.l){
		return true;
	}
	int x=!right(b.h,b.l,a.l);
	int y=!right(a.h,a.l,b.l);
	if(x==y){
		x=!right(b.h,b.l,a.h);
		y=!right(a.h,a.l,b.h);
	}
	return x>y;
}

signed main(){
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	int N;
	cin>>N;
	vector<pair<P,int>>v(N+1);
	for(int i=0;i<=N;i++){
		cin>>v[i].first;
		v[i].second=i;
	}
	vector<L>e;
	for(int i=1;i<=N;i++){
		e.push_back(L{v[0].first,v[i].first});
	}
	for(int i=0;i<N-1;i++){
		int a,b;
		cin>>a>>b;
		e.push_back(L{v[a].first,v[b].first});
	}
	for(auto&p:e){
		if(p.h<p.l){
			swap(p.l,p.h);
		}
	}
	vector<int>ans(N,1);
	vector<tuple<P,int,int>>q;
	for(int i=0;i<e.size();i++){
		q.emplace_back(e[i].l,1,i);
		q.emplace_back(e[i].h,2,i);
	}
	sort(q.begin(),q.end());
	set<pair<L,int>>s;
	s.emplace(L{P{-INF,-INF},P{INF,-INF}},-1);
	s.emplace(L{P{-INF,INF},P{INF,INF}},-1);
	for(auto[p,o,i]:q){
		if(o==1){
			auto it=s.insert(pair<L,int>(e[i],i)).first;
			auto lt=prev(it);
			auto rt=next(it);
			while(test(it->first,lt->first)){
				if(it->second<N){
					ans[it->second]=0;
					it=s.erase(it);
				}
				else{
					if(lt->second>=N){
						exit(1);
					}
					ans[lt->second]=0;
					lt=prev(s.erase(lt));
				}
			}
			while(test(it->first,rt->first)){
				if(it->second<N){
					ans[it->second]=0;
					it=prev(s.erase(it));
				}
				else{
					if(rt->second>=N){
						exit(1);
					}
					ans[rt->second]=0;
					rt=s.erase(rt);
				}
			}
		}
		if(o==2){
			auto it=s.find(pair<L,int>(e[i],i));
			if(it!=s.end()){
				it=s.erase(it);
				auto lt=prev(it);
				while(test(it->first,lt->first)){
					if(it->second<N){
						ans[it->second]=0;
						it=s.erase(it);
					}
					else{
						if(lt->second>=N){
							exit(1);
						}
						ans[lt->second]=0;
						lt=prev(s.erase(lt));
					}
				}
			}
		}
	}
	cout<<count(ans.begin(),ans.end(),1)<<'\n';
	for(int i=0;i<N;i++){
		if(ans[i]){
			cout<<i+1<<' ';
		}
	}
	cout<<'\n';
	return 0;
}