#include<bits/stdc++.h>
#define y0 y000
#define y1 y111
#define j0 j000
#define j1 j111
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 1e5 + 5;
const int mod = 998244353;

inline void add_mod(int &a,int b){ a+=b; if(a>=mod) a-=mod;}

inline ll pw(ll a,ll b)
{
	ll res = 1;
	while(b)
	{
		if(b&1) res=res*a%mod;
		a=a*a%mod; b>>=1;
	}
	return res;
}

struct Matrix
{
	static const int N = 3;
	int a[N][N];
	Matrix(void){ clear();}
	int* operator [] (int x){ return a[x];}
	const int* operator [] (int x) const { return a[x];}
	void clear(void){ memset(a, 0, sizeof(a));}
	void to_unit(void)
	{
		clear();
		for(int i=0; i<N; ++i)
			a[i][i] = 1;
	}
	Matrix operator * (const Matrix &b) const
	{
		Matrix res;
		for(int k=0; k<N; ++k)
			for(int i=0; i<N; ++i)
				for(int j=0; j<N; ++j)
					res[i][j] = (res[i][j] + (ll)a[i][k] * b[k][j]) %mod;
		return res;
	}
	pii calc(ll x,ll y)
	{
		x = (x %mod + mod) %mod;
		y = (y %mod + mod) %mod;
		int resx = (a[0][0] * x + a[0][1] * y + a[0][2]) %mod;
		int resy = (a[1][0] * x + a[1][1] * y + a[1][2]) %mod;
		return {resx, resy};
	}
};

Matrix trans(ll a,ll b,ll c)// flip
{
	a = (a %mod + mod) %mod;
	b = (b %mod + mod) %mod;
	c = (c %mod + mod) %mod;
	
	Matrix res;
	res[0][0] = (b * b - a * a) %mod;
	res[0][1] = -2ll * a * b %mod;
	res[0][2] = -2ll * a * c %mod;
	
	res[1][0] = -2ll * a * b %mod;
	res[1][1] = (a * a - b * b) %mod;
	res[1][2] = -2ll * b * c %mod;
	
	res[2][2] = 1;
	
	ll coef = pw((a * a + b * b) %mod, mod - 2);
	for(int i=0; i<=1; ++i)
		for(int j=0; j<=2; ++j)
			res[i][j] = (res[i][j] %mod + mod) * coef %mod;
	return res;
}

Matrix trans(ll x0,ll y0,ll a,ll b,ll c)// rotate
{
	x0 = (x0 %mod + mod) %mod;
	y0 = (y0 %mod + mod) %mod;
	a = (a %mod + mod) %mod;
	b = (b %mod + mod) %mod;
	c = (c %mod + mod) %mod;
	
	ll ivc = pw(c, mod-2);
	a = a * ivc %mod;
	b = b * ivc %mod;
	
	Matrix res;
	res[0][0] = b;
	res[0][1] = -a;
	res[0][2] = (b * (-x0) %mod - a * (-y0) %mod + x0) %mod;
	
	res[1][0] = a;
	res[1][1] = b;
	res[1][2] = (a * (-x0) %mod + b * (-y0) %mod + y0) %mod;
	
	res[2][2] = 1;
	
	for(int i=0; i<=1; ++i)
		for(int j=0; j<=2; ++j)
			res[i][j] = (res[i][j] %mod + mod) %mod;
	return res;
}

