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

public class savethebest_nn {

	static boolean dfs(int v, boolean[][] g, boolean[] was, int[] p1, int[] p2) {
		if (was[v]) {
			return false;
		}
		was[v] = true;
		for (int i = 0; i < g[v].length; i++) {
			if (!g[v][i]) {
				continue;
			}
			if (p2[i] < 0 || dfs(p2[i], g, was, p1, p2)) {
				p2[i] = v;
				p1[v] = i;
				return true;
			}
		}
		return false;
	}

	static Answer check(double d, int dSquared, int n, int m, int k, Point[] s1, Point[] s2) {
		boolean[][] g = new boolean[n][m];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				g[i][j] = s1[i].dist2(s2[j]) < dSquared;
			}
		}
		boolean[] was = new boolean[n];
		int[] p2 = new int[m];
		int[] p1 = new int[n];
		Arrays.fill(p1, -1);
		Arrays.fill(p2, -1);
		int answer = 0;
		for (int i = 0; i < n; i++) {
			Arrays.fill(was, false);
			if (dfs(i, g, was, p1, p2)) {
				answer++;
			}
		}
		answer = n + m - answer;
		if (answer < k) {
			return null;
		}
		Arrays.fill(was, false);
		for (int i = 0; i < n; i++) {
			if (p1[i] < 0) {
				dfs(i, g, was, p1, p2);
			}
		}
		boolean[] was2 = new boolean[m];
		for (int i = 0; i < n; i++) {
			if (was[i]) {
				for (int j = 0; j < m; j++) {
					if (!g[i][j] || p2[j] < 0) {
						continue;
					}
					was2[j] = true;
				}
			}
		}
		int[] ret = new int[k];
		int count = 0;
		for (int i = 0; count < k && i < n; i++) {
			if (was[i]) {
				ret[count++] = i;
			}
		}
		for (int i = 0; count < k && i < m; i++) {
			if (!was2[i]) {
				ret[count++] = i + n;
			}
		}
		return new Answer(d, ret);
	}

	static Answer solve(int n, int m, int k, Point[] p1, Point[] p2) {
		int l = 0;
		int r = Integer.MAX_VALUE / 2;
		while (l < r - 1) {
			int mid = l + r >> 1;
			if (check(Math.sqrt(mid), mid, n, m, k, p1, p2) != null) {
				l = mid;
			} else {
				r = mid;
			}
		}
		double d = r == Integer.MAX_VALUE / 2 ? Double.POSITIVE_INFINITY : Math.sqrt(l);
		return check(d, l, n, m, k, p1, p2);
	}

	static class Point {
		int x;
		int y;

		Point(int x, int y) {
			this.x = x;
			this.y = y;
		}

		int dist2(Point p) {
			int dx = x - p.x;
			int dy = y - p.y;
			return dx * dx + dy * dy;
		}

		@Override
		public int hashCode() {
			return x * 33533 + y;
		}

		@Override
		public boolean equals(Object o) {
			Point p = (Point) o;
			return x == p.x && y == p.y;
		}
	}

	static class Answer {
		double d;
		int[] id;

		Answer(double d, int[] id) {
			this.d = d;
			this.id = id;
		}
	}

	static final int MAXS = 200;
	static final int MAXX = 10000;

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(new File("savethebest.in"));
		int n = sc.nextInt();
		int m = sc.nextInt();
		int k = sc.nextInt();
		assert 1 <= n && 1 <= m && 1 <= k && k <= n + m && n + m <= MAXS;
		HashSet<Point> allPoints = new HashSet<Point>();
		Point[] p1 = new Point[n];
		for (int i = 0; i < n; i++) {
			int x = sc.nextInt();
			int y = sc.nextInt();
			assert -MAXX <= x && x <= MAXX;
			assert -MAXX <= y && y <= MAXX;
			p1[i] = new Point(x, y);
			assert allPoints.add(p1[i]);
		}
		Point[] p2 = new Point[m];
		for (int i = 0; i < m; i++) {
			int x = sc.nextInt();
			int y = sc.nextInt();
			assert -MAXX <= x && x <= MAXX;
			assert -MAXX <= y && y <= MAXX;
			p2[i] = new Point(x, y);
			assert allPoints.add(p2[i]);
		}
		PrintWriter out = new PrintWriter("savethebest.out");
		Answer ans = solve(n, m, k, p1, p2);
		out.println(Double.isInfinite(ans.d) ? "-1" : ans.d);
		for (int i = 0; i < k; i++) {
			out.println(ans.id[i] + 1);
		}
		out.close();
	}
}