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

public class maze1
{
	private static final Scanner cin = new Scanner(System.in);

	public static void main(String[] args)
	{
		while(true) {
			int sx = cin.nextInt() * 2;
			int sy = cin.nextInt() * 2;
			int n  = cin.nextInt();

			if(sx == 0 && sy == 0 && n == 0)
				break;

			boolean[][] map = new boolean[sx + 1][sy + 1];

			for(int x = 0; x <= sx; x++)
				map[x][0] = map[x][sy] = true;
			for(int y = 0; y <= sy; y++)
				map[0][y] = map[sx][y] = true;

			for(int i = 0; i < n; i++) {
				int x1 = cin.nextInt() * 2;
				int y1 = cin.nextInt() * 2;
				int x2 = cin.nextInt() * 2;
				int y2 = cin.nextInt() * 2;

				int mx = Math.min(x1, x2);
				int my = Math.min(y1, y2);
				int nx = Math.max(x1, x2);
				int ny = Math.max(y1, y2);

				for(int y = my; y <= ny; y++) {
					for(int x = mx; x <= nx; x++) {
						map[x][y] = true;
					}
				}
			}

			int px = cin.nextInt();
			int py = cin.nextInt();
			int qx = cin.nextInt();
			int qy = cin.nextInt();

			int dx = (py == qy) ? 0 : (px == 0) ? +1 : -1;
			int dy = (px == qx) ? 0 : (py == 0) ? +1 : -1;
			int cx = px + qx + dx;
			int cy = py + qy + dy;
			int gx = cin.nextInt() * 2 + 1;
			int gy = cin.nextInt() * 2 + 1;

			int ans = 1;

			boolean[][][] vis = new boolean[sx + 1][sy + 1][4];

			while(cx != gx || cy != gy) {
				int dir = (dx & 2) | (dy & 3);
				if(vis[cx][cy][dir]) { ans = -1; break; }
				ans++;
				vis[cx][cy][dir] = true;

				int _dx, _dy;

				if(! map[cx-dy][cy+dx]) {
					_dx = -dy;
					_dy = +dx;
				}
				else if(! map[cx+dx][cy+dy]) {
					_dx = +dx;
					_dy = +dy;
				}
				else if(! map[cx+dy][cy-dx]) {
					_dx = +dy;
					_dy = -dx;
				}
				else if(! map[cx-dx][cy-dy]) {
					_dx = -dx;
					_dy = -dy;
				}
				else {
					ans = -1; break; // very rare, but possible
				}

				dx = _dx;
				dy = _dy;

				cx += dx * 2;
				cy += dy * 2;
			}

			if(ans == -1) {
				System.out.println("Impossible");
			}
			else {
				System.out.println(ans);
			}
		}
	}
}