#include <bits/stdc++.h>

using namespace std;

ifstream fin("order.in");
ofstream fout("order.out");

struct T{
    int key;
    int priority;
    int number;
    T *left;
    T *right;
    T(){};
    T(int key, int priority, int number, T *left, T *right)
    {
        this -> key = key;
        this -> number = number;
        this -> priority = priority;
        this -> left = left;
        this -> right = right;
    }

} *Root, *NIL; // nod gol

void init(T* &Root) {
    srand(unsigned(time(0)));
    Root = NIL = new T(0, 0, 0, NULL, NULL);
}

inline void rotateRight(T* &node)
{
    T *tmp = node -> left;
    node -> number -= node -> left -> number;
    if(tmp -> right != NIL)
        tmp -> number -= tmp -> right -> number;


    node -> left = tmp -> right;
    if(tmp -> right != NIL)
    node -> number += tmp -> right -> number;

    tmp -> right = node;
    tmp -> number += node -> number;

    node = tmp;
}

inline void rotateLeft(T* &node)
{
    T *tmp = node -> right;
    node -> number -= node -> right -> number;
    if(tmp -> left != NIL)
        tmp -> number -= tmp -> left -> number;


    node -> right = tmp -> left;
    if(tmp -> left != NIL)
    node -> number += tmp -> left -> number;

    tmp -> left = node;
    tmp -> number += node -> number;

    node = tmp;
}
inline void balance(T* &node)
{
    if(node -> left!= NIL && node -> left -> priority > node -> priority)
    {
        rotateRight(node);
    }
    else if(node -> right != NIL && node -> right -> priority > node -> priority)
        {
            rotateLeft(node);
        }
}

inline void insert(T* &node, const int &value, const int &priority)
{
    int leftN = 0, rightN = 0;
    if(node == NIL)
    {
        node = new T(value, priority, 1, NIL, NIL);
        return;
    }
    if(node -> key > value)
    {
        insert(node -> left, value, priority);

    }
    else if(node -> key < value)
         {
             insert(node -> right, value, priority);
         }
    if(node -> left != NIL)
        leftN = node -> left -> number;
    if(node -> right != NIL)
        rightN = node -> right -> number;
    node -> number = leftN + rightN + 1;
     //node -> number ++;
    balance(node);
    //node -> number ++;
}

inline bool search(T* &node, const int &value)
{
    if(node == NIL)
    {
        return false;
    }

    if(node -> key == value)
    {
        return true;
    }

    if(node -> key > value)
    {
        search(node -> left, value);
    }
    else
    {
        search(node -> right, value);
    }
}

inline void erase(T* &node, const int &value)
{
    int leftP = 0, rightP = 0;
    if(node == NIL)
    {
        return;
    }
    if(node -> key > value)
    {
        erase(node -> left, value);
        node -> number --;
    }
    else if(node -> key < value)
         {
            erase(node -> right, value);
            node -> number --;
         }
         else
         {
             if(node -> left == NIL && node -> right == NIL) // e frunza
             {
                 delete node;
                 node = NIL;
             }
             else
             {
                 if(node -> left != NIL)
                 {
                     leftP = node -> left -> priority;
                 }
                 if(node -> right != NIL)
                 {
                     rightP = node -> right -> priority;
                 }
                 if(leftP > rightP)
                 {
                     rotateRight(node);
                 }
                 else
                 {
                     rotateLeft(node);
                 }
                 erase(node, value);
                 //node -> number --;
             }
         }
}

inline void queryK(T* &node, const int &x)
{

    int leftN = 0;
    if(node -> left != NIL)
        leftN = node -> left -> number;
    if(leftN + 1 == x)
    {
        fout << node -> key << ' ';
        erase(Root, node -> key);
        return;
    }

    if(leftN + 1 > x)
        queryK(node -> left, x);
    else
        queryK(node -> right, x - leftN - 1);
}

int main()
{
    init(Root);
    int N; fin >> N;
    int nr = 0;
    for(int i = 1; i <= N; i ++)
    {
        insert(Root, i, rand());
    }
    int copii = N;
    int position = 1;
    for(int i = 1; i <= N; i++)
    {
        position += i;
        position = ((position - 1) % copii) + 1;
        queryK(Root, position);
        position -= 1;
        copii--;
    }

    return 0;
}