#include <algorithm>
#include <cassert>
#include <iostream>
#include <vector>

using namespace std;

class CycledLinkedList {
public:
    struct Node {
        int prev_id, next_id;
    };

    vector<Node> nodes;

    explicit CycledLinkedList(int n = 1) { nodes.reserve(n); }

    void init_cycle(int n) {
        assert(nodes.empty());
        nodes.reserve(n);
        for (int i = 0; i < n; i++) {
            nodes.push_back({(i + n - 1) % n, (i + 1) % n});
        }
    }

    void remove_node(int id) {
        assert(id >= 0 && id < nodes.size());
        if (nodes[id].prev_id != -1) { nodes[nodes[id].prev_id].next_id = nodes[id].next_id; }
        if (nodes[id].next_id != -1) { nodes[nodes[id].next_id].prev_id = nodes[id].prev_id; }
        nodes[id].prev_id = nodes[id].next_id = -1;
    }
};

int cow_amount, good_cards_amount, cards_amount, pass_amount;
CycledLinkedList cards;

vector<int> simulate() {
    vector<int> good_nodes;
    int current_node = 0, previous_node = -1, cow = 1;
    while (good_nodes.size() < good_cards_amount) {
        // clog << "current_node: " << current_node << endl;
        if (cow == 0) { good_nodes.push_back(current_node); }
        previous_node = current_node, current_node = cards.nodes[current_node].next_id;
        cards.remove_node(previous_node);
        if (previous_node == current_node) { break; }
        cow = (cow + 1) % cow_amount;
        for (int _ = 0; _ < pass_amount; _++) {
            current_node = cards.nodes[current_node].next_id;
        }
    }
    return good_nodes;
}


int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> cow_amount >> cards_amount >> pass_amount;
    good_cards_amount = cards_amount / cow_amount;

    cards.init_cycle(cards_amount);

    vector<int> good_nodes = simulate();
    sort(good_nodes.begin(), good_nodes.end());
    for (const int node : good_nodes) {
        cout << node + 1 << endl;
    }

    return 0;
}