// Problem: 8_C. Looking for Order
// Time complexity: np
import java.util.Scanner;


public class CF_8C {

	public static void main(String[] args) {
		
		// Hooray bitmasks! I'm good at these :)
		
		Scanner in = new Scanner(System.in);
		
		// Handbag coordinates..
		int hb_x = in.nextInt(), hb_y = in.nextInt();
		int n = in.nextInt();
		int[] ox = new int[n];
		int[] oy = new int[n];
		
		// Dynamic programming: Also store a matrix of the time to reach one
		//  object from the other.
		// This considers the handbag to be object 0
		int[][] dt = new int[n][n];
		int[] hbd = new int[n];
		for (int i = 0; i < n; i++) {
			ox[i] = in.nextInt();
			oy[i] = in.nextInt();
			hbd[i] = (ox[i] - hb_x) * (ox[i] - hb_x)
					+ (oy[i] - hb_y) * (oy[i] - hb_y);
		}
		
		// Compute elapsed times...
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				dt[i][j] = (ox[i] - ox[j]) * (ox[i] - ox[j])
						+ (oy[i] - oy[j]) * (oy[i] - oy[j]);
			}
		}
		
		// Fill up an array with the amount of time it takes to grab
		//  all objects with the specified bitmask.
		int[] sofar = new int[1 << n];
		int[] masks = new int[1 << n];
		sofar[0] = 0;
		for (int i = 1; i < (1 << n); i++) {
			sofar[i] = -1;
		}
		
		for (int i = 0; i < (1 << n); i++) {
			if (sofar[i] != -1) {
				for (int maskbit = 0; maskbit < n; maskbit++) {
					// Look for first object in bitmask to grab...
					if (((1 << maskbit) & i) == 0) {
						int iffirst = ((1 << maskbit) | i);
						int fromold = sofar[i] + 2 * hbd[maskbit];
						
						if (sofar[iffirst] == -1 || sofar[iffirst] > fromold) {
							// A better way to get to position J was found, use it.
							sofar[iffirst] = fromold;
							masks[iffirst] = i;
						}
						
						// Find another thing while you're out...
						for (int otherone = 0; otherone < n; otherone++) {
							if (((1 << otherone) & iffirst) == 0) {
								int iffollow = ((1 << otherone) | iffirst);
								int fromi = sofar[i] + hbd[maskbit] + dt[maskbit][otherone] + hbd[otherone];
								
								// Did we find a better way to get to iffollow state?
								if (sofar[iffollow] == -1 || sofar[iffollow] > fromi) {
									sofar[iffollow] = fromi;
									masks[iffollow] = i;
								}
							}
						}
						break;
					}
				}
			}
		}
		
		// After all this time, we have an answer.
		// The minimum time will be the value of sofar at the very end,
		//  which will have the case of if all objects were picked up.
		// Clever, no?
		// The logic came from http://www.darrensun.com/codeforces-round-8/
		// Wish I could claim it mine, but it is not so.
		
		int end_val = (1 << n) - 1;
		
		System.out.println(sofar[end_val]);
		System.out.print(0);
		while (end_val > 0) {
			// Which objects were collected in the prvious trip?
			int diff = end_val ^ masks[end_val];
			int obj1 = -1, obj2 = -1;
			for (int i = 0; i < n; i++) {
				if (((1 << i) & diff) > 0) {
					obj2 = obj1;
					obj1 = i;
				}
			}
			
			if (obj2 >= 0) {
				// Two objects were collected this trip, output them both.
				System.out.print(" " + (obj1 + 1) + " " + (obj2 + 1) + " 0");
			} else {
				// Only one object was collected here.
				System.out.print(" " + (obj1 + 1) + " 0");
			}
			end_val = masks[end_val];
		}
		
		in.close();
	}

}