// Problem: 8_C. Looking for Order
// Time complexity: np
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main implements Runnable {

    // ////////////////////////////////////////////////////////////////////
    // Solution

    private int n;
    private int nn;
    private int[][] D;
    private int[] dp;
    private int[] prev;

    private void solve() throws Throwable {
        int xs = nextInt(), ys = nextInt();
        n = nextInt();
        int[][] pts = new int[n][2];
        for (int i = 0; i < n; i++) {
            pts[i][0] = nextInt();
            pts[i][1] = nextInt();
        }
        D = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (i == j) {
                    D[i][i] = 2 * (sqr(pts[i][0] - xs) + sqr(pts[i][1] - ys));
                } else {
                    D[i][j] = sqr(pts[i][0] - xs) + sqr(pts[i][1] - ys)
                            + sqr(pts[i][0] - pts[j][0])
                            + sqr(pts[i][1] - pts[j][1]) + sqr(pts[j][0] - xs)
                            + sqr(pts[j][1] - ys);
                }
            }
        }
        nn = 1 << n;
        dp = new int[nn];
        prev = new int[nn];
        Arrays.fill(dp, -1);
        Arrays.fill(prev, -1);
        dp[0] = 0;
        Dp(nn - 1);
        pw.println(dp[nn - 1]);
        pw.print(0);
        for (int p = nn - 1; p != -1 && prev[p] != -1; p = prev[p]) {
            int vv = p ^ prev[p];
            for (int j = 0; j < n; j++) {
                int jj = 1 << j;
                if ((vv & jj) == 0) continue;
                pw.print(' ');
                pw.print(j + 1);
            }
            pw.print(" 0");
        }
        pw.println();
    }

    private int Dp(int i) {
        if (dp[i] != -1) return dp[i];
        int ans = 107374182, p = -1;
        int j1 = 1, pos1 = 0;
        for (; pos1 < n && j1 < nn; j1 *= 2, pos1++) {
            if ((i & j1) == 0) continue;
            int a = D[pos1][pos1] + Dp(i ^ j1);
            if (a < ans) {
                ans = a;
                p = i ^ j1;
            }
            int j2 = j1 * 2, pos2 = pos1 + 1;
            for (; pos2 < n && j2 < nn; j2 *= 2, pos2++) {
                if ((i & j2) == 0) continue;
                a = D[pos1][pos2] + Dp(i ^ (j1 | j2));
                if (a < ans) {
                    ans = a;
                    p = i ^ (j1 | j2);
                }
            }
            break;
        }       
        dp[i] = ans;
        prev[i] = p;
        return ans;
    }

    private int sqr(int i) {
        return i * i;
    }

    // ////////////////////////////////////////////////////////////////////
    // Utility functions

    PrintWriter pw;
    BufferedReader in;
    StringTokenizer st;

    void initStreams() throws FileNotFoundException {
        //System.setIn(new FileInputStream("1"));
        in = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(System.out);
    }

    String nextString() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

    int nextInt() throws NumberFormatException, IOException {
        return Integer.parseInt(nextString());
    }

    long nextLong() throws NumberFormatException, IOException {
        return Long.parseLong(nextString());
    }

    double nextDouble() throws NumberFormatException, IOException {
        return Double.parseDouble(nextString());
    }

    static Throwable sError;

    public static void main(String[] args) throws Throwable {
//      Thread t = new Thread(null, new Main(), "1", 1 << 27);
//      t.start();
//      t.join();
        new Main().run();
        if (sError instanceof OutOfMemoryError) {
            throw sError;
        }
//      if (sError != null) {
//          throw sError;
//      }
    }

    public void run() {
        try {
            initStreams();
            solve();
        } catch (Throwable e) {
            sError = e;
        } finally {
            if (pw != null)
                pw.close();
        }
    }
}