使用了超级快读，本地无输出

#pragma GCC diagnostic error "-std=c++11"
#pragma GCC target("avx")
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#include<bits/stdc++.h>
using namespace std;
const int N=150000+10;
int n,m,p,a[N],l1,r1,id,c[N];
struct TREE{
	int cnt[5],num[5],len,tag,mid;
	inline void clear()
	{
		for(int i=0;i<=4;i++)
		{
			cnt[i]=num[i]=0;
		}
		return;
	}
}tree[N*4];
struct node{
	int cnt,num;
};
bool cmp(node x,node y)
{
	return x.num>y.num;
}
TREE merge(TREE x,TREE y,TREE xx)
{
	for(int i=0;i<p;i++)
	{
		if(y.num[i]==0)
		continue;
		for(int j=0;j<p;j++)
		{
			if(x.cnt[j]==y.cnt[i])
			{
				x.num[j]+=y.num[i];
				y.num[i]=0;
				break;
			}
		}
	}
	vector<node>us;
	for(int i=0;i<p;i++)
	{
		if(x.num[i]>0)
		us.push_back(node{x.cnt[i],x.num[i]});
		if(y.num[i]>0)
		us.push_back(node{y.cnt[i],y.num[i]});
	}
	if(us.size()<=p)
	{
		for(int i=0;i<us.size();i++)
		{
			xx.cnt[i]=us[i].cnt;
			xx.num[i]=us[i].num;
		}
	}
	else
	{
		sort(us.begin(),us.end(),cmp);
		for(int i=us.size();i>=0;i--)
		{
			c[i]=0;
		}
		for(int i=us.size()-1;i>=p;i--)
		{
			c[i]+=c[i+1];
			int del=us[i].num+c[i];
			if(del==0)
			continue;
			c[i-1]-=del;
			c[i-p-1]+=del;
		}
		for(int i=p-1;i>=0;i--)
		{
			c[i]+=c[i+1];
			xx.cnt[i]=us[i].cnt;
			xx.num[i]=us[i].num+c[i];
		}
	}
	return xx;
}
inline void build(int l,int r,int x)
{
	tree[x].len=r-l+1;
	tree[x].mid=(l+r)/2;
	if(l==r)
	{
		tree[x].cnt[0]=a[l];
		tree[x].num[0]=1;
		return;
	}
	build(l,tree[x].mid,x*2);
	build(tree[x].mid+1,r,x*2+1);
	tree[x]=merge(tree[x*2],tree[x*2+1],tree[x]);
	return;
}
inline void pushdown(int x)
{
	if(tree[x].tag!=0)
	{
		tree[x*2].clear();
		tree[x*2].cnt[0]=tree[x].tag;
		tree[x*2].num[0]=tree[x*2].len;
		tree[x*2].tag=tree[x].tag;
		tree[x*2+1].clear();
		tree[x*2+1].cnt[0]=tree[x].tag;
		tree[x*2+1].num[0]=tree[x*2+1].len;
		tree[x*2+1].tag=tree[x].tag;
		tree[x].tag=0;
	}
	return;
}
inline void change(int l,int r,int x)
{
	if(l>=l1&&r<=r1)
	{
		tree[x].clear();
		tree[x].cnt[0]=id;
		tree[x].num[0]=tree[x].len;
		tree[x].tag=id;
		return;
	}
	pushdown(x);
	if(tree[x].mid>=l1)
	change(l,tree[x].mid,x*2);
	if(tree[x].mid+1<=r1)
	change(tree[x].mid+1,r,x*2+1);
	tree[x]=merge(tree[x*2],tree[x*2+1],tree[x]);
	return;
}
inline TREE get(int l,int r,int x)
{
	if(l>=l1&&r<=r1)
	{
		return tree[x];
	}
	pushdown(x);
	TREE s;
	s.clear();
	if(tree[x].mid>=l1)
	s=merge(s,get(l,tree[x].mid,x*2),s);
	if(tree[x].mid+1<=r1)
	s=merge(s,get(tree[x].mid+1,r,x*2+1),s);
	return s;
}
namespace IO{
    const int SIZE=1<<21;
    static char ibuf[SIZE],obuf[SIZE],*iS,*iT,*oS=obuf,*oT=oS+SIZE-1;
    int qr;
    char qu[55],c;
    bool f;
    #define getchar() (IO::iS==IO::iT?(IO::iT=(IO::iS=IO::ibuf)+fread(IO::ibuf,1,IO::SIZE,stdin),(IO::iS==IO::iT?EOF:*IO::iS++)):*IO::iS++)
    #define putchar(x) *IO::oS++=x,IO::oS==IO::oT?flush():0
    #define flush() fwrite(IO::obuf,1,IO::oS-IO::obuf,stdout),IO::oS=IO::obuf
    #define puts(x) IO::Puts(x)
    template<typename T>
    inline void read(T&x){
        for(f=1,c=getchar();c<48||c>57;c=getchar())f^=c=='-';
        for(x=0;c<=57&&c>=48;c=getchar()) x=(x<<1)+(x<<3)+(c&15); 
        x=f?x:-x;
    }
    template<typename T>
    inline void write(T x){
        if(!x) putchar(48); if(x<0) putchar('-'),x=-x;
        while(x) qu[++qr]=x%10^48,x/=10;
        while(qr) putchar(qu[qr--]);
    }
    inline void Puts(const char*s){
        for(int i=0;s[i];++i)
            putchar(s[i]);
        putchar('\n');
    }
    struct Flusher_{~Flusher_(){flush();}}io_flusher_;
}
using IO::read;
using IO::write;
int main()
{
	read(n);
	read(m);
	read(p);
	p=100/p;
	for(int i=1;i<=n;i++)
	{
		read(a[i]);
	}
	build(1,n,1);
	while(m--)
	{
		int op;
		read(op); 
		read(l1);
		read(r1);
		if(op==1)
		{
			read(id);
			change(1,n,1);
		}
		else
		{
			TREE us=get(1,n,1);
			write(p);
			putchar(' ');
			for(int i=0;i<p;i++)
			{
				write(us.cnt[i]);
				putchar(' ');
			}
			puts("");
		}
	}
	return 0;
}
/*
100 9 20
5 4 3 3 4 5 5 2 1 6 2 4 2 4 6 1 1 5 3 1 6 2 1 2 6 1 5 3 1 6 2 2 4 5 3 1 5 6 5 4 5 3 3 1 6 4 6 2 1 2 3 3 1 5 5 3 6 2 4 1 6 6 1 3 1 5 2 6 5 1 3 5 3 6 5 5 1 1 2 6 1 6 2 1 1 2 4 3 3 5 1 6 5 1 1 2 4 6 3 6
1 8 81 4
1 78 90 5
1 62 76 3
1 87 96 1
1 27 40 1
1 31 75 2
1 44 62 4
1 80 85 1
2 50 100
*/