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 CPP):

Solution:
#include <bits/stdc++.h>
namespace utils {
template <class T, class V>
void fill(T& v, const int& n, const V& value);
template <class T>
void copy(const T& s, T& t);
template <class T>
void copy(const T& s, const int& n, T& t);
template <class T>
void sort(T& v);
template <class T>
void sort(T& v, const int& n);
}  // namespace utils
namespace utils {
template <class T>
void max(T& a, const T& b);
template <class T>
void min(T& a, const T& b);
template <class T>
std::string to_string(const T& v);
template <class T>
T to_type(const std::string& s);
}  // namespace utils
namespace solution {
struct Input;
struct Output;
struct Storages {
  Input* in;
  Output* out;
};
}  // namespace solution
namespace solution {
struct SolverInterface {
  virtual ~SolverInterface() {}
  virtual const Output* solve(const Input* in, Output* out) = 0;
};
}  // namespace solution
namespace solution {
struct SolutionInterface {
  virtual ~SolutionInterface(){};
  virtual int run() = 0;
  virtual bool action() = 0;
  virtual bool input(Input* s) = 0;
  virtual void output(const Output* s) = 0;
  virtual void before_all_actions() {}
  virtual void after_all_actions() {}
  virtual void before_action(const int& test_no) {}
  virtual void after_action(const int& test_no) {}
  SolverInterface* solver;
  Storages* storages;
};
}  // namespace solution
namespace solution {
struct SolutionBase : SolutionInterface {
  virtual ~SolutionBase(){};
  int run() {
    this->before_all_actions();
    for (;;) {
      this->before_action(-1);
      if (!this->action()) {
        this->after_action(-1);
        break;
      }
      this->after_action(-1);
    };
    this->after_all_actions();
    return 0;
  }
  bool action() {
    if (!this->input(this->storages->in)) {
      return false;
    }
    this->output(solver->solve(this->storages->in, this->storages->out));
    return true;
  }
};
}  // namespace solution
namespace solution {}
namespace solution {
const int SIZE = 300 + 11;
const int NONE = std::numeric_limits<int>::max();
}  // namespace solution
namespace solution {
using namespace utils;
}
namespace solution {
struct Input {
  int N;
  int S;
  std::array<int, SIZE> A;
};
struct Output {
  int best_f;
  int best_K[3];
};
}  // namespace solution
namespace solution {
struct Finder {
  int best_f;
  int best_K[3];
  int C[3];
  void init() {
    best_f = NONE;
    init_c();
  }
  void init_c() {
    fill(C, 3, 0);
    for (auto i = 0; i < in->N; ++i) {
      C[in->A[i] - 3]++;
    }
  }
  int f(const int& k3, const int& k4, const int& k5) {
    return std::abs(C[0] * k3 - C[1] * k4) + std::abs(C[1] * k4 - C[2] * k5);
  }
  int get_sum(const int& k3, const int& k4, const int& k5) {
    return k3 * C[0] + k4 * C[1] + k5 * C[2];
  }
  void find() {
    for (auto k3 = in->S / in->N; k3 >= 0; --k3) {
      for (auto k4 = (in->S - k3 * C[0]) / (in->N - C[0]); k4 >= k3; --k4) {
        int mid = (in->S - k3 * C[0] - k4 * C[1]) / (in->N - C[0] - C[1]);
        if (mid * C[2] - k4 * C[1] > best_f) break;
        if (get_sum(k3, k4, mid) == in->S) {
          auto ret = f(k3, k4, mid);
          if (ret < best_f) {
            best_f = ret;
            best_K[0] = k3;
            best_K[1] = k4;
            best_K[2] = mid;
          }
        }
        continue;
        int lb = 0;
        int ub = in->S + 1;
        while (ub - lb > 1) {
          int mid = (lb + ub) * 0.5;
          auto sum = get_sum(k3, k4, mid);
          if (sum <= in->S) {
            if (sum == in->S) {
              auto ret = f(k3, k4, mid);
              if (ret < best_f) {
                best_f = ret;
                best_K[0] = k3;
                best_K[1] = k4;
                best_K[2] = mid;
              }
            }
            lb = mid;
          } else {
            ub = mid;
          }
        }
      }
    }
  }
  const Input* in;
  Finder(const Input* in) : in(in) { init(); }
  static std::unique_ptr<Finder> create(const Input* in) {
    return std::unique_ptr<Finder>(new Finder(in));
  }
};
struct Solver : SolverInterface {
  const Output* solve(const Input* in, Output* out) {
    auto finder = Finder::create(in);
    finder->find();
    if (finder->best_f != NONE) {
      out->best_f = finder->best_f;
      for (auto i = 0; i < 3; ++i) {
        out->best_K[i] = finder->best_K[i];
      }
    } else {
      out->best_f = NONE;
    }
    return out;
  }
};
}  // namespace solution
namespace solution {
struct Solution : SolutionBase {
  bool input(Input* in) {
    if (!(std::cin >> in->N >> in->S)) return false;
    for (auto i = 0; i < in->N; ++i)
      if (!(std::cin >> in->A[i])) return false;
    return true;
  }
  void output(const Output* out) {
    if (out->best_f != NONE) {
      for (auto i = 0; i < 3; ++i) {
        std::cout << out->best_K[i] << " ";
      }
      std::cout << std::endl;
    } else {
      std::cout << -1 << std::endl;
    }
  }
};
}  // namespace solution
int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  using namespace solution;
  static Input in;
  static Output out;
  static Storages storages;
  static Solution solution;
  static Solver solver;
  storages.in = &in;
  storages.out = &out;
  solution.storages = &storages;
  solution.solver = &solver;
  return solution.run();
}
namespace utils {
template <class T, class V>
void fill(T& v, const int& n, const V& value) {
  std::fill(std::begin(v), std::begin(v) + n, value);
}
template <class T>
void copy(const T& s, T& t) {
  std::copy(std::begin(s), std::end(s), std::begin(t));
}
template <class T>
void copy(const T& s, const int& n, T& t) {
  std::copy(std::begin(s), std::begin(s) + n, std::begin(t));
}
template <class T>
void sort(T& v) {
  std::sort(std::begin(v), std::end(v));
}
template <class T>
void sort(T& v, const int& n) {
  std::sort(std::begin(v), std::begin(v) + n);
}
}  // namespace utils
namespace utils {
template <class T>
void max(T& a, const T& b) {
  a = std::max(a, b);
}
template <class T>
void min(T& a, const T& b) {
  a = std::min(a, b);
}
template <class T>
std::string to_string(const T& v) {
  std::ostringstream oss;
  oss << v;
  return oss.str();
}
template <class T>
T to_type(const std::string& s) {
  std::istringstream iss(s);
  T res;
  iss >> res;
  return res;
}
}  // namespace utils