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

public class enchanted_mb {
    static int sumArgMax(int[] a, int[] b) {
        int bestV = a[0] + b[0];
        int bestI = 0;
        for (int i = 1; i < a.length; ++i) {
            int currV = a[i] + b[i];
            if (bestV < currV) {
                bestV = currV;
                bestI = i;
            }
        }
        return bestI;
    }

    static int[] collectSingularArray(int[][] d, int from, int until) {
        int n = until - from;
        int nn = 1 << n;
        int[] rv = new int[nn];
        for (int m = 0; m < nn; ++m) {
            int sum = 0;
            for (int i = 0; i < n; ++i) {
                if ((m & (1 << i)) == 0) continue;
                for (int j = i; j < n; ++j) {
                    if ((m & (1 << j)) == 0) continue;
                    sum += d[from + i][from + j];
                }
            }
            rv[m] = sum;
        }
        return rv;
    }

    static int[][] constructPartialArray(int[][] d, int lFrom, int lUntil, int rFrom, int rUntil, boolean collectLeft) {
        int n0 = lUntil - lFrom;
        int n1 = rUntil - rFrom;
        int nn0 = 1 << n0;
        int nn1 = 1 << n1;

        int[] sum1 = collectLeft ? collectSingularArray(d, lFrom, lUntil)
                                 : collectSingularArray(d, rFrom, rUntil);

        int[] partial = new int[n1];

        int[][] rv = new int[nn0][nn1];
        for (int m0 = 0; m0 < nn0; ++m0) {
            Arrays.fill(partial, 0);
            for (int i = 0; i < n0; ++i) {
                if ((m0 & (1 << i)) == 0) continue;
                for (int j = 0; j < n1; ++j) {
                    partial[j] += d[lFrom + i][rFrom + j];
                }
            }
            for (int m1 = 0; m1 < nn1; ++m1) {
                int sum = sum1[collectLeft ? m0 : m1];
                for (int j = 0; j < n1; ++j) {
                    if ((m1 & (1 << j)) == 0) continue;
                    sum += partial[j];
                }
                rv[m0][m1] = sum;
            }
        }

        return rv;
    }

    public static void main(String[] args) throws IOException {
        try (BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
             PrintWriter out = new PrintWriter(System.out)) {
            String symbols = in.readLine();
            int n = symbols.length();
            int[][] d = new int[n][n];
            for (int i = 0; i < n; ++i) {
                StringTokenizer st = new StringTokenizer(in.readLine());
                for (int j = i; j < n; ++j) {
                    d[i][j] = Integer.parseInt(st.nextToken());
                }
            }

            int n0 = n / 3;
            int n1 = (n - n0) / 2;
            int n01 = n0 + n1;

            int nn0 = 1 << n0, nn1 = 1 << n1;

            int[][] p01 = constructPartialArray(d, 0, n0, n0, n01, true);
            int[][] p02 = constructPartialArray(d, 0, n0, n01, n, false);
            int[][] p12 = constructPartialArray(d, n0, n01, n01, n, true);

            int answerMask = 0;
            int answer = -1;
            for (int m0 = 0; m0 < nn0; ++m0) {
                for (int m1 = 0; m1 < nn1; ++m1) {
                    int bestM2 = sumArgMax(p02[m0], p12[m1]);
                    int currAnswer = p01[m0][m1] + p02[m0][bestM2] + p12[m1][bestM2];
                    if (answer < currAnswer) {
                        answer = currAnswer;
                        answerMask = m0 ^ (m1 << n0) ^ (bestM2 << n01);
                    }
                }
            }

            out.println(Integer.bitCount(answerMask));
            for (int i = 0; i < n; ++i) {
                if ((answerMask & (1 << i)) != 0) {
                    out.print(symbols.charAt(i));
                }
            }
            out.println();
        }
    }
}