#include<iostream>
#include<string>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<vector>

using namespace std;

int AINT[500010];
int Lazy[500010];
int v[500010];

void update(int a, int b, int X, int Y, int K)
{
	if (Lazy[K])
	{
		if (Lazy[K] % 2 != 0)
		{
			AINT[K] = (Y - X + 1) - AINT[K];
		}
		if (X != Y)
		{
			Lazy[K * 2] += Lazy[K];
			Lazy[K * 2 + 1] += Lazy[K];
		}
		Lazy[K] = 0;
	}
	

	if (a <= X && Y <= b)
	{
		if (X != Y)
		{
			Lazy[K * 2] += 1;
			Lazy[K * 2 + 1] += 1;
		}
		AINT[K] = (Y - X + 1) - AINT[K];
		return;
	}
	if (a <= (X + Y) / 2)
	{
		update(a, b, X, (X + Y) / 2, K * 2);
	}
	if (b > (X + Y) / 2)
	{
		update(a, b, (X + Y) / 2 + 1, Y, K * 2 + 1);
	}

	int a1=AINT[K*2];
	int a2=AINT[K*2+1];

	if (Lazy[K * 2] % 2 != 0)
		a1 = ((X + Y) / 2 - X+ 1) - AINT[K * 2];

	if (Lazy[K * 2 + 1] % 2 != 0)
		a2 = (Y - (X+Y)/2) - AINT[K * 2+1];

	AINT[K] = a1 + a2;

}

int query(int a, int b, int X, int Y,int K)
{
	if (Lazy[K])
	{
		if (Lazy[K] % 2 != 0)
		{
			AINT[K] = (Y - X + 1) - AINT[K];
		}
		if (X != Y)
		{
			Lazy[K * 2] += Lazy[K];
			Lazy[K * 2 + 1] += Lazy[K];
		}
		Lazy[K] = 0;
	}

	if (a <= X && Y <= b)
	{
		return AINT[K];
	}

	int a1=0, b1 = 0;
	if (a <= (X + Y) / 2)
		a1=query(a, b, X, (X + Y) / 2, K * 2);
	if (b>(X + Y) / 2)
		b1=query(a, b, (X + Y) / 2 + 1, Y, K * 2 + 1);

	return a1 + b1;
}

int main()
{

	

	int N, M;

	scanf("%d%d", &N, &M);

	int op = 0;

	for (int i = 1; i <= M; ++i)
	{
		scanf("%d",&op);

		if (op == 1)
		{
			int x, y;

			scanf("%d%d", &x, &y);

			update(x, y, 1, N, 1);
		}
		else
		{
			int p;
			scanf("%d", &p);

			int l = p, r = N;
			int l1 = p, r1 = p;
			int x = query(p, p, 1, N, 1);
			while (l <= r)
			{
				int mid = (l + r) / 2;
				
				if (query(p, mid, 1, N, 1) == x*(mid - p + 1))
				{
					r1 = mid;
					l = mid + 1;
				}
				else
					r = mid - 1;
			}

			l = 1, r = p;
		
			


			printf("%d %d %d\n", x, l1, r1);
		}

	}

	return 0;
}