struct Segment_Tree
{
	Matrix sum[MAXN<<2], isum[MAXN<<2], tag[MAXN<<2], itag[MAXN<<2];
	bool fltag[MAXN<<2], hastag[MAXN<<2];
	#define ls(u) ((u)<<1)
	#define rs(u) ((u)<<1|1)
	#define lson(u) ls(u),l,mid
	#define rson(u) rs(u),mid+1,r
	inline void push_up(int u)
	{
		sum[u] = sum[rs(u)] * sum[ls(u)];
		isum[u] = isum[rs(u)] * isum[ls(u)];
	}
	inline void upd_fl(int u)
	{
		swap(sum[u], isum[u]);
		fltag[u] ^= 1;
	}
	inline void upd_tag(int u,Matrix k,Matrix ik)
	{
		sum[u] = k * sum[u] * ik;
		isum[u] = k * isum[u] * ik;
		tag[u] = k * tag[u];
		itag[u] = itag[u] * ik;
		hastag[u] = 1;
	}
	inline void push_down(int u)
	{
		if(fltag[u])
		{
			upd_fl(ls(u)); upd_fl(rs(u));
			fltag[u] = 0;
		}
		if(hastag[u])
		{
			upd_tag(ls(u), tag[u], itag[u]);
			upd_tag(rs(u), tag[u], itag[u]);
			tag[u].to_unit();
			itag[u].to_unit();
			hastag[u] = 0;
		}
	}
	void build(int u,int l,int r,Matrix *a,Matrix *ia)
	{
		fltag[u] = hastag[u] = 0; tag[u].to_unit(); itag[u].to_unit();
		if(l == r)
		{
			sum[u] = a[l]; isum[u] = ia[l];
			return;
		}
		int mid = (l+r)>>1;
		build(lson(u),a,ia);
		build(rson(u),a,ia);
		push_up(u);
	}
	void update(int u,int l,int r,int ql,int qr,Matrix k,Matrix ik,bool fl)
	{
		if(ql<=l && r<=qr)
		{
			if(fl) upd_fl(u);
			upd_tag(u, k, ik);
			return;
		}
		push_down(u);
		int mid = (l+r)>>1;
		if(ql<=mid) update(lson(u),ql,qr,k,ik,fl);
		if(mid<qr) update(rson(u),ql,qr,k,ik,fl);
		push_up(u);
	}
	Matrix query(int u,int l,int r,int ql,int qr)
	{
		if(ql<=l && r<=qr) return sum[u];
		push_down(u);
		int mid = (l+r)>>1;
		if(ql<=mid && mid<qr)
			return query(rson(u),ql,qr) * query(lson(u),ql,qr);
		else return ql<=mid? query(lson(u),ql,qr): query(rson(u),ql,qr);
	}
}tree;

Matrix a[MAXN], ia[MAXN];

int main(void)
{
	int n,Q;
	scanf("%d%d",&n,&Q);
	for(int i=1; i<=n; ++i)
	{
		int type;
		scanf("%d",&type);
		if(type == 1)
		{
			int _a, _b, _c;
			scanf("%d%d%d",&_a,&_b,&_c);
			a[i] = ia[i] = trans(_a, _b, _c);
		}
		else
		{
			int _x0, _y0, _a, _b, _c;
			scanf("%d%d%d%d%d",&_x0,&_y0,&_a,&_b,&_c);
			a[i] = trans(_x0, _y0, _a, _b, _c);
			ia[i] = trans(_x0, _y0, -_a, _b, _c);
		}
	}
	
	tree.build(1,1,n,a,ia);
	
	while(Q--)
	{
		int type;
		scanf("%d",&type);
		if(type == 1)
		{
			int x,y,l,r;
			scanf("%d%d%d%d",&x,&y,&l,&r);
			
			auto res = tree.query(1,1,n,l,r).calc(x, y);
			printf("%d %d\n",res.first,res.second);
		}
		else if(type == 2)
		{
			int _a, _b, _c, l, r;
			scanf("%d%d%d%d%d",&_a,&_b,&_c,&l,&r);
			
			Matrix A = trans(_a, _b, _c);
			tree.update(1,1,n, l, r, A, A, 1);
		}
		else
		{
			int _x0, _y0, _a, _b, _c, l, r;
			scanf("%d%d%d%d%d%d%d",&_x0,&_y0,&_a,&_b,&_c,&l,&r);
			
			Matrix A = trans(_x0, _y0, _a, _b, _c);
			Matrix iA = trans(_x0, _y0, -_a, _b, _c);
			tree.update(1,1,n, l, r, A, iA, 0);
		}
	}
	return 0;
}