#include <cmath>

#include <cstdio>

#include <vector>

#include <iostream>

#include <algorithm>

using namespace std;

struct node {

    long value, size;

    int prev;

    node *left, *right;

};

const long MAX_N = 100000l;

node nodes[MAX_N];

long values[MAX_N];

//    Get Tree Size

long size(node *p)

{

    return p ? p->size : ;

}

//    Tree Operations

//

node *merge(node *l, node *r)

{

    if (!l) return r;

    if (!r) return l;

    if (l->prev > r->prev)

    {

        l->right = merge(l->right, r);

        l->size = size(l->left) + size(l->right) + ;

        return l;

    }

    //    l is on left of r: append l to r's left

    r->left = merge(l, r->left);

    r->size = size(r->left) + size(r->right) + ;

    return r;

}

//    split tree p by inx, to l and r

void split(node *p, long inx, node *&l, node *&r)

{

    if (!p)

    {

        l = r = nullptr;

        return;

    }

    long cur = size(p->left) + ;

    if (cur <= inx)

    {

        split(p->right, inx - cur, p->right, r);

        l = p;

    }

    else

    {

        split(p->left, inx, l, p->left);

        r = p;

    }

    p->size = size(p->left) + size(p->right) + ;

}

//

node *extract(node *&p, long from, long to)

{

    node *l, *m, *r;

    split(p, from, l, m);

    split(m, to - from, m, r);

    p = merge(l, r);

    return m;

}

//    Traversal

long preorder(node *p, long i/*from inx*/) // return new start inx

{

    if (!p) return i;

    i = preorder(p->left, i);

    values[i++] = p->value;

    return preorder(p->right, i);

}

int main()

{

    for (long i = ; i != MAX_N; ++i) {

        nodes[i].prev = rand();

        nodes[i].size = ;

    }

    long n, m;

    cin >> n >> m;

    node *tree = nullptr;

    for (long i = ; i != n; ++i) {

        cin >> nodes[i].value;

        tree = merge(tree, nodes + i);

    }

    for (long i = ; i != m; ++i) {

        long l, r;

        int type;

        cin >> type >> l >> r;

        node *sub = extract(tree, l - , r);

        if (type == )

            tree = merge(sub, tree);

        else

            tree = merge(tree, sub);

    }

    //    Serialize tree

    preorder(tree, );

    cout << abs(values[] - values[n-]) << endl;

    for (long i = ; i < n; ++i)

        cout << values[i] << " ";

    cout << endl;

    return ;

}