#include <cstdio>
#include <iostream>
#include <fstream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <sstream>
#include <iomanip>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <cstring>
#include <string>
#include <ctime>
#include <cassert>
#include <utility>

using namespace std;

#define MAXN 100050

int N, M, t, a, b, val;
int AL[4 * MAXN][2];
int AR[4 * MAXN][2];
int Aupd[4 * MAXN];

void init(int k, int st, int dr) {
    AL[k][0] = dr - st + 1;
    AR[k][0] = dr - st + 1;
    AL[k][1] = AR[k][1] = 0;
    if(st == dr)
        return;
    int m = (st + dr) / 2;
    init(2 * k, st, m);
    init(2 * k + 1, m + 1, dr);
}

void update(int k, int st, int dr) {
    if(a <= st && dr <= b) {
        if((AL[k] > 0) != (AR[k] > 0))
            throw new exception();
        swap(AL[k][0], AL[k][1]);
        swap(AR[k][0], AR[k][1]);
        Aupd[k] = 1 - Aupd[k];
        return;
    }
    
    if(Aupd[k] != 0) {
        Aupd[2 * k] = 1 - Aupd[2 * k];
        Aupd[2 * k + 1] = 1 - Aupd[2 * k + 1];
        swap(AL[2 * k][0], AL[2 * k][1]);
        swap(AL[2 * k + 1][0], AL[2 * k + 1][1]);
        swap(AR[2 * k][0], AR[2 * k][1]);
        swap(AR[2 * k + 1][0], AR[2 * k + 1][1]);
        Aupd[k] = 0;
    }
    
    int m = (st + dr) / 2;
    if(a <= m)
        update(2 * k, st, m);
    if(b > m)
        update(2 * k + 1, m + 1, dr);
    
    // LEFT
    if(AL[2 * k][0] > 0) { // left = 0
        AL[k][0] = AL[2 * k][0];
        if(AL[2 * k][0] == m - st + 1)
            AL[k][0] += AL[2 * k + 1][0];
        AL[k][1] = 0;
    }
    else { // left = 1
        AL[k][1] = AL[2 * k][1];
        if(AL[2 * k][1] == m - st + 1)
            AL[k][1] += AL[2 * k + 1][1];
        AL[k][0] = 0;
    }
    
    // RIGHT
    if(AR[2 * k + 1][0] > 0) { // right = 0
        AR[k][0] = AR[2 * k + 1][0];
        if(AR[2 * k + 1][0] == dr - m)
            AR[k][0] += AR[2 * k][0];
        AR[k][1] = 0;
    }
    else { // right = 1
        AR[k][1] = AR[2 * k + 1][1];
        if(AR[2 * k + 1][1] == dr - m)
            AR[k][1] += AR[2 * k][1];
        AR[k][0] = 0;
    }
}

int queryToRight(int k, int st, int dr) {
    if(st == dr) {
        val = 0;
        if(AL[k][1] > 0)
            val = 1;
        return 1;
    }
    int m = (st + dr) / 2;
    
    if(Aupd[k] != 0) {
        Aupd[2 * k] = 1 - Aupd[2 * k];
        Aupd[2 * k + 1] = 1 - Aupd[2 * k + 1];
        swap(AL[2 * k][0], AL[2 * k][1]);
        swap(AL[2 * k + 1][0], AL[2 * k + 1][1]);
        swap(AR[2 * k][0], AR[2 * k][1]);
        swap(AR[2 * k + 1][0], AR[2 * k + 1][1]);
        Aupd[k] = 0;
    }
    
    int ret;
    if(a <= m) {
        int crt = queryToRight(2 * k, st, m);
        if(crt == m - a + 1)
            crt += AL[2 * k + 1][val];
        ret = crt;
    }
    else {
        int crt = queryToRight(2 * k + 1, m + 1, dr);
        ret = crt;
    }
    
    return ret;
}

int queryToLeft(int k, int st, int dr) {
    if(st == dr) {
        val = 0;
        if(AR[k][1] > 0)
            val = 1;
        return 1;
    }
    int m = (st + dr) / 2;
    
    if(Aupd[k] != 0) {
        Aupd[2 * k] = 1 - Aupd[2 * k];
        Aupd[2 * k + 1] = 1 - Aupd[2 * k + 1];
        swap(AL[2 * k][0], AL[2 * k][1]);
        swap(AL[2 * k + 1][0], AL[2 * k + 1][1]);
        swap(AR[2 * k][0], AR[2 * k][1]);
        swap(AR[2 * k + 1][0], AR[2 * k + 1][1]);
        Aupd[k] = 0;
    }
    
    int ret;
    if(a <= m) {
        int crt = queryToLeft(2 * k, st, m);
        ret = crt;
    }
    else {
        int crt = queryToLeft(2 * k + 1, m + 1, dr);
        if(crt == a - m)
            crt += AR[2 * k][val];
        ret = crt;
    }
    
    return ret;
}

int main() {
//	freopen("date.in", "r", stdin);
//	freopen("date.out","w", stdout);
	
	scanf("%d %d", &N, &M);
	init(1, 0, N - 1);
	for(int i = 0; i < M; i++) {
        scanf("%d %d", &t, &a);
        a--;
        if(t == 1) {
            scanf("%d", &b);
            b--;
            update(1, 0, N - 1);
        }
        else {
            int L = a - queryToLeft(1, 0, N - 1) + 1;
            int R = a + queryToRight(1, 0, N - 1) - 1;
            
            L++; R++;
            printf("%d %d %d\n", val, L, R);
        }
	}
	
	return 0;
}