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

using namespace std;

struct Treap {
    long long val;
    int len;
    Treap *left, *right;
    int prior;

    Treap (long long a = 0):
    val(a), len(1), left(NULL), right(NULL), prior(rand()) {}
};

void update(Treap *x) {
    if (x == NULL)
    return;
    x->len = ((x->left) ? x->left->len : 0) + ((x->right) ? x->right->len : 0) + 1;
}

Treap *merge(Treap *l, Treap *r) {
    if (l == NULL)
    return r;
    if (r == NULL)
    return l;
    if (l->prior < r->prior) {
        r->left = merge(l, r->left);
        update(r);
        return r;
    } else {
        l->right = merge(l->right, r);
        update(l);
        return l;
    }
}

void split(Treap *root, Treap *&l, Treap *&r, int sz_left) {
    if (root == NULL) {
        l = r = NULL;
        return;
    }
    int lsz = (root->left) ? root->left->len : 0;
    if (sz_left <= lsz) {
        Treap *tmp_l, *tmp_r;
        split(root->left, tmp_l, tmp_r, sz_left);
        root->left = tmp_r;
        l = tmp_l,
        r = root;
    } else {
        Treap *tmp_l, *tmp_r;
        split(root->right, tmp_l, tmp_r, sz_left - lsz - 1);
        root->right = tmp_l;
        l = root,
        r = tmp_r;
    }
    update(root);
}

void add(Treap *&root, int pos, int val) {
    Treap *z = new Treap(val), *l, *r;
    split(root, l, r, pos);
    root = merge(merge(l, z), r);
}

void print(Treap *root) {
    if (root == NULL)
    return;
    print(root->left);
    cout << root->val << " ";
    print(root->right);
}

Treap *root = NULL;

int main() {

    int n, m; cin >> n >> m;
    int l, r;
    Treap *left, *mid, *right;
    for (int i = 0; i < n; i++){
        add(root, i, i + 1);
    }
    for (int i = 0; i < m; i++) {
        cin >> l >> r;
        l--;
        r--;
        split(root, left, right, r + 1);
        split(left, left, mid, l);
        root = merge(merge(mid, left), right);
    }
    print(root);
    cout << '\n';
    return 0;
}