// Problem: 8_C. Looking for Order
// Time complexity: np


import java.util.*;
import java.io.*;
import java.awt.Point;
import java.math.BigInteger;

import static java.lang.Math.*;

// Solution is at the bottom of code

public class ProblemC_008 implements Runnable{
	
	final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
	
	BufferedReader in;
	OutputWriter out;
	StringTokenizer tok = new StringTokenizer("");
	
	public static void main(String[] args){
		new Thread(null, new ProblemC_008(), "", 128 * (1L << 20)).start();
	}
	
	/////////////////////////////////////////////////////////////////////
	
	void init() throws FileNotFoundException{
		Locale.setDefault(Locale.US);
		
		if (ONLINE_JUDGE){
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new OutputWriter(System.out);
		}else{
			in = new BufferedReader(new FileReader("input.txt"));
			out = new OutputWriter("output.txt");
		}
	}
	
	////////////////////////////////////////////////////////////////
	
	long timeBegin, timeEnd;

	void time(){
		timeEnd = System.currentTimeMillis();
		System.err.println("Time = " + (timeEnd - timeBegin));
	}
	
	void debug(Object... objects){
		if (ONLINE_JUDGE){
			for (Object o: objects){
				System.err.println(o.toString());
			}
		}
	}
	
	/////////////////////////////////////////////////////////////////////
	
	public void run(){
		try{
			timeBegin = System.currentTimeMillis();
			Locale.setDefault(Locale.US);
			
			init();
			solve();
			
			out.close();
			time();
		}catch (Exception e){
			e.printStackTrace(System.err);
			System.exit(-1);
		}
	}
	
	/////////////////////////////////////////////////////////////////////
	
	String delim = " ";
	
	String readString() throws IOException{
		while(!tok.hasMoreTokens()){
			try{
				tok = new StringTokenizer(in.readLine());
			}catch (Exception e){
				return null;
			}
		}
		
		return tok.nextToken(delim);
	}
	
	String readLine() throws IOException{
		return in.readLine();
	}
	
	/////////////////////////////////////////////////////////////////
	
	final char NOT_A_SYMBOL = '\0';
	
	char readChar() throws IOException{
		int intValue = in.read();
		
		if (intValue == -1){
			return NOT_A_SYMBOL;
		}
		
		return (char) intValue;
	}
	
	char[] readCharArray() throws IOException{
		return readLine().toCharArray();
	}
	
	/////////////////////////////////////////////////////////////////
	
	int readInt() throws IOException{
		return Integer.parseInt(readString());
	}
	
	int[] readIntArray(int size) throws IOException{
		int[] array = new int[size];
		
		for (int index = 0; index < size; ++index){
			array[index] = readInt();
		}
		
		return array;
	}
	
	///////////////////////////////////////////////////////////////////
	
	long readLong() throws IOException{
		return Long.parseLong(readString());
	}
	
	long[] readLongArray(int size) throws IOException{
		long[] array = new long[size];
		
		for (int index = 0; index < size; ++index){
			array[index] = readLong();
		}
		
		return array;
	}
	
	////////////////////////////////////////////////////////////////////
	
	double readDouble() throws IOException{
		return Double.parseDouble(readString());
	}
	
	double[] readDoubleArray(int size) throws IOException{
		double[] array = new double[size];
		
		for (int index = 0; index < size; ++index){
			array[index] = readDouble();
		}
		
		return array;
	}
	
	/////////////////////////////////////////////////////////////////////
	
	Point readPoint() throws IOException{
		return new Point(readInt(), readInt());
	}
	
	Point[] readPointArray(int size) throws IOException{
		Point[] array = new Point[size];
		
		for (int index = 0; index < size; ++index){
			array[index] = readPoint();
		}
		
		return array;
	}
	
	/////////////////////////////////////////////////////////////////////
	
	class OutputWriter extends PrintWriter{

		final int DEFAULT_PRECISION = 12;
		
		int precision;
		String format, formatWithSpace;
		
		{
			precision = DEFAULT_PRECISION;
			
			format = createFormat(precision);
			formatWithSpace = format + " ";
		}
		
