Problem: While most students still sit their exams, the tractor college has completed the summer exam session. In fact, students study only one subject at this college — the Art of Operating a Tractor. Therefore, at the end of a term a student gets only one mark, a three (satisfactory), a four (good) or a five (excellent). Those who score lower marks are unfortunately expelled.

The college has n students, and oddly enough, each of them can be on scholarship. The size of the scholarships varies each term. Since the end-of-the-term exam has just ended, it's time to determine the size of the scholarship to the end of next term.

The monthly budget for the scholarships of the Tractor college is s rubles. To distribute the budget optimally, you must follow these rules:

  * The students who received the same mark for the exam, should receive the same scholarship;
  * Let us denote the size of the scholarship (in roubles) for students who have received marks 3, 4 and 5 for the exam, as k3, k4 and k5, respectively. The values k3, k4 and k5 must be integers and satisfy the inequalities 0 ≤ k3 ≤ k4 ≤ k5;
  * Let's assume that c3, c4, c5 show how many students received marks 3, 4 and 5 for the exam, respectively. The budget of the scholarship should be fully spent on them, that is, c3·k3 + c4·k4 + c5·k5 = s;
  * Let's introduce function <image> — the value that shows how well the scholarships are distributed between students. In the optimal distribution function f(k3, k4, k5) takes the minimum possible value. 



Given the results of the exam, and the budget size s, you have to find the optimal distribution of the scholarship.

Input

The first line has two integers n, s (3 ≤ n ≤ 300, 1 ≤ s ≤ 3·105) — the number of students and the budget size for the scholarship, respectively. The second line contains n integers, where the i-th number represents the mark that the i-th student got for the exam. It is guaranteed that at each mark was given to at least one student.

Output

On a single line print three integers k3, k4 and k5 — the sought values that represent the optimal distribution of the scholarships. If there are multiple optimal answers, print any of them. If there is no answer, print -1.

Examples

Input

5 11
3 4 3 5 5


Output

1 3 3


Input

6 15
5 3 3 4 4 5


Output

-1

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;

public class CF200 implements Runnable {

    private static final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

    private BufferedReader in;
    private PrintWriter out;
    private StringTokenizer tok = new StringTokenizer("");

