#include <iostream>
#include <vector>
#include <random>

using namespace std;

mt19937 mt(41);

struct node {

    int val, y;
    size_t sz;
    node *left, *right;
    bool rev;

    explicit node(int val) : val(val), y(mt()), sz(1), left(nullptr), right(nullptr), rev(false) {}
};

node *root = nullptr;

int calc_size(node *v) {
    if (v != nullptr) {
        return v->sz;
    }
    return 0;
}

static void upd(node *v) {
    v->sz = calc_size(v->left) + calc_size(v->right) + 1;
}

static void push(node *v) {
    if (v != nullptr && v->rev) {
        v->rev = false;
        swap(v->left, v->right);
        if (v->left != nullptr) v->left->rev ^= 1;
        if (v->right != nullptr) v->right->rev ^= 1;
    }
}

node *merge(node *left, node *right) {
    if (left == nullptr) return right;
    if (right == nullptr) return left;

    push(left), push(right);

    if (left->y > right->y) {
        left->right = merge(left->right, right);
        upd(left);
        root = left;
    } else {
        right->left = merge(left, right->left);
        upd(right);
        root = right;
    }
    return root;
}

pair<node *, node *> split(node *v, int x) {

    if (v == nullptr) return {nullptr, nullptr};

    if (v->val <= x) {
        auto[rl, rr] = split(v->right, x);
        v->right = rl;
        upd(v);
        return {v, rr};
    } else {
        auto[ll, lr] = split(v->left, x);
        v->left = ll;
        upd(v);
        return {lr, v};
    }
}

static void insert(int x) {
    auto[le, ri] = split(root, x);
    node *v = new node(x);
    merge(le, merge(v, ri));
}

pair<node *, node *> split_on_size(node *v = root, int x = 0) {
    if (v == nullptr) return {nullptr, nullptr};
    push(v);
    if (calc_size(v->left) >= x) {
        auto[ll, lr] = split_on_size(v->left, x);
        v->left = lr;
        upd(v);
        return {ll, v};
    } else {
        auto[rl, rr] = split_on_size(v->right, x - calc_size(v->left) - 1);
        v->right = rl;
        upd(v);
        return {v, rr};
    }
}

static void reverse(int l, int r, node *v = root) {
    auto[ll, ri] = split_on_size(v, l - 1);
    auto[mid, rr] = split_on_size(ri, r - l + 1);
    mid->rev ^= 1;
    merge(ll, merge(mid, rr));
}

static void print(node *v = root) {
    push(v);
    if (v->left != nullptr) {
        print(v->left);
    }
    cout << v->val << " ";
    if (v->right != nullptr) {
        print(v->right);
    }
}


int main() {
    ios_base::sync_with_stdio(false);

    int n, m, l, r;
    cin >> n >> m;
    root = new node(1);
    for (int i = 2; i < n + 1; i++) {
        insert(i);
    }
    for (int i = 0; i < m; i++) {
        cin >> l >> r;
        reverse(l, r);
    }

    print(root);
    return 0;
}