#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#include "dzilib.h"
using namespace std;

// #define FOR(i, n) for (int i = 0; i < n; i++)
#define f first
#define s second
#define pb push_back
#define all(s) s.begin(), s.end()
#define sz(s) (int)s.size()

#define FOR(i, l, r) for (int i = (l); i <= (r); ++i)
#define REP(i, n) FOR(i, 0, (n)-1)
#define ssize(x) int(x.size())

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define losuj(a, b) uniform_int_distribution<long long>(a, b)(rng)

using vi = vector<int>;
using ll = long long;
using ull = unsigned long long;
using pll = pair<ll, ll>;
using pull = pair<ull, ull>;
using vll = vector<ll>;
using ii = pair<int, int>;

namespace PollardRho
{
    mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
    const int P = 1e6 + 9;
    ll seq[P];
    int primes[P], spf[P];
    inline ll add_mod(ll x, ll y, ll m)
    {
        return (x += y) < m ? x : x - m;
    }
    inline ll mul_mod(ll x, ll y, ll m)
    {
        ll res = __int128(x) * y % m;
        return res;
        // ll res = x * y - (ll)((long double)x * y / m + 0.5) * m;
        // return res < 0 ? res + m : res;
    }
    inline ll pow_mod(ll x, ll n, ll m)
    {
        ll res = 1 % m;
        for (; n; n >>= 1)
        {
            if (n & 1)
                res = mul_mod(res, x, m);
            x = mul_mod(x, x, m);
        }
        return res;
    }
    // O(it * (logn)^3), it = number of rounds performed
    inline bool miller_rabin(ll n)
    {
        if (n <= 2 || (n & 1 ^ 1))
            return (n == 2);
        if (n < P)
            return spf[n] == n;
        ll c, d, s = 0, r = n - 1;
        for (; !(r & 1); r >>= 1, s++)
        {
        }
        // each iteration is a round
        for (int i = 0; primes[i] < n && primes[i] < 32; i++)
        {
            c = pow_mod(primes[i], r, n);
            for (int j = 0; j < s; j++)
            {
                d = mul_mod(c, c, n);
                if (d == 1 && c != 1 && c != (n - 1))
                    return false;
                c = d;
            }
            if (c != 1)
                return false;
        }
        return true;
    }
    void init()
    {
        int cnt = 0;
        for (int i = 2; i < P; i++)
        {
            if (!spf[i])
                primes[cnt++] = spf[i] = i;
            for (int j = 0, k; (k = i * primes[j]) < P; j++)
            {
                spf[k] = primes[j];
                if (spf[i] == spf[k])
                    break;
            }
        }
    }
    // returns O(n^(1/4))
    ll pollard_rho(ll n)
    {
        while (1)
        {
            ll x = rnd() % n, y = x, c = rnd() % n, u = 1, v, t = 0;
            ll *px = seq, *py = seq;
            while (1)
            {
                *py++ = y = add_mod(mul_mod(y, y, n), c, n);
                *py++ = y = add_mod(mul_mod(y, y, n), c, n);
                if ((x = *px++) == y)
                    break;
                v = u;
                u = mul_mod(u, abs(y - x), n);
                if (!u)
                    return __gcd(v, n);
                if (++t == 32)
                {
                    t = 0;
                    if ((u = __gcd(u, n)) > 1 && u < n)
                        return u;
                }
            }
            if (t && (u = __gcd(u, n)) > 1 && u < n)
                return u;
        }
    }
    vector<ll> factorize(ll n)
    {
        if (n == 1)
            return vector<ll>();
        if (miller_rabin(n))
            return vector<ll>{n};
        vector<ll> v, w;
        while (n > 1 && n < P)
        {
            v.push_back(spf[n]);
            n /= spf[n];
        }
        if (n >= P)
        {
            ll x = pollard_rho(n);
            v = factorize(x);
            w = factorize(n / x);
            v.insert(v.end(), w.begin(), w.end());
        }
        return v;
    }