		public OutputWriter(OutputStream out) {
			super(out);
		}

		public OutputWriter(String fileName) throws FileNotFoundException {
			super(fileName);
		}
		
		public int getPrecision() {
			return precision;
		}

		public void setPrecision(int precision) {
			this.precision = precision;
			
			format = createFormat(precision);
			formatWithSpace = format + " ";
		}
		
		private String createFormat(int precision){
			return "%." + precision + "f";
		}
		
		@Override
		public void print(double d){
			printf(format, d);
		}
		
		public void printWithSpace(double d){
			printf(formatWithSpace, d);
		}

		public void printAll(double...d){
			for (int i = 0; i < d.length - 1; ++i){
				printWithSpace(d[i]);
			}
			
			print(d[d.length - 1]);
		}
		
		@Override
		public void println(double d){
			printlnAll(d);
		}
		
		public void printlnAll(double... d){
			printAll(d);
			println();
		}
	}
	
	/////////////////////////////////////////////////////////////////////
	
	int[][] steps = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; 
	
	boolean check(int index, int lim){
		return (0 <= index && index < lim);
	}
	
	/////////////////////////////////////////////////////////////////////
	
	void solve() throws IOException{
		Point bag = readPoint();
		
		int n = readInt();
		
		Point[] points = new Point[n];
		
		for (int i = 0; i < n; ++i){
			points[i] = readPoint();
		}
		
		int[] dist = new int[n];
		for (int i = 0; i < n; ++i){
			int dx = points[i].x - bag.x;
			int dy = points[i].y - bag.y;
			
			dist[i] = dx * dx + dy * dy;
		}
		
		int[][] d = new int[n][n];
		for (int i = 0; i < n; ++i){
			for (int j = 0; j < n; ++j){
				int dx = points[i].x - points[j].x;
				int dy = points[i].y - points[j].y;
				
				d[i][j] = dx * dx + dy * dy;
				d[i][j] += dist[i] + dist[j];
			}
		}
		
		int[] singleMasks = new int[n];
		for (int i = 0; i < n; ++i){
			singleMasks[i] = (1 << i);
		}
		
		int[][] doubleMasks = new int[n][n];
		for (int i = 0; i < n; ++i){
			for (int j = 0; j < n; ++j){
				doubleMasks[i][j] = (singleMasks[i] | singleMasks[j]);
			}
		}
		
		int lim = (1 << n);
		int[] dp = new int[lim];
		
		Arrays.fill(dp, Integer.MAX_VALUE);
		dp[0] = 0;
		
		int[] p = new int[lim];
		Arrays.fill(p, -1);
		
		for (int mask = 0; mask < lim; ++mask){
			if (dp[mask] == Integer.MAX_VALUE){
				continue;
			}
			
			int minBit = -1;
			
			for (int bit = 0; bit < n; ++bit){
				if (checkBit(mask, bit)) continue;
				
				if (minBit == -1 || (dist[minBit] > dist[bit])){
					minBit = bit;
				}
			}
			
			if (minBit == -1){
				continue;
			}
			
			for (int bit = 0; bit < n; ++bit){
				if (checkBit(mask, bit)) continue;
				
				int newMask = (mask | (1 << minBit) | (1 << bit));
				
				if (dp[newMask] > dp[mask] + d[minBit][bit]){
					dp[newMask] = dp[mask] + d[minBit][bit];
					p[newMask] = minBit * n + bit;
				}
			}
		}
		
		out.println(dp[lim-1]);
		
		int curMask = lim - 1;
		while (p[curMask] != -1){
			out.print("0 ");
			
			int first = p[curMask] / n;
			int second = p[curMask] % n;
			
			out.print((first + 1) + " ");
			curMask ^= (1 << first);
			
			if (first != second){
				out.print((second + 1) + " ");
				curMask ^= (1 << second);
			}
		}
		
		out.println("0");
	}

	private boolean checkBit(int mask, int bitNumber) {
		return (mask & (1 << bitNumber)) != 0;
	}
	
	boolean checkMask(int mask, int innerMask){
		return (mask & innerMask) == innerMask;
	}
}