1.

/*
 * ACM Contest training
 * Problem: 624 - CD
 * Link: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=8&page=show_problem&problem=565
 *
 * @author Patrick Bedat, Philippe Brousse, Christoph Goettschkes
 * @version 1.0, 11/14/2010
 *
 * Method : Ad-Hoc
 * Status : Accepted
 * Runtime: 0.276
 */

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

import java.util.*;

class Main
{

    static final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static List<Integer> bestSubset;
    static int globalMax;

    public static void main(String[] agrs) throws IOException
    {
        do
        {
            bestSubset = new ArrayList<Integer>();
            globalMax = Integer.MAX_VALUE;
            StringTokenizer tokenizer = new StringTokenizer(reader.readLine());

            int n = Integer.parseInt(tokenizer.nextToken());
            int tracks = Integer.parseInt(tokenizer.nextToken());

            List<Integer> tracksArray = new ArrayList<Integer>();
            for (int i = 0; i < tracks; i++)
                tracksArray.add(Integer.parseInt(tokenizer.nextToken()));

            List<Integer> sorted = new ArrayList<Integer>(tracksArray);
            Collections.sort(sorted);
            Collections.reverse(sorted);

            int s = 0;
            for (int i : tracksArray)
                s += i;

            if (s < n)
            {
                globalMax = n - s;
                bestSubset = tracksArray;
            }
            else
                test(n, tracksArray, s, new ArrayList<Integer>());

            StringBuilder out = new StringBuilder();
            for (int i : bestSubset)
                out.append(i + " ");
            out.append("sum:" + (n - globalMax));
            System.out.println(out);

        }
        while (reader.ready());
    }

    static boolean test(int length, List<Integer> values, int possibleAdd, List<Integer> current)
    {
        if (length < 0)
            return false;

        if (length == 0)
        {
            globalMax = 0;
            bestSubset = current;
            return true;
        }

        if (length - possibleAdd > globalMax)
            return false;

        if (length < globalMax)
        {
            globalMax = length;
            bestSubset = new ArrayList<Integer>(current);
        }
        List<Integer> t = new ArrayList<Integer>(values);
        for (int i = 0; i < values.size(); i++)
        {
            current.add(values.get(i));
            t.remove(0);
            if (test(length - values.get(i), t, possibleAdd - values.get(i), current))
                return true;
            current.remove(current.size() - 1);
        }

        return false;
    }
}