    vector<pair<ll, int>> get_pairs(vector<ll> factors)
    {
        sort(factors.begin(), factors.end());
        vector<pair<ll, int>> ret;
        assert(sz(factors));
        ret.pb({factors[0], 0});
        for (auto &f : factors)
        {
            if (ret.back().f == f)
            {
                ret.back().s++;
            }
            else
            {
                ret.pb({f, 1});
            }
        }
        return ret;
    }
    
    int num_divisors(ll val)
    {
        auto factors = get_pairs(factorize(val));
        
        int ret = 1;
        for (auto &[p, cnt] : factors)
        {
            ret *= (cnt + 1);
        }
        return ret;
    }
}

const ll BIG_INF = 1e18;

ll pow(ll a, int b)
{
    ll ret = 1;
    while (b)
    {
        if (b & 1)
        {
            if (ret > BIG_INF / a)
                return BIG_INF;
            ret *= a;
        }
        if (b > 1)
        {
            if (a > BIG_INF / a)
                return BIG_INF;
            a *= a;
        }
        b >>= 1;
    }
    return ret;
}

const int N = 2e7 + 5;
int sito[N];
int divs[N];
const ll C = 1e17;
vi primes;

// ll min_val(int ile, set<int> used)
// {
//     auto factors = get_pairs(factorize(ile));
//     vi wykladniki;
//     for (auto & [p, cnt] : factors)
//     {
//         wykladniki.pb(cnt);
//     }
//     ll ret = 1;

//     sort(all(wykladniki));
//     reverse(all(wykladniki));

//     int last_prime = 0;
//     for (auto & wyk : wykladniki)
//     {
//         while (used.count(primes[last_prime]))
//             last_prime++;
//         ll more = pow(primes[last_prime], wyk);
//         last_prime++;
//         if (ret > BIG_INF / more)
//             return BIG_INF;
//         ret *= more;
//     }
//     return ret;
// }

void prep()
{
    for (int i = 2; i < N; i++)
    {
        if (sito[i] == 0)
        {
            primes.pb(i);
            for (ll j = 1ll * i * i; j < N; j += i)
            {
                if (sito[j] == 0)
                    sito[j] = i;
            }
        }
    }

    for (int i = 1; i < N; i++)
    {
        for (int j = i; j < N; j += i)
        {
            divs[j]++;
        }
    }
}

int main()
{
    PollardRho::init();
    prep();

    // int good = 0;
    // vector<ll> num_divs;
    // ll sum = 0;
    // for (int i = 0; i < 70; ++i)
    // {
    //     ll val = losuj(C - N / 2, C);
    //     // cout << "FACTORIZING " << val << endl;
    //     auto f = PollardRho::factorize(val);

    //     vector<pair<ll, int>> factors = get_pairs(f);
    //     num_divs.pb(num_divisors(factors));
    //     sum += num_divs.back();
    // }
    // sort(all(num_divs));
    // cout << C << ' ' << min_val({2, 2, 2, 2, 2, 2, 2, 2, 2, 2}, {}) << endl;
    // for (int i = 0; i < 30; i++)
    // {
    //     cout << num_divs[i] << ' ';
    // }
    // cout << endl;
    // for (int i = 0; i < 30; i++)
    // {
    //     cout << num_divs[sz(num_divs) - 1 - i] << ' ';
    // }
    // cout << "AVG " << sum / sz(num_divs) << endl;
    // exit(0);
    int t = GetT();
    int q = GetQ();
    long long c = GetC();
    long long n = GetN();

    int queries = q / t;

    // cout << t << ' '  << q << ' ' << c << ' ' << n << endl;

    while (t--)
    {
        if (n <= 1000000)
        {
            vector<int> candidates;
            for (int i = 1; i <= n; i++)
            {
                candidates.pb(i);
            }
            for (int i = 0; i < c; i++)
            {
                int x = Ask(i);
                vector<int> new_candidates;
                for (auto &u : candidates)
                {
                    if (divs[u + i] == x)
                    {
                        new_candidates.pb(u);
                    }
                }
                swap(candidates, new_candidates);
                // assert(sz(candidates));
                if (candidates.size() == 1)
                {
                    break;
                }
            }
            Answer(candidates[0]);
        }
        else
        {
            assert(false);
        }
    }
    return 0;
}