// Arup Guha
// 4/10/2015
// Solution to 2012 NCPC Problem E: Ecodriving

import java.util.*;
import java.io.*;

public class ecodriving {

	public static int n;
	public static pt[] myPts;
	public static ArrayList[] graph;

	public static void main(String[] args) throws Exception {

		BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer tok = new StringTokenizer(stdin.readLine());

		n = Integer.parseInt(tok.nextToken());
		int numE = Integer.parseInt(tok.nextToken());
		int maxD = Integer.parseInt(tok.nextToken());

		// Read the points.
		myPts = new pt[n];
		for (int i=0; i<n; i++) {
			tok = new StringTokenizer(stdin.readLine());
			int x = Integer.parseInt(tok.nextToken());
			int y = Integer.parseInt(tok.nextToken());
			myPts[i] = new pt(x,y);
		}

		graph = new ArrayList[n];
		for (int i=0; i<n; i++)
			graph[i] = new ArrayList<Integer>();

		// Read the edges.
		for (int i=0; i<numE; i++) {
			tok = new StringTokenizer(stdin.readLine());
			int v1 = Integer.parseInt(tok.nextToken()) - 1;
			int v2 = Integer.parseInt(tok.nextToken()) - 1;
			graph[v1].add(v2);
		}

		// Set up modified BFS.
		double[] visited = new double[n*n];
		Arrays.fill(visited, maxD+1);
		PriorityQueue<info> pq = new PriorityQueue<info>();

		for (int i=0; i<graph[0].size(); i++) {
			int next = ((ArrayList<Integer>)graph[0]).get(i);
			pq.offer(new info(0, next, 0, myPts[0].dist(myPts[next])));
		}

		Double result = null;

		// Run BFS.
		while (pq.size() > 0) {

			// Get next; mark its distance.
			info cur = pq.poll();
			int curv1 = cur.loc1;
			int curv2 = cur.loc2;
			visited[curv1*n+curv2] = Math.min(visited[curv1*n+curv2], cur.distance);

			// Got there!
			if (curv2 == n-1) {
				result = cur.angle;
				break;
			}

			//  Try enqueing neighbors.
			for (int i=0; i<graph[curv2].size(); i++) {

				// Get each neighbor.
				int next = ((ArrayList<Integer>)graph[curv2]).get(i);
				if (next == curv1) continue;
				double nextD = cur.distance + myPts[curv2].dist(myPts[next]);
				double thisAngle = Math.max(cur.angle, turn(myPts[curv1], myPts[curv2], myPts[next]));

				// Too far.
				if (nextD > maxD+1e-9) continue;

				// We always put this in the queue, if this distance is less than the best using this edge.
				if (nextD <= visited[curv2*n+next])
					pq.offer(new info(curv2, next, thisAngle, nextD));
			}
		}

		// Output result.
		if (result == null) System.out.println("Impossible");
		else System.out.println(result*180/Math.PI);

	}

	// Use dot product to get angle ABC.
	public static double turn(pt a, pt b, pt c) {
		pt dir1 = new pt(a.x-b.x, a.y-b.y);
		pt dir2 = new pt(c.x-b.x, c.y-b.y);
		return Math.PI - Math.acos(dir1.dot(dir2)/dir1.mag()/dir2.mag());
	}
}

class pt {

	public double x;
	public double y;

	public pt(double myX, double myY) {
		x = myX;
		y = myY;
	}

	public double dist(pt other) {
		return Math.sqrt((x-other.x)*(x-other.x)+(y-other.y)*(y-other.y));
	}

	public double dot(pt other) {
		return this.x*other.x + this.y*other.y;
	}

	public double mag() {
		return Math.sqrt(x*x+y*y);
	}
}

class info implements Comparable<info> {

	public int loc1;
	public int loc2;
	public double angle;
	public double distance;

	public info(int i,int j, double myA, double myD) {
		loc1 = i;
		loc2 = j;
		angle = myA;
		distance = myD;
	}

	public int compareTo(info other) {
		if (this.angle < other.angle) return -1;
		if (this.angle > other.angle) return 1;
		return 0;
	}
}