#include <cstring>
#include <memory>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <sstream>
#include <limits>
#include <cctype>
#include <string>
#include <iterator>
#include <algorithm>
#include <bitset>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <functional>
#include <utility>
#include <fstream>
#include <tuple>
#include <list>
using namespace std;

#define DEBUG(x)\
    cerr << #x" = " << x << endl;

class Reader {
  public:
    Reader(const string& filename):
            m_stream(filename),
            m_pos(kBufferSize - 1),
            m_buffer(new char[kBufferSize]) {
        next();
    }

    Reader& operator>>(int& value) {
        value = 0;
        while (current() < '0' || current() > '9')
            next();
        while (current() >= '0' && current() <= '9') {
            value = value * 10 + current() - '0';
            next();
        }
        return *this;
    }

  private:
    const int kBufferSize = 32768;

    char current() {
        return m_buffer[m_pos];
    }

    void next() {
        if (!(++m_pos != kBufferSize)) {
            m_stream.read(m_buffer.get(), kBufferSize);
            m_pos = 0;
        }
    }

    ifstream m_stream;
    int m_pos;
    unique_ptr<char[]> m_buffer;
};

template<class T>
ostream& operator << (ostream& out, const vector<T>& v) {
    for (const auto& e : v) {
        out << e << ' ';
    }
    return out;
}

template<class T>
ostream& operator << (ostream& out, const vector<vector<T>>& v) {
    for (const auto& e : v) {
        out << e << '\n';
    }
    return out;
}

template<class T>
istream& operator >> (istream& in, vector<T>& v) {
  for (auto& value : v) {
    cin >> value;
  }
}

using ll = long long;
using ull = unsigned long long;

int main() {
#ifdef INFOARENA
    ifstream cin("loto.in");
    ofstream cout("loto.out");
#endif
    int N, S;
    vector<int> numbers;

    cin >> N >> S;
    numbers.resize(N);
    cin >> numbers;

    unordered_map<int, tuple<int, int, int>> m;

    for (int n1 : numbers) {
      for (int n2 : numbers) {
        for (int n3 : numbers) {
          m[n1 + n2 + n3] = make_tuple(n1, n2, n3);
        }
      }
    }

    for (int n1 : numbers) {
      for (int n2 : numbers) {
        for (int n3 : numbers) {
          auto it = m.find(S - (n1 + n2 + n3));
          if (it != m.end()) {
            auto tup = it->second;
            cout << get<0>(tup) << ' ' << get<1>(tup) << ' ' << get<2>(tup) << ' '
              << n1 << ' ' << n2 << ' ' << n3 << endl;
            return 0;
          }
        }
      }
    }

    cout << -1 << endl;
    return 0;
}