#include <iostream>
#include <fstream>
#include <cstdlib>
#include <ctime>
using namespace std;
ifstream fin("order.in");
ofstream fout("order.out");

struct T{
    int key, priority, s;
    T *left, *right;
    void sum()
    {
        s = 1;
        if (left)
            s += this->left->s;
        if (right)
            s += this->right->s;
    }
    T(int k, int p, T* l, T* r)
    {
        key = k;
        priority = p;
        left = l;
        right = r;
        sum();
    }
};
T *R, *nil;

void init()
{
    srand( time ( 0 ) );
    R = nil = new T(0, 0, 0, 0);
    R->s = 0;
    nil->s = 0;
}

void rotL(T* &n)
{
    T* x = n->left;
    n->left = x->right;
    x-> right =  n;
    n->sum();
    n = x;
    n->sum();
}

void rotR(T* &n)
{
    T* x = n->right;
    n->right = x->left;
    x->left = n;
    n->sum();
    n = x;
    n->sum();
}

void balance(T* &n)
{
    if(n->left->priority > n->priority)
        rotL(n);
    else if(n->right->priority > n->priority)
        rotR(n);
}

void insert(T* &n, int key, int priority)
{
    if(n==nil)
    {
        n = new T(key, priority, nil, nil);
        return;
    }
    if(n->key > key)
    {
        insert(n->left, key, priority);
    }
    else if(n->key < key)
    {
        insert(n->right, key, priority);
    }
    n->sum();
    balance(n);
}

void erase(T* &n, int key)
{
    if(n==nil)
        return;
    if(n->key > key)
    {
        erase(n->left, key);
        n->sum();
    }
    else if(n->key < key)
    {
        erase(n->right, key);
        n->sum();
    }
    else
    {
        if(n->left == nil && n->right == nil)
        {
            delete n;
            n = nil;
            return;
        }
        if(n->left->priority > n->right->priority)
        {
            rotL(n);
            erase(n->right, key);
        }
        else
        {
            rotR(n);
            erase(n->left, key);
        }
        n->sum();
    }
}

int kth_key(T* &n, int nr)
{
    if(nr > n->s)
        return -1;
    if(n->left->s >= nr)
        return kth_key(n->left, nr);
    if(n->left->s + 1 == nr)
        return n->key;
    else
        return kth_key(n->right, nr-(n->left->s+1));
}

void af(T* &n)
{
    if(n==nil)
        return;
    af(n->left);
    cout << n->key << " ";
    af(n->right);
}

int main()
{
    int n, i, ind, val;
    init();
    fin>>n;
    for(i=n;i>=1;i--)
    {
        insert(R, i, rand()+1);
    }
    ind=1;
    for(i=1;i<=n;i++)
    {
        ind += i-1;
        ind = ind % R->s;
        val = kth_key(R, ind+1);
        fout << val << " ";
        erase(R, val);
    }

}