    private void init() throws FileNotFoundException {
        Locale.setDefault(Locale.US);
        String fileName = "";
        if (ONLINE_JUDGE && fileName.isEmpty()) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        } else {
            if (fileName.isEmpty()) {
                in = new BufferedReader(new FileReader("input.txt"));
                out = new PrintWriter("output.txt");
            } else {
                in = new BufferedReader(new FileReader(fileName + ".in"));
                out = new PrintWriter(fileName + ".out");
            }
        }
    }

    String readString() {
        while (!tok.hasMoreTokens()) {
            try {
                tok = new StringTokenizer(in.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return tok.nextToken();
    }

    int readInt() {
        return Integer.parseInt(readString());
    }

    long readLong() {
        return Long.parseLong(readString());
    }

    double readDouble() {
        return Double.parseDouble(readString());
    }

    int[] readIntArray(int size) {
        int[] a = new int[size];
        for (int i = 0; i < size; i++) {
            a[i] = readInt();
        }
        return a;
    }

    public static void main(String[] args) {
        //new Thread(null, new A(), "", 128 * (1L << 20)).start();
        new CF200().run();
    }

    long timeBegin, timeEnd;

    void time() {
        timeEnd = System.currentTimeMillis();
        System.err.println("Time = " + (timeEnd - timeBegin));
    }

    @Override
    public void run() {
        try {
            timeBegin = System.currentTimeMillis();
            init();

            int n = readInt();
            int s = readInt();
            int c3 = 0, c4 = 0, c5 = 0;
            for (int i = 0; i < n; i++) {
                int x = readInt();
                if (x == 3) c3++;
                if (x == 4) c4++;
                if (x == 5) c5++;
            }

//            Random random = new Random();
//            for (int it = 0; it <= 10000; it++) {
//                int sum = 1 + random.nextInt(1000);
//                int a = 1 + random.nextInt(100);
//                int b = 1 + random.nextInt(100);
//                int c = 1 + random.nextInt(100);
//                if (solve(a, b, c, sum) != solveBrut(a, b, c, sum)) {
//                    out.println("PLOHO " + a + " " + b + " " + c + " " + sum);
//                }
//            }

//            solve(54, 24, 2, 572);
//            solveBrut(54, 24, 2, 572);

            solve(c3, c4, c5, s);

            out.close();
            time();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }
    }

    private int aiverson(boolean good) {
        return good ? 1 : 0;
    }

    int[] euclid(int a, int b) {
        if (a == 0) {
            return new int[]{0, 1};
        }
        int[] coeffs = euclid(b % a, a);
        int x1 = coeffs[0];
        int y1 = coeffs[1];
        return new int[]{y1 - b / a * x1, x1};
    }

    int gcd(int a, int b) {
        return a == 0 ? b : gcd(b % a, a);
    }

    int solveBrut(int c3, int c4, int c5, int s) {
        int ansK3 = -1, ansK4 = -1, ansK5 = -1;
        int ans = Integer.MAX_VALUE;

        for (int k3 = 0; k3 <= 1000; k3++) {
            for (int k4 = k3; k4 <= 1000; k4++) {
                int rest = s - c3 * k3 - c4 * k4;
                if (rest % c5 != 0 || rest < 0) continue;
                int k5 = rest / c5;
                if (k5 >= k4) {
                    int f = Math.abs(k3 * c3 - k4 * c4) + Math.abs(k4 * c4 - k5 * c5);
                    if (f <= ans) {
                        ans = f;
                        ansK3 = k3;
                        ansK4 = k4;
                        ansK5 = k5;
                    }
                }
            }
        }
        if (ansK3 == -1) {
            out.println(-1);
        } else {
            out.printf("%d %d %d %d\n", ansK3, ansK4, ansK5, ans);
        }
        return ans;
    }


    int ansK3 = -1, ansK4 = -1, ansK5 = -1;
    int ans = Integer.MAX_VALUE;

    void updateAns(int c3, int k3, int c4, int k4, int c5, int k5, int sum) {
        if (sum != c3 * k3 + c4 * k4 + c5 * k5) return;
        if (k3 >= 0 && k3 <= k4 && k4 <= k5 && ans > f(c3, k3, c4, k4, c5, k5)) {
            ans = f(c3, k3, c4, k4, c5, k5);
            ansK3 = k3;
            ansK4 = k4;
            ansK5 = k5;
        }
    }

    int INF = 1000 * 1000;

    private int solve(int c3, int c4, int c5, int s) throws IOException {

        ans = Integer.MAX_VALUE;
        ansK3 = ansK4 = ansK5 = -1;

        int[] euclid = euclid(c3, c5);
        int gcd = gcd(c3, c5);

        int d3 = c5 / gcd;
        int d5 = c3 / gcd;

        for (int k4 = 0; k4 * (c4 + c5) <= s; k4++) {
            int sum = s - k4 * c4;
            if (sum % gcd != 0) {
                continue;
            }
            int k3_0 = euclid[0] * (sum / gcd);
            int k5_0 = euclid[1] * (sum / gcd);

            int left = -BINSEARCH_BORDER, right = BINSEARCH_BORDER;
            int rightBorder = -INF;
            while (left <= right) {
                int i = (left + right) >> 1;
                if (k3_0 + i * d3 <= k4) {
                    rightBorder = i;
                    left = i + 1;
                } else {
                    right = i - 1;
                }
            }

            left = -BINSEARCH_BORDER;
            right = rightBorder;
            while (left <= right) {
                int i = (left + right) >> 1;
                if (k5_0 - i * d5 >= k4) {
                    rightBorder = i;
                    left = i + 1;
                } else {
                    right = i - 1;
                }
            }

            left = -BINSEARCH_BORDER;
            right = BINSEARCH_BORDER;
            int leftBorder = Integer.MAX_VALUE;
            while (left <= right) {
                int i = (left + right) >> 1;
                if (i * d3 + k3_0 >= 0) {
                    leftBorder = i;
                    right = i - 1;
                } else {
                    left = i + 1;
                }
            }

            left = -BINSEARCH_BORDER;
            right = BINSEARCH_BORDER;
            int border = Integer.MAX_VALUE;
            while (left <= right) {
                int i = (left + right) >> 1;
                if (c3 * (i * d3 + k3_0) <= c4 * k4) {
                    border = i;
                    left = i + 1;
                } else {
                    right = i - 1;
                }
            }
            if (border != Integer.MAX_VALUE && border >= leftBorder && border <= rightBorder) {
                updateAns(c3, border * d3 + k3_0, c4, k4, c5, k5_0 - border * d5, s);
                border++;
                updateAns(c3, border * d3 + k3_0, c4, k4, c5, k5_0 - border * d5, s);
            }

            left = -BINSEARCH_BORDER;
            right = BINSEARCH_BORDER;
            border = Integer.MAX_VALUE;
            while (left <= right) {
                int i = (left + right) >> 1;
                if (c3 * (i * d3 + k3_0) <= c5 * (k5_0 - i * d5)) {
                    border = i;
                    left = i + 1;
                } else {
                    right = i - 1;
                }
            }
            if (border != Integer.MAX_VALUE && border >= leftBorder && border <= rightBorder) {
                updateAns(c3, border * d3 + k3_0, c4, k4, c5, k5_0 - border * d5, s);
                border++;
                updateAns(c3, border * d3 + k3_0, c4, k4, c5, k5_0 - border * d5, s);
            }

            left = -BINSEARCH_BORDER;
            right = BINSEARCH_BORDER;
            border = Integer.MAX_VALUE;
            while (left <= right) {
                int i = (left + right) >> 1;
                if (c5 * (k5_0 - i * d5) <= c4 * k4) {
                    border = i;
                    right = i - 1;
                } else {
                    left = i + 1;
                }
            }
            if (border != Integer.MAX_VALUE && border >= leftBorder && border <= rightBorder) {
                updateAns(c3, border * d3 + k3_0, c4, k4, c5, k5_0 - border * d5, s);
                border++;
                updateAns(c3, border * d3 + k3_0, c4, k4, c5, k5_0 - border * d5, s);
            }


            if (leftBorder <= rightBorder) {
                int k3_1 = k3_0 + leftBorder * d3;
                int k3_2 = k3_0 + rightBorder * d3;
                int k5_1 = k5_0 - leftBorder * d5;
                int k5_2 = k5_0 - rightBorder * d5;
                updateAns(c3, k3_1, c4, k4, c5, k5_1, s);
                updateAns(c3, k3_2, c4, k4, c5, k5_2, s);
            }
        }

        if (ansK4 == -1) {
            out.println(-1);
        } else {
            out.println(ansK3 + " " + ansK4 + " " + ansK5);
        }

        return ans;
    }

    int f(int c3, int k3, int c4, int k4, int c5, int k5) {
        return Math.abs(c3 * k3 - c4 * k4) + Math.abs(c4 * k4 - c5 * k5);
    }

    final int BINSEARCH_BORDER = 1000000;
}