#include <bits/stdc++.h>
using namespace std;
namespace Octane
{
// non terrae plus ultra
#define OCTANE
#define BUFFER_SIZE 100000
#define ll long long
#define db double
#define ldb long double
    char ibuf[BUFFER_SIZE], obuf[BUFFER_SIZE];
    char *p1 = ibuf, *p2 = ibuf, *p3 = obuf;
#ifdef ONLINE_JUDGE
#define getchar() ((p1 == p2) and (p2 = (p1 = ibuf) + fread(ibuf, 1, BUFFER_SIZE, stdin), p1 == p2) ? (EOF) : (*p1++))
#define putchar(x) ((p3 == obuf + BUFFER_SIZE) && (fwrite(obuf, p3 - obuf, 1, stdout), p3 = obuf), *p3++ = x)
#endif // fread in OJ, getchar in local

#define isdigit(ch) (ch > 47 && ch < 58)
#define isspace(ch) (ch < 33 && ch != EOF)

    const ll pow10[] = {
        (ll)1e0,
        (ll)1e1,
        (ll)1e2,
        (ll)1e3,
        (ll)1e4,
        (ll)1e5,
        (ll)1e6,
        (ll)1e7,
        (ll)1e8,
        (ll)1e9,
        (ll)1e10,
        (ll)1e11,
        (ll)1e12,
        (ll)1e13,
        (ll)1e14,
        (ll)1e15,
        (ll)1e16,
        (ll)1e17,
        (ll)1e18,
    };

    struct Octane_t
    {
        ~Octane_t()
        {
            fwrite(obuf, p3 - obuf, 1, stdout);
        }
        bool flag = false;
        operator bool()
        {
            return flag;
        }
    } io;

    template <typename T>
    inline T read()
    {
        T s = 0;
        int w = 1;
        char ch;
        while (ch = getchar(), !isdigit(ch) && (ch != EOF))
            if (ch == '-')
                w = -1;
        if (ch == EOF)
            return 0;
        while (isdigit(ch))
            s = s * 10 + ch - 48, ch = getchar();
        if (ch == '.')
        {
            ll flt = 0;
            int cnt = 0;
            while (ch = getchar(), isdigit(ch))
                if (cnt < 18)
                    flt = flt * 10 + ch - 48, cnt++;
            s += (db)flt / pow10[cnt];
        }
        return s *= w;
    }
    template <typename T>
    inline bool read(T &s)
    {
        s = 0;
        int w = 1;
        char ch;
        while (ch = getchar(), !isdigit(ch) && (ch != EOF))
            if (ch == '-')
                w = -1;
        if (ch == EOF)
            return false;
        while (isdigit(ch))
            s = s * 10 + ch - 48, ch = getchar();
        if (ch == '.')
        {
            ll flt = 0;
            int cnt = 0;
            while (ch = getchar(), isdigit(ch))
                if (cnt < 18)
                    flt = flt * 10 + ch - 48, cnt++;
            s += (db)flt / pow10[cnt];
        }
        return s *= w, true;
    }
    inline bool read(char &s)
    {
        while (s = getchar(), isspace(s))
            ;
        return s != EOF;
    }
    inline bool read(char *s)
    {
        char ch;
        while (ch = getchar(), isspace(ch))
            ;
        if (ch == EOF)
            return false;
        while (!isspace(ch))
            *s++ = ch, ch = getchar();
        *s = '\000';
        return true;
    }
    template <typename T>
    void print(T x)
    {
        static int t[20];
        int top = 0;
        if (x < 0)
            putchar('-'), x = -x;
        do
        {
            t[++top] = x % 10;
            x /= 10;
        } while (x);
        while (top)
            putchar(t[top--] + 48);
    }
    struct empty_type
    {
    };
    int pcs = 8;
    empty_type setpcs(int cnt)
    {
        return pcs = cnt, empty_type();
    }
    inline void print(empty_type x) {}
    inline void print(double x)
    {
        if (x < 0)
            putchar('-'), x = -x;
        x += 5.0 / pow10[pcs + 1];
        print((ll)(x));
        x -= (ll)(x);
        if (pcs != 0)
            putchar('.');
        for (int i = 1; i <= pcs; i++)
            x *= 10, putchar((int)x + '0'), x -= (int)x;
    }
    inline void print(float x)
    {
        if (x < 0)
            putchar('-'), x = -x;
        x += 5.0 / pow10[pcs + 1];
        print((ll)(x));
        x -= (ll)(x);
        if (pcs != 0)
            putchar('.');
        for (int i = 1; i <= pcs; i++)
            x *= 10, putchar((int)x + '0'), x -= (int)x;
    }
    inline void print(char x)
    {
        putchar(x);
    }
    inline void print(char *x)
    {
        for (int i = 0; x[i]; i++)
            putchar(x[i]);
    }
    inline void print(const char *x)
    {
        for (int i = 0; x[i]; i++)
            putchar(x[i]);
    }

// support for string
#ifdef _GLIBCXX_STRING
    inline bool read(std::string &s)
    {
        s = "";
        char ch;
        while (ch = getchar(), isspace(ch))
            ;
        if (ch == EOF)
            return false;
        while (!isspace(ch))
            s += ch, ch = getchar();
        return true;
    }
    inline void print(std::string x)
    {
        for (string::iterator i = x.begin(); i != x.end(); i++)
            putchar(*i);
    }
    inline bool getline(Octane_t &io, string s)
    {
        s = "";
        char ch = getchar();
        if (ch == EOF)
            return false;
        while (ch != '\n' and ch != EOF)
            s += ch, ch = getchar();
        return true;
    }
#endif

// support for initializer_list
#if __cplusplus >= 201103L
    template <typename T, typename... T1>
    inline int read(T &a, T1 &...other)
    {
        return read(a) + read(other...);
    }
    template <typename T, typename... T1>
    inline void print(T a, T1... other)
    {
        print(a);
        print(other...);
    }
#endif

    //  give up iostream
    template <typename T>
    Octane_t &operator>>(Octane_t &io, T &b)
    {
        return io.flag = read(b), io;
    }
    Octane_t &operator>>(Octane_t &io, char *b)
    {
        return io.flag = read(b), io;
    }
    template <typename T>
    Octane_t &operator<<(Octane_t &io, T b)
    {
        return print(b), io;
    }

#define cout io
#define cin io
#define endl '\n'
#undef ll
#undef db
#undef ldb
#undef BUFFER_SIZE
}
using namespace Octane;
#define file(x) freopen(#x ".in", "r", stdin), freopen(#x ".out", "w", stdout)
// #define int long long
const int N = 1e5 + 10;
int L, q;
int p[N];
map<int, pair<int, int>> mp;
signed main()
{
    // file();
    memset(p, 0x3f3f3f, sizeof(p));
    cin >> L >> q;
    for (int i = -L; i <= L; ++i)
        for (int j = i; j <= L; ++j)
            mp[i * i * i + j * j * j] = {i, j};
    for (int i = -L; i <= L; ++i)
        for (int num = 1; num <= 10000; ++num)
        {
            if (abs(p[num]) <= L)
                continue;
            if (mp.count(num - (i * i * i)))
                p[num] = i;
        }
    for (int i = 1, x; i <= q; ++i)
    {
        cin >> x;
        if (abs(p[x]) > L)
            cout << L + 1 << " " << L + 1 << " " << L + 1 << endl;
        else
            cout << p[x] << " " << mp[x - p[x] * p[x] * p[x]].first << " " << mp[x - p[x] * p[x] * p[x]].second << endl;
    }
    cout << endl;
    return 0;
}