// compile: make data
// run: ./data < data.in
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
#ifdef LOCAL
#include <debug/codeforces.h>
#define debug(x...) _debug_print(#x, x);
#define Debug(x...) _debug_print_format(#x, x);
std::ifstream terminal("/dev/tty");
#define PP cerr<<"\033[1;30mpause...\e[0m",terminal.ignore();
#else
#define debug(x...)
#define Debug(x...)
#define PP
#endif
template<typename...Args> void print_(Args...args){((cout<<args<<" "),...)<<endl;}
#define rep(i,a,b) for(int i=(a);i<(int)(b);++i)
#define sz(v) ((int)(v).size())
#define print(...) print_(__VA_ARGS__);
#define FIND(a, x) ((find(a.begin(),a.end(),(x))!=a.end())?1:0)
#define cmin(x,...) x=min({(x),__VA_ARGS__})
#define cmax(x,...) x=max({(x),__VA_ARGS__})
#define INTMAX (int)(9223372036854775807)
// #define INF (int)(1152921504606846976)
#define NaN (int)(0x8b88e1d0595d51d1)
#define double long double
#define int long long
#define uint unsigned long long
#define MAXN 200010

template <class T> struct treap {
    struct node {
        node *ch[2];
        int rd, size;
        T val;
    };
    node *root = nullptr;
    vector<node> pool;
    treap(int N) {
        pool.resize(N);
    }
    int total = 0;
    node *newnode(T val) {
        node *x = &pool[total++];
        x->val = val;
        x->rd = rand();
        x->size = 1;
        return x;
    }
    int getsize(node *x) {return x ? x->size : 0; }
    void pushup(node *x) {
        if (!x) return;
        x->size = getsize(x->ch[0]) + getsize(x->ch[1]) + 1;
    }
    void pushdown(node *x) {
        if (x) return;
    }
    pair<node*, node*> split(node *x, int size) {
        if (!x) return {nullptr, nullptr};
        pushdown(x);
        if (size <= getsize(x->ch[0])) {
            auto [lc, rc] = split(x->ch[0], size);
            x->ch[0] = rc;
            pushup(x);
            return {lc, x};
        }
        auto [lc, rc] = split(x->ch[1], size - getsize(x->ch[0]) - 1);
        x->ch[1] = lc;
        pushup(x);
        return {x, rc};
    }
    node *merge(node *x, node *y) {
        if (!x && !y) return nullptr;
        if (!x) return y;
        if (!y) return x;
        pushdown(x), pushdown(y);
        if (x->rd < y->rd) {
            x->ch[1] = merge(x->ch[1], y);
            pushup(x);
            return x;
        }
        y->ch[0] = merge(x, y->ch[0]);
        pushup(y);
        return y;
    }
    void insert(T val, int rank) {
        auto [l, r] = split(root, rank);
        node *mid = merge(l, newnode(val));
        root = merge(mid, r);
    }
    vector<T> inorder() {
        vector<T> res;
        stack<node*> st;
        for (node *x = root; x || sz(st); ) {
            if (x) st.push(x), x = x->ch[0];
            else {
                x = st.top(); st.pop();
                res.push_back(x->val);
                x = x->ch[1];
            }
        }
        return res;
    }
    tuple<node*, node*, node*> interval(int l, int r) {
        auto [L, y] = split(root, r+1);
        auto [x, mid] = split(L, l);
        return {x, mid, y};
    }
    void graphviz_dump(string filename = "graph.dot") {
        FILE *f = fopen(filename.c_str(), "w");
        fprintf(f, "digraph {\n");
        rep(i, 0, total) {
            node *x = &pool[i];
            fprintf(f, "%lld.c_str());
            rep(j, 1, sz(desired)) fprintf(f, " | %s", desired[j].c_str());
            fprintf(f, "\" shape=\"record\"];\n");
        }
        rep(i, 0, total) {
            node *x = &pool[i];
            if (x->ch[0]) fprintf(f, "    %lld -> %ld;\n", i, x->ch[0] - &pool[0]);
            if (x->ch[1]) fprintf(f, "    %lld -> %ld;\n", i, x->ch[1] - &pool[0]);
        }
        fprintf(f, "}\n");
    }
    void solve(int l, int r) {
        auto [x, mid, y] = interval(l, r);
        root = merge(merge(x, y), mid);
    }
};
    // struct value {
    //     int c;
    // };

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

    int n, q; cin >> n >> q;
    string s; cin >> s;
    struct value {
        int c;
    };
    treap<value> t(sz(s));
    rep(i, 0, sz(s)) t.insert({s[i]}, i);

    while (q--) {
        int l, r; cin >> l >> r; --l, --r;
        t.solve(l, r);
    }

    auto v = t.inorder();
    rep(i, 0, sz(v)) cout << (char)v[i].c;
    cout << endl;
    // t.graphviz_dump();

    return 0;
}