// Author -- Frame

#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#include<vector>
#include<iostream>

#define lowbit(x) ((x)&(-x))
#define Finline __inline__ __attribute__ ((always_inline))
#define DEBUG printf("Running on Line %d in Function %s\n",__LINE__,__FUNCTION__)

typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;

const int inf=0x3f3f3f3f,Inf=0x7fffffff;
const ll INF=0x7fffffffffffffff;
const double eps=1e-10;

uint seed=19260817;
const uint _RAND_MAX_=4294967295u;
Finline uint Rand(){return seed=seed*998244353u+1000000007u;}

template <typename _Tp>_Tp gcd(const _Tp &a,const _Tp &b){return (!b)?a:gcd(b,a%b);}
template <typename _Tp>Finline _Tp abs(const _Tp &a){return a>=0?a:-a;}
template <typename _Tp>Finline _Tp max(const _Tp &a,const _Tp &b){return a<b?b:a;}
template <typename _Tp>Finline _Tp min(const _Tp &a,const _Tp &b){return a<b?a:b;}
template <typename _Tp>Finline void chmax(_Tp &a,const _Tp &b){(a<b)&&(a=b);}
template <typename _Tp>Finline void chmin(_Tp &a,const _Tp &b){(b<a)&&(a=b);}
template <typename _Tp>Finline bool _cmp(const _Tp &a,const _Tp &b){return abs(a-b)<=eps;}
template <typename _Tp>Finline void read(_Tp &x)
{
	register char ch(getchar());
	bool f(false);
	while(ch<48||ch>57) f|=ch==45,ch=getchar();
	x=ch&15,ch=getchar();
	while(ch>=48&&ch<=57) x=(((x<<2)+x)<<1)+(ch&15),ch=getchar();
	if(f) x=-x;
}
template <typename _Tp,typename... Args>Finline void read(_Tp &t,Args &...args)
{
	read(t);read(args...);
}
Finline int read_str(char *s)
{
	register char ch(getchar());
	while(ch==' '||ch=='\r'||ch=='\n') ch=getchar();
	register char *tar=s;
	*tar=ch,ch=getchar();
	while(ch!=' '&&ch!='\r'&&ch!='\n'&&ch!=EOF) *(++tar)=ch,ch=getchar();
	return tar-s+1;
}

const int N=150005;
int p,tot;
struct node{
	int val,cnt;
};
std::vector<node> tmp;
int a[N];
Finline std::vector<node> merge(std::vector<node> ans,const std::vector<node> &b)
{
	for(auto it:b)
	{
		bool flag=false;
		for(auto &itt:ans)
		{
			if(itt.val==it.val)
			{
				flag=true;
				itt.cnt+=it.cnt;
				break;
			}
		}
		if(!flag)
		{
			ans.push_back(it);
		}
	}
	while((int)ans.size()>tot)
	{
		int minn=inf;
		for(int i=0;i<tot;++i)
		{
			chmin(minn,ans[i].cnt);
		}
		for(int i=0;i<tot;++i)
		{
			ans[i].cnt-=minn;
		}
		tmp.clear();
		for(auto it:ans)
		{
			if(it.cnt)
			{
				tmp.push_back(it);
			}
		}
		ans=tmp;
	}
	return ans;
}
struct seg_tr{
	struct Node{
		int ls,rs;
		std::vector<node> val;
		int tag;
	}f[N<<1];
	int node_cnt;
	Finline void PushUp(int x)
	{
		f[x].val=merge(f[f[x].ls].val,f[f[x].rs].val);
	}
	int build(int l,int r)
	{
		int cur=++node_cnt;
		if(l==r)
		{
			f[cur].val.push_back((node){a[l],1});
			return cur;
		}
		int mid=(l+r)>>1;
		f[cur].ls=build(l,mid);
		f[cur].rs=build(mid+1,r);
		PushUp(cur);
		return cur;
	}
	Finline void cover(int cur,int l,int r,int C)
	{
		f[cur].val.clear();
		f[cur].val.push_back((node){C,r-l+1});
		f[cur].tag=C;
	}
	Finline void PushDown(int cur,int l,int r)
	{
		if(f[cur].tag)
		{
			int mid=(l+r)>>1;
			cover(f[cur].ls,l,mid,f[cur].tag);
			cover(f[cur].rs,mid+1,r,f[cur].tag);
			f[cur].tag=0;
		}
	}
	void Update(int L,int R,int l,int r,int cur,int C)
	{
		if(L<=l&&r<=R)
		{
			cover(cur,l,r,C);
			return;
		}
		PushDown(cur,l,r);
		int mid=(l+r)>>1;
		if(L<=mid) Update(L,R,l,mid,f[cur].ls,C);
		if(R>mid) Update(L,R,mid+1,r,f[cur].rs,C);
		PushUp(cur);
	}
	std::vector<node> Query(int L,int R,int l,int r,int cur)
	{
		if(L<=l&&r<=R)
		{
			return f[cur].val;
		}
		PushDown(cur,l,r);
		int mid=(l+r)>>1;
		if(L<=mid&&R>mid)
		{
			return merge(Query(L,R,l,mid,f[cur].ls),Query(L,R,mid+1,r,f[cur].rs));
		}
		if(L<=mid)
		{
			return Query(L,R,l,mid,f[cur].ls);
		}
		return Query(L,R,mid+1,r,f[cur].rs);
	}
}tr;
int main()
{
	int n,_,p;
	read(n,_,p);
	tot=100/p;
	for(int i=1;i<=n;++i) read(a[i]);
	tr.build(1,n);
	int opt,l,r,v;
	std::vector<node> qwq;
	while(_--)
	{
		read(opt);
		if(opt==1)
		{
			read(l,r,v);
			tr.Update(l,r,1,n,1,v);
		}
		else
		{
			read(l,r);
			qwq=tr.Query(l,r,1,n,1);
			printf("%d ",(int)qwq.size());
			for(auto it:qwq) printf("%d ",it.val);
			printf("\n");
		}
	}
	return 0;
}


//Author:xht37
#include <bits/stdc++.h>

#define ui unsigned int
#define ll long long
#define ul unsigned ll
#define ld long double

#define pi pair <int, int>
#define fi first
#define se second
#define mp make_pair

#define ls (p << 1)
#define rs (ls | 1)
#define md ((t[p].l + t[p].r) >> 1)

#define vi vector <int>
#define pb push_back
#define pq priority_queue

#define dbg(x) cerr << #x" = " << x << endl
#define debug(...) fprintf(stderr, __VA_ARGS__)

#define fl(x) freopen(x".in", "r", stdin), freopen(x".out", "w", stdout)

using namespace std;

namespace io {
	const int SI = 1 << 21 | 1;
	char IB[SI], *IS, *IT, OB[SI], *OS = OB, *OT = OS + SI - 1, c, ch[100];
	int f, t;
	#define gc() (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++)
	inline void flush() {
		fwrite(OB, 1, OS - OB, stdout), OS = OB;
	}
	inline void pc(char x) {
		*OS++ = x;
		if (OS == OT) flush();
	}
	template <class I>
	inline void rd(I &x) {
		for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
		for (x = 0; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + (c & 15), c = gc());
		x *= f;
	}
	template <class I>
	inline void rda(I *a, int &n) {
		for (int i = 1; i <= n; i++) rd(a[i]);
	}
	inline void rds(char *s, int &x) {
		for (c = gc(); c < 33 || c > 126; c = gc());
		for (x = 0; c >= 33 && c <= 126; s[++x] = c, c = gc());
		s[x+1] = '\0';
	}
	template <class I>
	inline void print(I x, char k = '\n') {
		if (!x) pc('0');
		if (x < 0) pc('-'), x = -x;
		while (x) ch[++t] = x % 10 + '0', x /= 10;
		while (t) pc(ch[t--]);
		pc(k);
	}
	inline void prints(string s) {
		int x = s.length();
		while (t < x) pc(s[t++]);
		pc('\n'), t = 0;
	}
	struct Flush {
		~Flush() {
			flush();
		}
	} flusher;
}
using io::rd;
using io::rda;
using io::rds;
using io::print;
using io::prints;

const int N = 1.5e5 + 7;
int n, m, p, k, a[N];
struct T {
	int l, r, z;
	map<int, int> c;
} t[N<<2];

inline map<int, int> merge(map<int, int> a, map<int, int> b) {
	for (pi o : b) {
		a[o.fi] += o.se;
		if ((int)a.size() <= k) continue;
		int x = n;
		for (pi p : a) x = min(x, p.se);
		for (pi p : a)
			if (!(a[p.fi] -= x)) a.erase(p.fi);
	}
	return a;
}

void build(int p, int l, int r) {
	t[p].l = l, t[p].r = r;
	if (t[p].l == t[p].r) return t[p].c[a[l]] = 1, void();
	build(ls, l, md), build(rs, md + 1, r);
	t[p].c = merge(t[ls].c, t[rs].c);
}

inline void setx(int p, int x) {
	t[p].z = x, t[p].c.clear(), t[p].c[x] = t[p].r - t[p].l + 1;
}

inline void spd(int p) {
	if (t[p].z) setx(ls, t[p].z), setx(rs, t[p].z), t[p].z = 0;
}

void change(int p, int l, int r, int x) {
//	debug("change %d %d %d\n", t[p].l, t[p].r, x);
	if (t[p].l >= l && t[p].r <= r) return setx(p, x);
	spd(p);
	if (l <= md) change(ls, l, r, x);
	if (r > md) change(rs, l, r, x);
	t[p].c = merge(t[ls].c, t[rs].c);
}

map<int, int> ask(int p, int l, int r) {
	if (t[p].l >= l && t[p].r <= r) return t[p].c;
	spd(p);
	map<int, int> c;
	if (l <= md) c = ask(ls, l, r);
	if (r > md) c = merge(c, ask(rs, l, r));
//	debug("ask %d %d %d\n", t[p].l, t[p].r, (int)c.size());
	return c;
}

int main() {
//	fl("1");
	rd(n), rd(m), rd(p), k = 100 / p, rda(a, n);
	build(1, 1, n);
	for (int i = 1, o, l, r, x; i <= m; i++) {
//		dbg(i);
		rd(o), rd(l), rd(r);
		if (o == 1) rd(x), change(1, l, r, x);
		else {
			auto ans = ask(1, l, r);
			print(ans.size(), ' ');
//			debug("%d %d %d\n", l, r, (int)ans.size());
			for (pi o : ans) print(o.fi, ' ');
			prints("");
		}
	}
	return 0;
}


//Author:xht37
#include <bits/stdc++.h>

#define ui unsigned int
#define ll long long
#define ul unsigned ll
#define ld long double

#define pi pair <int, int>
#define fi first
#define se second
#define mp make_pair

#define ls (p << 1)
#define rs (ls | 1)
#define md ((t[p].l + t[p].r) >> 1)

#define vi vector <int>
#define pb push_back
#define pq priority_queue

#define dbg(x) cerr << #x" = " << x << endl
#define debug(...) fprintf(stderr, __VA_ARGS__)

#define fl(x) freopen(x".in", "r", stdin), freopen(x".out", "w", stdout)

using namespace std;

namespace io {
	const int SI = 1 << 21 | 1;
	char IB[SI], *IS, *IT, OB[SI], *OS = OB, *OT = OS + SI - 1, c, ch[100];
	int f, t;
	#define gc() (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++)
	inline void flush() {
		fwrite(OB, 1, OS - OB, stdout), OS = OB;
	}
	inline void pc(char x) {
		*OS++ = x;
		if (OS == OT) flush();
	}
	template <class I>
	inline void rd(I &x) {
		for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
		for (x = 0; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + (c & 15), c = gc());
		x *= f;
	}
	template <class I>
	inline void rda(I *a, int &n) {
		for (int i = 1; i <= n; i++) rd(a[i]);
	}
	inline void rds(char *s, int &x) {
		for (c = gc(); c < 33 || c > 126; c = gc());
		for (x = 0; c >= 33 && c <= 126; s[++x] = c, c = gc());
		s[x+1] = '\0';
	}
	template <class I>
	inline void print(I x, char k = '\n') {
		if (!x) pc('0');
		if (x < 0) pc('-'), x = -x;
		while (x) ch[++t] = x % 10 + '0', x /= 10;
		while (t) pc(ch[t--]);
		pc(k);
	}
	inline void prints(string s) {
		int x = s.length();
		while (t < x) pc(s[t++]);
		pc('\n'), t = 0;
	}
	struct Flush {
		~Flush() {
			flush();
		}
	} flusher;
}
using io::rd;
using io::rda;
using io::rds;
using io::print;
using io::prints;

const int N = 1.5e5 + 7;
int n, m, p, k, a[N];
struct T {
	int l, r, z;
	map<int, int> c;
} t[N<<2];

inline map<int, int> merge(map<int, int> a, map<int, int> b) {
	map<int, int> c = a;
	for (pi o : b) c[o.fi] += o.se;
	while ((int)c.size() > k) {
		vi v;
		for (pi o : c) {
			v.pb(o.fi);
			if ((int)v.size() > k) break;
		}
		for (int x : v)
			if (!--c[x]) c.erase(x);
	}
	return c;
}

void build(int p, int l, int r) {
	t[p].l = l, t[p].r = r;
	if (t[p].l == t[p].r) return t[p].c[a[l]] = 1, void();
	build(ls, l, md), build(rs, md + 1, r);
	t[p].c = merge(t[ls].c, t[rs].c);
}

inline void setx(int p, int x) {
	t[p].z = x, t[p].c.clear(), t[p].c[x] = t[p].r - t[p].r + 1;
}

inline void spd(int p) {
	if (t[p].z) setx(ls, t[p].z), setx(rs, t[p].z), t[p].z = 0;
}

void change(int p, int l, int r, int x) {
	if (t[p].l <= l && t[p].r >= r) return setx(p, x);
	spd(p);
	if (l <= md) change(ls, l, r, x);
	if (r > md) change(ls, l, r, x);
	t[p].c = merge(t[ls].c, t[rs].c);
}

map<int, int> ask(int p, int l, int r) {
	if (t[p].l <= l && t[p].r >= r) return t[p].c;
	spd(p);
	map<int, int> c;
	if (l <= md) c = ask(ls, l, r);
	if (r > md) c = merge(c, ask(rs, l, r));
	return c;
}

int main() {
	rd(n), rd(m), rd(p), k = 100 / p, rda(a, n);
	build(1, 1, n);
	for (int i = 1, o, l, r, x; i <= m; i++) {
		rd(o), rd(l), rd(r);
		if (o == 1) rd(x), change(1, l, r, x);
		else {
			auto ans = ask(1, l, r);
			print(ans.size(), ' ');
			for (pi o : ans) print(o.fi, ' ');
			prints("");
		}
	}
	return 0;
}


//Author:xht37
#include <bits/stdc++.h>

#define ui unsigned int
#define ll long long
#define ul unsigned ll
#define ld long double

#define pi pair <int, int>
#define fi first
#define se second
#define mp make_pair

#define ls (p << 1)
#define rs (ls | 1)
#define md ((t[p].l + t[p].r) >> 1)

#define vi vector <int>
#define pb push_back
#define pq priority_queue

#define dbg(x) cerr << #x" = " << x << endl
#define debug(...) fprintf(stderr, __VA_ARGS__)

#define fl(x) freopen(x".in", "r", stdin), freopen(x".out", "w", stdout)

using namespace std;

namespace io {
	const int SI = 1 << 21 | 1;
	char IB[SI], *IS, *IT, OB[SI], *OS = OB, *OT = OS + SI - 1, c, ch[100];
	int f, t;
	#define gc() (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++)
	inline void flush() {
		fwrite(OB, 1, OS - OB, stdout), OS = OB;
	}
	inline void pc(char x) {
		*OS++ = x;
		if (OS == OT) flush();
	}
	template <class I>
	inline void rd(I &x) {
		for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
		for (x = 0; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + (c & 15), c = gc());
		x *= f;
	}
	template <class I>
	inline void rda(I *a, int &n) {
		for (int i = 1; i <= n; i++) rd(a[i]);
	}
	inline void rds(char *s, int &x) {
		for (c = gc(); c < 33 || c > 126; c = gc());
		for (x = 0; c >= 33 && c <= 126; s[++x] = c, c = gc());
		s[x+1] = '\0';
	}
	template <class I>
	inline void print(I x, char k = '\n') {
		if (!x) pc('0');
		if (x < 0) pc('-'), x = -x;
		while (x) ch[++t] = x % 10 + '0', x /= 10;
		while (t) pc(ch[t--]);
		pc(k);
	}
	inline void prints(string s) {
		int x = s.length();
		while (t < x) pc(s[t++]);
		pc('\n'), t = 0;
	}
	struct Flush {
		~Flush() {
			flush();
		}
	} flusher;
}
using io::rd;
using io::rda;
using io::rds;
using io::print;
using io::prints;

const int N = 1.5e5 + 7;
int n, m, p, k, a[N];
struct T {
	int l, r, z;
	map<int, int> c;
} t[N<<2];

inline map<int, int> merge(map<int, int> a, map<int, int> b) {
	map<int, int> c = a;
	for (pi o : b) c[o.fi] += o.se;
	while ((int)c.size() > k) {
		vi v;
		for (pi o : c) {
			v.pb(o.fi);
			if ((int)v.size() > k) break;
		}
		for (int x : v)
			if (!--c[x]) c.erase(x);
	}
	return c;
}

void build(int p, int l, int r) {
	t[p].l = l, t[p].r = r;
	if (t[p].l == t[p].r) return t[p].c[a[l]] = 1, void();
	build(ls, l, md), build(rs, md + 1, r);
	t[p].c = merge(t[ls].c, t[rs].c);
}

inline void setx(int p, int x) {
	t[p].z = x, t[p].c.clear(), t[p].c[x] = t[p].r - t[p].r + 1;
}

inline void spd(int p) {
	if (t[p].z) setx(ls, t[p].z), setx(rs, t[p].z), t[p].z = 0;
}

void change(int p, int l, int r, int x) {
//	debug("change %d %d %d\n", t[p].l, t[p].r, x);
	if (t[p].l >= l && t[p].r <= r) return setx(p, x);
	spd(p);
	if (l <= md) change(ls, l, r, x);
	if (r > md) change(rs, l, r, x);
	t[p].c = merge(t[ls].c, t[rs].c);
}

map<int, int> ask(int p, int l, int r) {
	if (t[p].l >= l && t[p].r <= r) return t[p].c;
	spd(p);
	map<int, int> c;
	if (l <= md) c = ask(ls, l, r);
	if (r > md) c = merge(c, ask(rs, l, r));
//	debug("ask %d %d %d\n", t[p].l, t[p].r, (int)c.size());
	return c;
}

int main() {
//	fl("1");
	rd(n), rd(m), rd(p), k = 100 / p, rda(a, n);
	build(1, 1, n);
	for (int i = 1, o, l, r, x; i <= m; i++) {
//		dbg(i);
		rd(o), rd(l), rd(r);
		if (o == 1) rd(x), change(1, l, r, x);
		else {
			auto ans = ask(1, l, r);
			print(ans.size(), ' ');
//			debug("%d %d %d\n", l, r, (int)ans.size());
			for (pi o : ans) print(o.fi, ' ');
			prints("");
		}
	}
	return 0;
}


//Author:xht37
#include <bits/stdc++.h>

#define ui unsigned int
#define ll long long
#define ul unsigned ll
#define ld long double

#define pi pair <int, int>
#define fi first
#define se second
#define mp make_pair

#define ls (p << 1)
#define rs (ls | 1)
#define md ((t[p].l + t[p].r) >> 1)

#define vi vector <int>
#define pb push_back
#define pq priority_queue

#define dbg(x) cerr << #x" = " << x << endl
#define debug(...) fprintf(stderr, __VA_ARGS__)

#define fl(x) freopen(x".in", "r", stdin), freopen(x".out", "w", stdout)

using namespace std;

namespace io {
	const int SI = 1 << 21 | 1;
	char IB[SI], *IS, *IT, OB[SI], *OS = OB, *OT = OS + SI - 1, c, ch[100];
	int f, t;
	#define gc() (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++)
	inline void flush() {
		fwrite(OB, 1, OS - OB, stdout), OS = OB;
	}
	inline void pc(char x) {
		*OS++ = x;
		if (OS == OT) flush();
	}
	template <class I>
	inline void rd(I &x) {
		for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
		for (x = 0; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + (c & 15), c = gc());
		x *= f;
	}
	template <class I>
	inline void rda(I *a, int &n) {
		for (int i = 1; i <= n; i++) rd(a[i]);
	}
	inline void rds(char *s, int &x) {
		for (c = gc(); c < 33 || c > 126; c = gc());
		for (x = 0; c >= 33 && c <= 126; s[++x] = c, c = gc());
		s[x+1] = '\0';
	}
	template <class I>
	inline void print(I x, char k = '\n') {
		if (!x) pc('0');
		if (x < 0) pc('-'), x = -x;
		while (x) ch[++t] = x % 10 + '0', x /= 10;
		while (t) pc(ch[t--]);
		pc(k);
	}
	inline void prints(string s) {
		int x = s.length();
		while (t < x) pc(s[t++]);
		pc('\n'), t = 0;
	}
	struct Flush {
		~Flush() {
			flush();
		}
	} flusher;
}
using io::rd;
using io::rda;
using io::rds;
using io::print;
using io::prints;

const int N = 1.5e5 + 7;
int n, m, p, k, a[N];
struct T {
	int l, r, z;
	map<int, int> c;
} t[N<<2];

inline map<int, int> merge(map<int, int> a, map<int, int> b) {
	map<int, int> c = a;
	for (pi o : b) c[o.fi] += o.se;
	while ((int)c.size() > k) {
		vi v;
		int k = n;
		for (pi o : c) {
			v.pb(o.fi), k = min(k, o.se);
			if ((int)v.size() > k) break;
		}
		for (int x : v)
			if (!(c[x] -= k)) c.erase(x);
	}
	return c;
}

void build(int p, int l, int r) {
	t[p].l = l, t[p].r = r;
	if (t[p].l == t[p].r) return t[p].c[a[l]] = 1, void();
	build(ls, l, md), build(rs, md + 1, r);
	t[p].c = merge(t[ls].c, t[rs].c);
}

inline void setx(int p, int x) {
	t[p].z = x, t[p].c.clear(), t[p].c[x] = t[p].r - t[p].l + 1;
}

inline void spd(int p) {
	if (t[p].z) setx(ls, t[p].z), setx(rs, t[p].z), t[p].z = 0;
}

void change(int p, int l, int r, int x) {
//	debug("change %d %d %d\n", t[p].l, t[p].r, x);
	if (t[p].l >= l && t[p].r <= r) return setx(p, x);
	spd(p);
	if (l <= md) change(ls, l, r, x);
	if (r > md) change(rs, l, r, x);
	t[p].c = merge(t[ls].c, t[rs].c);
}

map<int, int> ask(int p, int l, int r) {
	if (t[p].l >= l && t[p].r <= r) return t[p].c;
	spd(p);
	map<int, int> c;
	if (l <= md) c = ask(ls, l, r);
	if (r > md) c = merge(c, ask(rs, l, r));
//	debug("ask %d %d %d\n", t[p].l, t[p].r, (int)c.size());
	return c;
}

int main() {
//	fl("1");
	rd(n), rd(m), rd(p), k = 100 / p, rda(a, n);
	build(1, 1, n);
	for (int i = 1, o, l, r, x; i <= m; i++) {
//		dbg(i);
		rd(o), rd(l), rd(r);
		if (o == 1) rd(x), change(1, l, r, x);
		else {
			auto ans = ask(1, l, r);
			print(ans.size(), ' ');
//			debug("%d %d %d\n", l, r, (int)ans.size());
			for (pi o : ans) print(o.fi, ' ');
			prints("");
		}
	}
	return 0;
}


//Author:xht37
#include <bits/stdc++.h>

#define ui unsigned int
#define ll long long
#define ul unsigned ll
#define ld long double

#define pi pair <int, int>
#define fi first
#define se second
#define mp make_pair

#define ls (p << 1)
#define rs (ls | 1)
#define md ((t[p].l + t[p].r) >> 1)

#define vi vector <int>
#define pb push_back
#define pq priority_queue

#define dbg(x) cerr << #x" = " << x << endl
#define debug(...) fprintf(stderr, __VA_ARGS__)

#define fl(x) freopen(x".in", "r", stdin), freopen(x".out", "w", stdout)

using namespace std;

namespace io {
	const int SI = 1 << 21 | 1;
	char IB[SI], *IS, *IT, OB[SI], *OS = OB, *OT = OS + SI - 1, c, ch[100];
	int f, t;
	#define gc() (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++)
	inline void flush() {
		fwrite(OB, 1, OS - OB, stdout), OS = OB;
	}
	inline void pc(char x) {
		*OS++ = x;
		if (OS == OT) flush();
	}
	template <class I>
	inline void rd(I &x) {
		for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
		for (x = 0; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + (c & 15), c = gc());
		x *= f;
	}
	template <class I>
	inline void rda(I *a, int &n) {
		for (int i = 1; i <= n; i++) rd(a[i]);
	}
	inline void rds(char *s, int &x) {
		for (c = gc(); c < 33 || c > 126; c = gc());
		for (x = 0; c >= 33 && c <= 126; s[++x] = c, c = gc());
		s[x+1] = '\0';
	}
	template <class I>
	inline void print(I x, char k = '\n') {
		if (!x) pc('0');
		if (x < 0) pc('-'), x = -x;
		while (x) ch[++t] = x % 10 + '0', x /= 10;
		while (t) pc(ch[t--]);
		pc(k);
	}
	inline void prints(string s) {
		int x = s.length();
		while (t < x) pc(s[t++]);
		pc('\n'), t = 0;
	}
	struct Flush {
		~Flush() {
			flush();
		}
	} flusher;
}
using io::rd;
using io::rda;
using io::rds;
using io::print;
using io::prints;

const int N = 1.5e5 + 7;
int n, m, p, k, a[N];
struct T {
	int l, r, z;
	vector<pi> c;
} t[N<<2];

inline vector<pi> merge(vector<pi> a, vector<pi> b) {
	for (pi o : b) {
		bool ok = 0;
		for (pi &p : a)
			if (p.fi == o.fi) {
				p.se += o.se, ok = 1;
				break;
			}
		if (ok) continue;
		a.pb(o);
		if ((int)a.size() <= k) continue;
		int x = n;
		for (pi p : a) x = min(x, p.se);
		vector<pi> c;
		for (pi p : a)
			if (p.se - x) c.pb(mp(p.fi, p.se - x));
		a = c;
	}
	return a;
}

void build(int p, int l, int r) {
	t[p].l = l, t[p].r = r;
	if (t[p].l == t[p].r) return t[p].c.pb(mp(a[l], 1)), void();
	build(ls, l, md), build(rs, md + 1, r);
	t[p].c = merge(t[ls].c, t[rs].c);
}

inline void setx(int p, int x) {
	t[p].z = x, t[p].c.clear(), t[p].c.pb(mp(x, t[p].r - t[p].l + 1));
}

inline void spd(int p) {
	if (t[p].z) setx(ls, t[p].z), setx(rs, t[p].z), t[p].z = 0;
}

void change(int p, int l, int r, int x) {
//	debug("change %d %d %d\n", t[p].l, t[p].r, x);
	if (t[p].l >= l && t[p].r <= r) return setx(p, x);
	spd(p);
	if (l <= md) change(ls, l, r, x);
	if (r > md) change(rs, l, r, x);
	t[p].c = merge(t[ls].c, t[rs].c);
}

vector<pi> ask(int p, int l, int r) {
	if (t[p].l >= l && t[p].r <= r) return t[p].c;
	spd(p);
	vector<pi> c;
	if (l <= md) c = ask(ls, l, r);
	if (r > md) c = merge(c, ask(rs, l, r));
//	debug("ask %d %d %d\n", t[p].l, t[p].r, (int)c.size());
	return c;
}

int main() {
//	fl("1");
	rd(n), rd(m), rd(p), k = 100 / p, rda(a, n);
	build(1, 1, n);
	for (int i = 1, o, l, r, x; i <= m; i++) {
//		dbg(i);
		rd(o), rd(l), rd(r);
		if (o == 1) rd(x), change(1, l, r, x);
		else {
			auto ans = ask(1, l, r);
			print(ans.size(), ' ');
//			debug("%d %d %d\n", l, r, (int)ans.size());
			for (pi o : ans) print(o.fi, ' ');
			prints("");
		}
	}
	return 0;
}


//Author:xht37
#include <bits/stdc++.h>

#define ui unsigned int
#define ll long long
#define ul unsigned ll
#define ld long double

#define pi pair <int, int>
#define fi first
#define se second
#define mp make_pair

#define ls (p << 1)
#define rs (ls | 1)
#define md ((t[p].l + t[p].r) >> 1)

#define vi vector <int>
#define pb push_back
#define pq priority_queue

#define dbg(x) cerr << #x" = " << x << endl
#define debug(...) fprintf(stderr, __VA_ARGS__)

#define fl(x) freopen(x".in", "r", stdin), freopen(x".out", "w", stdout)

using namespace std;

namespace io {
	const int SI = 1 << 21 | 1;
	char IB[SI], *IS, *IT, OB[SI], *OS = OB, *OT = OS + SI - 1, c, ch[100];
	int f, t;
	#define gc() (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++)
	inline void flush() {
		fwrite(OB, 1, OS - OB, stdout), OS = OB;
	}
	inline void pc(char x) {
		*OS++ = x;
		if (OS == OT) flush();
	}
	template <class I>
	inline void rd(I &x) {
		for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
		for (x = 0; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + (c & 15), c = gc());
		x *= f;
	}
	template <class I>
	inline void rda(I *a, int &n) {
		for (int i = 1; i <= n; i++) rd(a[i]);
	}
	inline void rds(char *s, int &x) {
		for (c = gc(); c < 33 || c > 126; c = gc());
		for (x = 0; c >= 33 && c <= 126; s[++x] = c, c = gc());
		s[x+1] = '\0';
	}
	template <class I>
	inline void print(I x, char k = '\n') {
		if (!x) pc('0');
		if (x < 0) pc('-'), x = -x;
		while (x) ch[++t] = x % 10 + '0', x /= 10;
		while (t) pc(ch[t--]);
		pc(k);
	}
	inline void prints(string s) {
		int x = s.length();
		while (t < x) pc(s[t++]);
		pc('\n'), t = 0;
	}
	struct Flush {
		~Flush() {
			flush();
		}
	} flusher;
}
using io::rd;
using io::rda;
using io::rds;
using io::print;
using io::prints;

const int N = 1.5e5 + 7;
int n, m, p, k, a[N];
struct T {
	int l, r, z;
	map<int, int> c;
} t[N<<2];

inline map<int, int> merge(map<int, int> a, map<int, int> b) {
	map<int, int> c = a;
	for (pi o : b) c[o.fi] += o.se;
	while ((int)c.size() > k) {
		vi v;
		int t = n;
		for (pi o : c) {
			v.pb(o.fi), t = min(t, o.se);
			if ((int)v.size() > k) break;
		}
		for (int x : v)
			if (!(c[x] -= t)) c.erase(x);
	}
	return c;
}

void build(int p, int l, int r) {
	t[p].l = l, t[p].r = r;
	if (t[p].l == t[p].r) return t[p].c[a[l]] = 1, void();
	build(ls, l, md), build(rs, md + 1, r);
	t[p].c = merge(t[ls].c, t[rs].c);
}

inline void setx(int p, int x) {
	t[p].z = x, t[p].c.clear(), t[p].c[x] = t[p].r - t[p].l + 1;
}

inline void spd(int p) {
	if (t[p].z) setx(ls, t[p].z), setx(rs, t[p].z), t[p].z = 0;
}

void change(int p, int l, int r, int x) {
//	debug("change %d %d %d\n", t[p].l, t[p].r, x);
	if (t[p].l >= l && t[p].r <= r) return setx(p, x);
	spd(p);
	if (l <= md) change(ls, l, r, x);
	if (r > md) change(rs, l, r, x);
	t[p].c = merge(t[ls].c, t[rs].c);
}

map<int, int> ask(int p, int l, int r) {
	if (t[p].l >= l && t[p].r <= r) return t[p].c;
	spd(p);
	map<int, int> c;
	if (l <= md) c = ask(ls, l, r);
	if (r > md) c = merge(c, ask(rs, l, r));
//	debug("ask %d %d %d\n", t[p].l, t[p].r, (int)c.size());
	return c;
}

int main() {
//	fl("1");
	rd(n), rd(m), rd(p), k = 100 / p, rda(a, n);
	build(1, 1, n);
	for (int i = 1, o, l, r, x; i <= m; i++) {
//		dbg(i);
		rd(o), rd(l), rd(r);
		if (o == 1) rd(x), change(1, l, r, x);
		else {
			auto ans = ask(1, l, r);
			print(ans.size(), ' ');
//			debug("%d %d %d\n", l, r, (int)ans.size());
			for (pi o : ans) print(o.fi, ' ');
			prints("");
		}
	}
	return 0;
}


//Author:xht37
#include <bits/stdc++.h>

#define ui unsigned int
#define ll long long
#define ul unsigned ll
#define ld long double

#define pi pair <int, int>
#define fi first
#define se second
#define mp make_pair

#define ls (p << 1)
#define rs (ls | 1)
#define md ((t[p].l + t[p].r) >> 1)

#define vi vector <int>
#define pb push_back
#define pq priority_queue

#define dbg(x) cerr << #x" = " << x << endl
#define debug(...) fprintf(stderr, __VA_ARGS__)

#define fl(x) freopen(x".in", "r", stdin), freopen(x".out", "w", stdout)

using namespace std;

namespace io {
	const int SI = 1 << 21 | 1;
	char IB[SI], *IS, *IT, OB[SI], *OS = OB, *OT = OS + SI - 1, c, ch[100];
	int f, t;
	#define gc() (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++)
	inline void flush() {
		fwrite(OB, 1, OS - OB, stdout), OS = OB;
	}
	inline void pc(char x) {
		*OS++ = x;
		if (OS == OT) flush();
	}
	template <class I>
	inline void rd(I &x) {
		for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
		for (x = 0; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + (c & 15), c = gc());
		x *= f;
	}
	template <class I>
	inline void rda(I *a, int &n) {
		for (int i = 1; i <= n; i++) rd(a[i]);
	}
	inline void rds(char *s, int &x) {
		for (c = gc(); c < 33 || c > 126; c = gc());
		for (x = 0; c >= 33 && c <= 126; s[++x] = c, c = gc());
		s[x+1] = '\0';
	}
	template <class I>
	inline void print(I x, char k = '\n') {
		if (!x) pc('0');
		if (x < 0) pc('-'), x = -x;
		while (x) ch[++t] = x % 10 + '0', x /= 10;
		while (t) pc(ch[t--]);
		pc(k);
	}
	inline void prints(string s) {
		int x = s.length();
		while (t < x) pc(s[t++]);
		pc('\n'), t = 0;
	}
	struct Flush {
		~Flush() {
			flush();
		}
	} flusher;
}
using io::rd;
using io::rda;
using io::rds;
using io::print;
using io::prints;

const int N = 1.5e5 + 7;
int n, m, p, k, a[N];
struct T {
	int l, r, z;
	map<int, int> c;
} t[N<<2];

inline map<int, int> merge(map<int, int> a, map<int, int> b) {
	map<int, int> c = a;
	for (pi o : b) c[o.fi] += o.se;
	while ((int)c.size() > k) {
		vi v;
		for (pi o : c) {
			v.pb(o.fi);
			if ((int)v.size() > k) break;
		}
		for (int x : v)
			if (!--c[x]) c.erase(x);
	}
	return c;
}

void build(int p, int l, int r) {
	t[p].l = l, t[p].r = r;
	if (t[p].l == t[p].r) return t[p].c[a[l]] = 1, void();
	build(ls, l, md), build(rs, md + 1, r);
	t[p].c = merge(t[ls].c, t[rs].c);
}

inline void setx(int p, int x) {
	t[p].z = x, t[p].c.clear(), t[p].c[x] = t[p].r - t[p].l + 1;
}

inline void spd(int p) {
	if (t[p].z) setx(ls, t[p].z), setx(rs, t[p].z), t[p].z = 0;
}

void change(int p, int l, int r, int x) {
//	debug("change %d %d %d\n", t[p].l, t[p].r, x);
	if (t[p].l >= l && t[p].r <= r) return setx(p, x);
	spd(p);
	if (l <= md) change(ls, l, r, x);
	if (r > md) change(rs, l, r, x);
	t[p].c = merge(t[ls].c, t[rs].c);
}

map<int, int> ask(int p, int l, int r) {
	if (t[p].l >= l && t[p].r <= r) return t[p].c;
	spd(p);
	map<int, int> c;
	if (l <= md) c = ask(ls, l, r);
	if (r > md) c = merge(c, ask(rs, l, r));
//	debug("ask %d %d %d\n", t[p].l, t[p].r, (int)c.size());
	return c;
}

int main() {
//	fl("1");
	rd(n), rd(m), rd(p), k = 100 / p, rda(a, n);
	build(1, 1, n);
	for (int i = 1, o, l, r, x; i <= m; i++) {
//		dbg(i);
		rd(o), rd(l), rd(r);
		if (o == 1) rd(x), change(1, l, r, x);
		else {
			auto ans = ask(1, l, r);
			print(ans.size(), ' ');
//			debug("%d %d %d\n", l, r, (int)ans.size());
			for (pi o : ans) print(o.fi, ' ');
			prints("");
		}
	}
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
int gi() {
	int res = 0, w = 1;
	char ch = getchar();
	while (ch != '-' && !isdigit(ch)) ch = getchar();
	if (ch == '-') w = -1, ch = getchar();
	while (isdigit(ch)) res = res * 10 + ch - '0', ch = getchar();
	return res * w;
}
const int MAX_N = 1.5e5 + 5;
#define vii vector<pair<int, int> >
#define pii pair<int, int>
#define fi first
#define se second
vii vec[MAX_N << 2];
int tag[MAX_N << 2], len[MAX_N << 2];
int N, M, K;
vii merge(const vii &l, const vii &r) {
	vii res = l;
	for (int i = 0; i < (int)r.size(); i++) {
		bool flag = 1;
		for (int j = 0; j < (int)l.size() && flag; j++)
			if (l[j].fi == r[i].fi) { res[j].se += r[i].se; flag = 0; }
		if (flag) res.emplace_back(r[i]);
	}
	sort(res.begin(), res.end(), [](const pii &l, const pii &r) {return l.se > r.se; });
	while ((int)res.size() > K) {
		int x = res.back().se;
		for (int i = 0, j = res.size() - 1; i <= K; i++, j--)
		 	res[j].se -= x;
		while (!res.back().se) res.pop_back();
	}
	return res;
}
#define lson (o << 1)
#define rson (o << 1 | 1)
void puttag(int o, int v) { vec[o].clear(), vec[o].emplace_back(v, len[o]), tag[o] = v; }
void pushdown(int o) {
	if (!tag[o]) return ;
	puttag(lson, tag[o]), puttag(rson, tag[o]);
	tag[o] = 0;
}
void build(int o, int l, int r) {
	len[o] = r - l + 1;
	if (l == r) {
		int v = gi(); vec[o].emplace_back(v, 1);
		return ;
	}
	int mid = (l + r) >> 1;
	build(lson, l, mid), build(rson, mid + 1, r);
	vec[o] = merge(vec[lson], vec[rson]);
}
void modify(int o, int l, int r, int ql, int qr, int v) {
	if (ql <= l && r <= qr) return puttag(o, v);
	pushdown(o);
	int mid = (l + r) >> 1;
	if (ql <= mid) modify(lson, l, mid, ql, qr, v);
	if (qr > mid) modify(rson, mid + 1, r, ql, qr, v);
	vec[o] = merge(vec[lson], vec[rson]);
}
vii query(int o, int l, int r, int ql, int qr) {
	if (l == ql && r == qr) return vec[o];
	pushdown(o);
	int mid = (l + r) >> 1;
	if (qr <= mid) return query(lson, l, mid, ql, qr);
	else if (ql > mid) return query(rson, mid + 1, r, ql, qr);
	else return merge(query(lson, l, mid, ql, mid), query(rson, mid + 1, r, mid + 1, qr));
}
int main () {
#ifndef ONLINE_JUDGE
    freopen("cpp.in", "r", stdin);
#endif
	N = gi(), M = gi(), K = gi(); K = 100 / K;
	build(1, 1, N);
	while (M--) {
		int op = gi(), l = gi(), r = gi(), v;
		if (op == 1) v = gi(), modify(1, 1, N, l, r, v);
		if (op == 2) {
			vii ans = query(1, 1, N, l, r);
			printf("%lu", ans.size());
			for (pii it : ans) printf(" %d", it.fi);
			putchar('\n');
		}
	}
    return 0;
}


#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#define pii pair<int, int>
#define fi first
#define se second
#define N 200200
using namespace std;

int n, m, p, q;
pii tp[12];

struct Node {
    int cnt;
    pii p[5];
    inline void init(int w = 0, int c = 0) {
        if (!w) return cnt = 0, void();
        cnt = 1, p[0] = make_pair(w, c);
    }
    inline void add(int x) {
        for (int i = 0; i < cnt; ++i)
            p[i].fi += x;
    }
    Node operator+(Node b) {
        int top = 0;
        for (int i = 0; i < cnt; ++i) {
            bool ok = 0;
            for (int j = 0; j < b.cnt; ++j)
                if (p[i].fi == b.p[j].fi)
                    b.p[j].se += p[i].se, ok = 1;
            if (!ok) tp[top++] = p[i];
        }
        for (int i = 0; i < b.cnt; ++i)
            tp[top++] = b.p[i];
        while (top > q) {
            int mi = n;
            for (int i = 0; i < top; ++i)
                if (mi > tp[i].se) mi = tp[i].se;
            for (int i = 0; i < top; ++i) {
                if (tp[i].se > mi) continue;
                tp[i] = make_pair(0, 0);
                swap(tp[i], tp[top - 1]);
                --top, --i;
            }
        }
        Node res;
        res.cnt = top;
        for (int i = 0; i < top; ++i)
            res.p[i] = tp[i];
        return res;
    }
    void print() {
        printf("%d ", cnt);
        for (int i = 0; i < cnt; ++i)
            printf("%d ", p[i].fi);
        putchar('\n');
    }
};

Node tr[N << 2];
int eql[N << 2], pls[N << 2];

#define ls (pos << 1)
#define rs (pos << 1 | 1)

inline void make(int pos, int w, int c) {
    (w < 0) ? (eql[pos] = -w, tr[pos].init(-w, c)) : (pls[pos] += w, tr[pos].add(w));
}

void pushdown(int pos, int cl, int cr) {
    if (eql[pos] + pls[pos] == 0) return ;
    if (eql[pos]) {
        make(ls, -eql[pos], cl);
        make(rs, -eql[pos], cr);
        eql[pos] = 0;
    }
    if (pls[pos]) {
        make(ls, pls[pos], cl);
        make(rs, pls[pos], cr);
        pls[pos] = 0;
    }
}

inline void pushup(int pos) {
    tr[pos] = tr[pos << 1] + tr[pos << 1 | 1];
}

void modify(int L, int R, int w, int l = 1, int r = n, int pos = 1) {
    if (L <= l && r <= R) return make(pos, w, r - l + 1);
    int mid = (l + r) >> 1;
    pushdown(pos, mid - l + 1, r - mid);
    if (L <= mid) modify(L, R, w, l, mid, ls);
    if (mid < R) modify(L, R, w, mid + 1, r, rs);
    pushup(pos);
}

Node query(int L, int R, int l = 1, int r = n, int pos = 1) {
    if (L <= l && r <= R) return tr[pos];
    int mid = (l + r) >> 1;
    pushdown(pos, mid - l + 1, r - mid);
    if (L <= mid && mid < R)
        return query(L, R, l, mid, ls) + query(L, R, mid + 1, r, rs);
    return (L <= mid) ? query(L, R, l, mid, ls) : query(L, R, mid + 1, r, rs);
}

#undef ls
#undef rs

int main() {
#ifdef isLOCAL
    freopen("war.in", "r", stdin);
    freopen("war.out", "w", stdout);
#endif

    cin >> n >> m >> p, q = 100 / p;

    for (int i = 1, w; i <= n; ++i) {
        scanf("%d", &w);
        modify(i, i, -w);
    }

    while (m--) {
        int op, l, r, w;
        scanf("%d%d%d", &op, &l, &r);
        if (op == 1) {
            scanf("%d", &w);
            modify(l, r, -w);
        } else if (op == 3) {
            modify(l, r, 1);
        } else if (op == 2) {
            Node now = query(l, r);
            now.print();
        }
    }

    return 0;
}


#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#define pii pair<int, int>
#define fi first
#define se second
#define N 200200
using namespace std;

int n, m, p, q;
pii tp[12];

struct Node {
    int cnt;
    pii p[5];
    inline void init(int w = 0, int c = 0) {
        if (!w) return cnt = 0, void();
        cnt = 1, p[0] = make_pair(w, c);
    }
    inline void add(int x) {
        for (int i = 0; i < cnt; ++i)
            p[i].fi += x;
    }
    Node operator+(Node b) {
        int top = 0;
        for (int i = 0; i < cnt; ++i) {
            bool ok = 0;
            for (int j = 0; j < b.cnt; ++j)
                if (p[i].fi == b.p[j].fi)
                    b.p[j].se += p[i].se, ok = 1;
            if (!ok) tp[top++] = p[i];
        }
        for (int i = 0; i < b.cnt; ++i)
            tp[top++] = b.p[i];
        while (top > q) {
            int mi = n;
            for (int i = 0; i < top; ++i)
                if (mi > tp[i].se) mi = tp[i].se;
            for (int i = 0; i < top; ++i) {
                tp[i].se -= mi;
                if (tp[i].se) continue;
                swap(tp[i], tp[top - 1]);
                --i, --top;
            }
        }
        Node res;
        res.cnt = top;
        for (int i = 0; i < top; ++i)
            res.p[i] = tp[i];
        return res;
    }
    void print() {
        printf("%d ", cnt);
        for (int i = 0; i < cnt; ++i)
            printf("%d ", p[i].fi);
        putchar('\n');
    }
};

Node tr[N << 2];
int eql[N << 2], pls[N << 2];

#define ls (pos << 1)
#define rs (pos << 1 | 1)

inline void make(int pos, int w, int c) {
    (w < 0) ? (eql[pos] = -w, tr[pos].init(-w, c)) : (pls[pos] += w, tr[pos].add(w));
}

void pushdown(int pos, int cl, int cr) {
    if (eql[pos] + pls[pos] == 0) return ;
    if (eql[pos]) {
        make(ls, -eql[pos], cl);
        make(rs, -eql[pos], cr);
        eql[pos] = 0;
    }
    if (pls[pos]) {
        make(ls, pls[pos], cl);
        make(rs, pls[pos], cr);
        pls[pos] = 0;
    }
}

inline void pushup(int pos) {
    tr[pos] = tr[pos << 1] + tr[pos << 1 | 1];
}

void modify(int L, int R, int w, int l = 1, int r = n, int pos = 1) {
    if (L <= l && r <= R) return make(pos, w, r - l + 1);
    int mid = (l + r) >> 1;
    pushdown(pos, mid - l + 1, r - mid);
    if (L <= mid) modify(L, R, w, l, mid, ls);
    if (mid < R) modify(L, R, w, mid + 1, r, rs);
    pushup(pos);
}

Node query(int L, int R, int l = 1, int r = n, int pos = 1) {
    if (L <= l && r <= R) return tr[pos];
    int mid = (l + r) >> 1;
    pushdown(pos, mid - l + 1, r - mid);
    if (L <= mid && mid < R)
        return query(L, R, l, mid, ls) + query(L, R, mid + 1, r, rs);
    return (L <= mid) ? query(L, R, l, mid, ls) : query(L, R, mid + 1, r, rs);
}

#undef ls
#undef rs

int main() {
#ifdef isLOCAL
    freopen("war.in", "r", stdin);
    freopen("war.out", "w", stdout);
#endif

    cin >> n >> m >> p, q = 100 / p;

    for (int i = 1, w; i <= n; ++i) {
        scanf("%d", &w);
        modify(i, i, -w);
    }

    while (m--) {
        int op, l, r, w;
        scanf("%d%d%d", &op, &l, &r);
        if (op == 1) {
            scanf("%d", &w);
            modify(l, r, -w);
        } else if (op == 4) {
            modify(l, r, 1);
        } else if (op == 2) {
            Node now = query(l, r);
            now.print();
        }
    }

    return 0;
}


#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
#define LL long long
#define Re register int
#define IT vector<QWQ>::iterator
using namespace std;
const int N=15e4+3;
int n,x,y,z,p,K,T,op,A[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct QWQ{int x,k;QWQ(Re X=0,Re K=0){x=X,k=K;}};
struct Segment_Tree{
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid ((L+R)>>1)
	vector<QWQ>tr[N<<2];int add[N<<2];
	inline vector<QWQ> merge(vector<QWQ>A,vector<QWQ>B){
		vector<QWQ>P=A;
		for(Re I=0,SZ=B.size();I<SZ;++I){
			Re flag=0;
			for(Re J=0,SZ_=P.size();J<SZ_;++J)
				if(B[I].x==P[J].x){P[J].k+=B[I].k,flag=1;break;}
			if(flag)continue;
			P.push_back(B[I]);
			if((int)P.size()>K){
				vector<QWQ>tmp;Re Min=2e9;
				for(Re J=0,SZ_=P.size();J<SZ_;++J)Min=min(Min,P[J].k);
				for(Re J=0,SZ_=P.size();J<SZ_;++J)if(P[J].k-Min>0)tmp.push_back(QWQ(P[J].x,P[J].k-Min));
				P=tmp;
			}
		}
		return P;
	}
	inline void build(Re p,Re L,Re R){
		if(L==R){tr[p].push_back(QWQ(A[L],1));return;}
		build(pl,L,mid),build(pr,mid+1,R);
		tr[p]=merge(tr[pl],tr[pr]);
	}
	inline void updata(Re p,Re L,Re R,Re v){
		add[p]=v,tr[p].clear(),tr[p].push_back(QWQ(v,R-L+1));
	}
	inline void pushdown(Re p,Re L,Re R){
		if(add[p])updata(pl,L,mid,add[p]),updata(pr,mid+1,R,add[p]),add[p]=0;
	}
	inline void change(Re p,Re L,Re R,Re l,Re r,Re v){
		if(l<=L&&R<=r){updata(p,L,R,v);return;}
		pushdown(p,L,R);
		if(l<=mid)change(pl,L,mid,l,r,v);
		if(r>mid)change(pr,mid+1,R,l,r,v);
		tr[p]=merge(tr[pl],tr[pr]);
	}
	inline vector<QWQ> ask(Re p,Re L,Re R,Re l,Re r){
		if(l<=L&&R<=r)return tr[p];
		pushdown(p,L,R);
		if(r<=mid)return ask(pl,L,mid,l,r);
		else if(l>mid)return ask(pr,mid+1,R,l,r);
		else return merge(ask(pl,L,mid,l,r),ask(pr,mid+1,R,l,r));
	}
}TR;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),in(p),K=100/p;
	for(Re i=1;i<=n;++i)in(A[i]);
	TR.build(1,1,n);
	while(T--){
		in(op),in(x),in(y);
		if(op<2)in(z),TR.change(1,1,n,x,y,z);
		else{
			vector<QWQ> ans=TR.ask(1,1,n,x,y);
			printf("%d ",ans.size());
			for(Re i=0,SZ=ans.size();i<SZ;++i)printf("%d ",ans[i].x);
			puts("");
		}
	}
}


#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
#define LL long long
#define Re register int
#define IT vector<QWQ>::iterator
using namespace std;
const int N=15e4+3;
int n,x,y,z,p,K,T,op,A[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct QWQ{int x,k;QWQ(Re X=0,Re K=0){x=X,k=K;}};
struct Segment_Tree{
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid ((L+R)>>1)
	vector<QWQ>tr[N<<2];int add[N<<2];
	inline vector<QWQ> merge(vector<QWQ>A,vector<QWQ>B){
		vector<QWQ>P;P=A;
		for(IT x=B.begin();x!=B.end();++x){
			Re flag=0;
			for(Re J=0,SZ_=P.size();J<SZ_;++J)
				if(x->x==P[J].x){P[J].k+=x->k,flag=1;break;}
			if(flag)continue;
			P.push_back(*x);
			if((int)P.size()>K){
				vector<QWQ>tmp;Re Min=2e9;
				for(Re J=0,SZ_=P.size();J<SZ_;++J)Min=min(Min,P[J].k);
				for(Re J=0,SZ_=P.size();J<SZ_;++J)if(P[J].k-Min>0)tmp.push_back(QWQ(tr[p][J].x,tr[p][J].k-Min));
				P=tmp;
			}
		}
		return P;
	}
	inline void build(Re p,Re L,Re R){
		if(L==R){tr[p].push_back(QWQ(A[L],1));return;}
		build(pl,L,mid),build(pr,mid+1,R);
		tr[p]=merge(tr[pl],tr[pr]);
	}
	inline void updata(Re p,Re L,Re R,Re v){
		add[p]=v,tr[p].clear(),tr[p].push_back(QWQ(v,R-L+1));
	}
	inline void pushdown(Re p,Re L,Re R){
		if(add[p])updata(pl,L,mid,add[p]),updata(pr,mid+1,R,add[p]),add[p]=0;
	}
	inline void change(Re p,Re L,Re R,Re l,Re r,Re v){
		if(l<=L&&R<=r){updata(p,L,R,v);return;}
		pushdown(p,L,R);
		if(l<=mid)change(pl,L,mid,l,r,v);
		if(r>mid)change(pr,mid+1,R,l,r,v);
		tr[p]=merge(tr[pl],tr[pr]);
	}
	inline vector<QWQ> ask(Re p,Re L,Re R,Re l,Re r){
		if(l<=L&&R<=r)return tr[p];
		pushdown(p,L,R);
		if(r<=mid)return ask(pl,L,mid,l,r);
		else if(l>mid)return ask(pr,mid+1,R,l,r);
		else return merge(ask(pl,L,mid,l,r),ask(pr,mid+1,R,l,r));
	}
}TR;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),in(p),K=100/p;
	for(Re i=1;i<=n;++i)in(A[i]);
	TR.build(1,1,n);
	while(T--){
		in(op),in(x),in(y);
		if(op<2)in(z),TR.change(1,1,n,x,y,z);
		else{
			vector<QWQ> ans=TR.ask(1,1,n,x,y);
			printf("%d ",ans.size());
			for(Re i=0,SZ=ans.size();i<SZ;++i)printf("%d ",ans[i].x);
			puts("");
		}
	}
}


#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
#define LL long long
#define Re register int
#define IT vector<QWQ>::iterator
using namespace std;
const int N=15e4+3;
int n,x,y,z,p,K,T,op,A[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct QWQ{int x,k;QWQ(Re X=0,Re K=0){x=X,k=K;}};
struct Segment_Tree{
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid ((L+R)>>1)
	vector<QWQ>tr[N<<2];int add[N];
	inline vector<QWQ> merge(vector<QWQ>A,vector<QWQ>B){
		vector<QWQ>P;P=A;
		for(IT x=B.begin();x!=B.end();++x){
			Re flag=0;
			for(Re J=0,SZ_=P.size();J<SZ_;++J)
				if(x->x==P[J].x){P[J].k+=x->k,flag=1;break;}
			if(flag)continue;
			P.push_back(*x);
			if((int)P.size()>K){
				vector<QWQ>tmp;Re Min=2e9;
				for(Re J=0,SZ_=P.size();J<SZ_;++J)Min=min(Min,P[J].k);
				for(Re J=0,SZ_=P.size();J<SZ_;++J)if(P[J].k-Min>0)tmp.push_back(QWQ(tr[p][J].x,tr[p][J].k-Min));
				P=tmp;
			}
		}
		return P;
	}
	inline void build(Re p,Re L,Re R){
		if(L==R){tr[p].push_back(QWQ(A[L],1));return;}
		build(pl,L,mid),build(pr,mid+1,R);
		tr[p]=merge(tr[pl],tr[pr]);
	}
	inline void updata(Re p,Re L,Re R,Re v){
		add[p]=v,tr[p].clear(),tr[p].push_back(QWQ(v,R-L+1));
	}
	inline void pushdown(Re p,Re L,Re R){
		if(add[p])updata(pl,L,mid,add[p]),updata(pr,mid+1,R,add[p]),add[p]=0;
	}
	inline void change(Re p,Re L,Re R,Re l,Re r,Re v){
		if(l<=L&&R<=r){updata(p,L,R,v);return;}
		pushdown(p,L,R);
		if(l<=mid)change(pl,L,mid,l,r,v);
		if(r>mid)change(pr,mid+1,R,l,r,v);
		tr[p]=merge(tr[pl],tr[pr]);
	}
	inline vector<QWQ> ask(Re p,Re L,Re R,Re l,Re r){
		if(l<=L&&R<=r)return tr[p];
		pushdown(p,L,R);
		if(r<=mid)return ask(pl,L,mid,l,r);
		else if(l>mid)return ask(pr,mid+1,R,l,r);
		else return merge(ask(pl,L,mid,l,r),ask(pr,mid+1,R,l,r));
	}
}TR;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),in(p),K=100/p;
	for(Re i=1;i<=n;++i)in(A[i]);
	TR.build(1,1,n);
	while(T--){
		in(op),in(x),in(y);
		if(op<2)in(z),TR.change(1,1,n,x,y,z);
		else{
			vector<QWQ> ans=TR.ask(1,1,n,x,y);
			printf("%d ",ans.size());
			for(Re i=0,SZ=ans.size();i<SZ;++i)printf("%d ",ans[i].x);
			puts("");
		}
	}
}


#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
#define LL long long
#define Re register int
#define IT vector<QWQ>::iterator
using namespace std;
const int N=15e4+3;
int n,x,y,z,p,K,T,op,A[N];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
struct QWQ{int x,k;QWQ(Re X=0,Re K=0){x=X,k=K;}};
struct Segment_Tree{
	#define pl (p<<1)
	#define pr (p<<1|1)
	#define mid ((L+R)>>1)
	vector<QWQ>tr[N<<2];int add[N];
	inline vector<QWQ> merge(vector<QWQ>A,vector<QWQ>B){
		vector<QWQ>P;P=A;
		for(IT x=B.begin();x!=B.end();++x){
			Re flag=0;
			for(Re J=0,SZ_=P.size();J<SZ_;++J)
				if(x->x==P[J].x){P[J].k+=x->k,flag=1;break;}
			if(flag)continue;
			P.push_back(*x);
			if((int)P.size()>K){
				vector<QWQ>tmp;Re Min=2e9;
				for(Re J=0,SZ_=P.size();J<SZ_;++J)Min=min(Min,P[J].k);
				for(Re J=0,SZ_=P.size();J<SZ_;++J)if(P[J].k-Min>0)tmp.push_back(QWQ(tr[p][J].x,tr[p][J].k-Min));
				P=tmp;
			}
		}
		return P;
	}
	inline void build(Re p,Re L,Re R){
		if(L==R){tr[p].push_back(QWQ(A[L],1));return;}
		build(pl,L,mid),build(pr,mid+1,R);
		tr[p]=merge(tr[pl],tr[pr]);
	}
	inline void updata(Re p,Re L,Re R,Re v){
		add[p]=v,tr[p].clear(),tr[p].push_back(QWQ(v,R-L+1));
	}
	inline void pushdown(Re p,Re L,Re R){
		if(add[p])updata(pl,L,mid,add[p]),updata(pr,mid+1,R,add[p]),add[p]=0;
	}
	inline void change(Re p,Re L,Re R,Re l,Re r,Re v){
		if(l<=L&&R<=r){updata(p,L,R,v);return;}
		if(l<=mid)change(pl,L,mid,l,r,v);
		if(r>mid)change(pr,mid+1,R,l,r,v);
		tr[p]=merge(tr[pl],tr[pr]);
	}
	inline vector<QWQ> ask(Re p,Re L,Re R,Re l,Re r){
		if(l<=L&&R<=r)return tr[p];
		if(r<=mid)return ask(pl,L,mid,l,r);
		else if(l>mid)return ask(pr,mid+1,R,l,r);
		else return merge(ask(pl,L,mid,l,r),ask(pr,mid+1,R,l,r));
	}
}TR;
int main(){
//	freopen("123.txt","r",stdin);
	in(n),in(T),in(p),K=100/p;
	for(Re i=1;i<=n;++i)in(A[i]);
	TR.build(1,1,n);
	while(T--){
		in(op),in(x),in(y);
		if(op<2)in(z),TR.change(1,1,n,x,y,z);
		else{
			vector<QWQ> ans=TR.ask(1,1,n,x,y);
			printf("%d ",ans.size());
			for(Re i=0,SZ=ans.size();i<SZ;++i)printf("%d ",ans[i]);
			puts("");
		}
	}
}


#include<bits/stdc++.h>
#define N 150005
using namespace std;

int n,p,q;

struct node{
	int s,a[5],b[5];
	void fill(int x,int y){
		s=1; a[0]=x; b[0]=y;
	}
}t[525000];

node operator +(const node &a,const node &b){
	node c; c=a;
	for (int i=0;i<b.s;i++){
		int fl=0;
		for (int j=0;j<c.s;j++)
			if (c.a[j]==b.a[i]){
				c.b[j]+=b.b[i];
				fl=1;
				break;
			}
		if (fl) continue;
		if (c.s<p){
			c.a[c.s]=b.a[i];
			c.b[c.s]=b.b[i];
			c.s++;
			continue;
		}
		int k=0;
		for (int j=1;j<c.s;j++)
			if (c.b[j]<c.b[k]) k=j;
		if (b.b[i]<c.b[k])
			for (int j=0;j<c.s;j++)
				c.b[j]-=b.b[i];
		else{
			int tmp=c.b[k];
			c.a[k]=b.a[i];
			c.b[k]=b.b[i];
			for (int j=0;j<c.s;j++)
				c.b[j]-=tmp;
		}
	}
	return c;
}

int a[N];

int tg[525000];

void build(int k,int l,int r){
	if (l==r){
		t[k].fill(a[l],1);
		return;
	}
	int mid=(l+r)/2;
	build(k*2,l,mid);
	build(k*2+1,mid+1,r);
	t[k]=t[k*2]+t[k*2+1];
}

void pushdown(int k,int l,int r){
	if (!tg[k]) return;
	int mid=(l+r)/2;
	t[k*2].fill(tg[k],mid-l+1);
	t[k*2+1].fill(tg[k],r-mid);
	tg[k*2]=tg[k*2+1]=tg[k];
	tg[k]=0;
}

void change(int k,int l,int r,int x,int y,int v){
	if (l==x&&r==y){
		t[k].fill(v,r-l+1);
		tg[k]=v;
		return;
	}
	pushdown(k,l,r);
	int mid=(l+r)/2;
	if (y<=mid) change(k*2,l,mid,x,y,v);
	else if (x>mid) change(k*2+1,mid+1,r,x,y,v);
	else change(k*2,l,mid,x,mid,v),
		 change(k*2+1,mid+1,r,mid+1,y,v);
	t[k]=t[k*2]+t[k*2+1];
}

node ask(int k,int l,int r,int x,int y){
	if (l==x&&r==y) return t[k];
	pushdown(k,l,r);
	int mid=(l+r)/2;
	if (y<=mid) return ask(k*2,l,mid,x,y);
	if (x>mid) return ask(k*2+1,mid+1,r,x,y);
	return ask(k*2,l,mid,x,mid)+ask(k*2+1,mid+1,r,mid+1,y);
}

int main(){
	scanf("%d%d%d",&n,&q,&p);
	p=100/p;
	for (int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	build(1,1,n);
	while (q--){
		int tp,l,r,x;
		scanf("%d%d%d",&tp,&l,&r);
		if (tp==1){
			scanf("%d",&x);
			change(1,1,n,l,r,x);
		}
		else{
			node ans=ask(1,1,n,l,r);
			printf("%d",ans.s);
			for (int i=0;i<ans.s;i++)
				printf(" %d",ans.a[i]);
			puts("");
		}
	}
}


#include<bits/stdc++.h>
#define N 150005
using namespace std;

int n,p,q;

struct node{
	int s,a[5],b[5];
	void fill(int x,int y){
		s=1; a[0]=x; b[0]=y;
	}
}t[525000];
node operator +(const node &a,const node &b){
	node c; c=a;
	for (int i=0;i<b.s;i++){
		int fl=0;
		for (int j=0;j<a.s;j++)
			if (c.a[j]==b.a[i]){
				c.b[j]+=b.b[i];
				fl=1;
				break;
			}
		if (fl) continue;
		if (c.s<p){
			c.a[c.s]=b.a[i];
			c.b[c.s]=b.b[i];
			c.s++;
			continue;
		}
		int k=0;
		for (int j=1;j<c.s;j++)
			if (c.b[j]<c.b[k]) k=j;
		if (b.b[i]<c.b[k])
			for (int j=0;j<c.s;j++)
				c.b[j]-=b.b[i];
		else{
			int tmp=c.b[k];
			c.a[k]=b.a[i];
			c.b[k]=b.a[i];
			for (int j=0;j<c.s;j++)
				c.b[j]-=tmp;
		}
	}
	return c;
}

int a[N];

int tg[525000];

void build(int k,int l,int r){
	if (l==r){
		t[k].fill(a[l],1);
		return;
	}
	int mid=(l+r)/2;
	build(k*2,l,mid);
	build(k*2+1,mid+1,r);
	t[k]=t[k*2]+t[k*2+1];
}

void pushdown(int k,int l,int r){
	if (!tg[k]) return;
	int mid=(l+r)/2;
	t[k*2].fill(tg[k],mid-l+1);
	t[k*2+1].fill(tg[k],r-mid);
	tg[k*2]=tg[k*2+1]=tg[k];
	tg[k]=0;
}

void change(int k,int l,int r,int x,int y,int v){
	if (l==x&&r==y){
		t[k].fill(v,r-l+1);
		return;
	}
	pushdown(k,l,r);
	int mid=(l+r)/2;
	if (y<=mid) change(k*2,l,mid,x,y,v);
	else if (x>mid) change(k*2+1,mid+1,r,x,y,v);
	else change(k*2,l,mid,x,mid,v),
		 change(k*2+1,mid+1,r,mid+1,y,v);
	t[k]=t[k*2]+t[k*2+1];
}

node ask(int k,int l,int r,int x,int y){
	if (l==x&&r==y) return t[k];
	pushdown(k,l,r);
	int mid=(l+r)/2;
	if (y<=mid) return ask(k*2,l,mid,x,y);
	if (x>mid) return ask(k*2+1,mid+1,r,x,y);
	return ask(k*2,l,mid,x,mid)+ask(k*2+1,mid+1,r,mid+1,y);
}

int main(){
	scanf("%d%d%d",&n,&q,&p);
	p=100/p;
	for (int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	build(1,1,n);
	while (q--){
		int tp,l,r,x;
		scanf("%d%d%d",&tp,&l,&r);
		if (tp==1){
			scanf("%d",&x);
			change(1,1,n,l,r,x);
		}
		else{
			node ans=ask(1,1,n,l,r);
			printf("%d",ans.s);
			for (int i=0;i<ans.s;i++)
				printf(" %d",ans.a[i]);
			puts("");
		}
	}
}


#include<bits/stdc++.h>
#define N 150005
using namespace std;

int n,p,q;

struct node{
	int s,a[5],b[5];
	void fill(int x,int y){
		s=1; a[0]=x; b[0]=y;
	}
}t[525000];

node operator +(const node &a,const node &b){
	node c; c=a;
	for (int i=0;i<b.s;i++){
		int fl=0;
		for (int j=0;j<a.s;j++)
			if (c.a[j]==b.a[i]){
				c.b[j]+=b.b[i];
				fl=1;
				break;
			}
		if (fl) continue;
		if (c.s<p){
			c.a[c.s]=b.a[i];
			c.b[c.s]=b.b[i];
			c.s++;
			continue;
		}
		int k=0;
		for (int j=1;j<c.s;j++)
			if (c.b[j]<c.b[k]) k=j;
		if (b.b[i]<c.b[k])
			for (int j=0;j<c.s;j++)
				c.b[j]-=b.b[i];
		else{
			int tmp=c.b[k];
			c.a[k]=b.a[i];
			c.b[k]=b.a[i];
			for (int j=0;j<c.s;j++)
				c.b[j]-=tmp;
		}
	}
	return c;
}

int a[N];

int tg[525000];

void build(int k,int l,int r){
	if (l==r){
		t[k].fill(a[l],1);
		return;
	}
	int mid=(l+r)/2;
	build(k*2,l,mid);
	build(k*2+1,mid+1,r);
	t[k]=t[k*2]+t[k*2+1];
}

void pushdown(int k,int l,int r){
	if (!tg[k]) return;
	int mid=(l+r)/2;
	t[k*2].fill(tg[k],mid-l+1);
	t[k*2+1].fill(tg[k],r-mid);
	tg[k*2]=tg[k*2+1]=tg[k];
	tg[k]=0;
}

void change(int k,int l,int r,int x,int y,int v){
	if (l==x&&r==y){
		t[k].fill(v,r-l+1);
		tg[k]=v;
		return;
	}
	pushdown(k,l,r);
	int mid=(l+r)/2;
	if (y<=mid) change(k*2,l,mid,x,y,v);
	else if (x>mid) change(k*2+1,mid+1,r,x,y,v);
	else change(k*2,l,mid,x,mid,v),
		 change(k*2+1,mid+1,r,mid+1,y,v);
	t[k]=t[k*2]+t[k*2+1];
}

node ask(int k,int l,int r,int x,int y){
	if (l==x&&r==y) return t[k];
	pushdown(k,l,r);
	int mid=(l+r)/2;
	if (y<=mid) return ask(k*2,l,mid,x,y);
	if (x>mid) return ask(k*2+1,mid+1,r,x,y);
	return ask(k*2,l,mid,x,mid)+ask(k*2+1,mid+1,r,mid+1,y);
}

int main(){
	scanf("%d%d%d",&n,&q,&p);
	p=100/p;
	for (int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	build(1,1,n);
	while (q--){
		int tp,l,r,x;
		scanf("%d%d%d",&tp,&l,&r);
		if (tp==1){
			scanf("%d",&x);
			change(1,1,n,l,r,x);
		}
		else{
			node ans=ask(1,1,n,l,r);
			printf("%d",ans.s);
			for (int i=0;i<ans.s;i++)
				printf(" %d",ans.a[i]);
			puts("");
		}
	}
}


#include<bits/stdc++.h>
#define N 150005
using namespace std;

int n,p,q;

struct node{
	int s,a[5],b[5];
	void fill(int x,int y){
		s=1; a[0]=x; b[0]=y;
	}
}t[525000];

node operator +(const node &a,const node &b){
	node c; c=a;
	for (int i=0;i<b.s;i++){
		int fl=0;
		for (int j=0;j<c.s;j++)
			if (c.a[j]==b.a[i]){
				c.b[j]+=b.b[i];
				fl=1;
				break;
			}
		if (fl) continue;
		if (c.s<p){
			c.a[c.s]=b.a[i];
			c.b[c.s]=b.b[i];
			c.s++;
			continue;
		}
		int k=0;
		for (int j=1;j<c.s;j++)
			if (c.b[j]<c.b[k]) k=j;
		if (b.b[i]<c.b[k])
			for (int j=0;j<c.s;j++)
				c.b[j]-=b.b[i];
		else{
			int tmp=c.b[k];
			c.a[k]=b.a[i];
			c.b[k]=b.a[i];
			for (int j=0;j<c.s;j++)
				c.b[j]-=tmp;
		}
	}
	return c;
}

int a[N];

int tg[525000];

void build(int k,int l,int r){
	if (l==r){
		t[k].fill(a[l],1);
		return;
	}
	int mid=(l+r)/2;
	build(k*2,l,mid);
	build(k*2+1,mid+1,r);
	t[k]=t[k*2]+t[k*2+1];
}

void pushdown(int k,int l,int r){
	if (!tg[k]) return;
	int mid=(l+r)/2;
	t[k*2].fill(tg[k],mid-l+1);
	t[k*2+1].fill(tg[k],r-mid);
	tg[k*2]=tg[k*2+1]=tg[k];
	tg[k]=0;
}

void change(int k,int l,int r,int x,int y,int v){
	if (l==x&&r==y){
		t[k].fill(v,r-l+1);
		tg[k]=v;
		return;
	}
	pushdown(k,l,r);
	int mid=(l+r)/2;
	if (y<=mid) change(k*2,l,mid,x,y,v);
	else if (x>mid) change(k*2+1,mid+1,r,x,y,v);
	else change(k*2,l,mid,x,mid,v),
		 change(k*2+1,mid+1,r,mid+1,y,v);
	t[k]=t[k*2]+t[k*2+1];
}

node ask(int k,int l,int r,int x,int y){
	if (l==x&&r==y) return t[k];
	pushdown(k,l,r);
	int mid=(l+r)/2;
	if (y<=mid) return ask(k*2,l,mid,x,y);
	if (x>mid) return ask(k*2+1,mid+1,r,x,y);
	return ask(k*2,l,mid,x,mid)+ask(k*2+1,mid+1,r,mid+1,y);
}

int main(){
	scanf("%d%d%d",&n,&q,&p);
	p=100/p;
	for (int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	build(1,1,n);
	while (q--){
		int tp,l,r,x;
		scanf("%d%d%d",&tp,&l,&r);
		if (tp==1){
			scanf("%d",&x);
			change(1,1,n,l,r,x);
		}
		else{
			node ans=ask(1,1,n,l,r);
			printf("%d",ans.s);
			for (int i=0;i<ans.s;i++)
				printf(" %d",ans.a[i]);
			puts("");
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
#define N 150005
#define L (k<<1)
#define R (L+1)
#define mid (l+r>>1)
#define vii vector<pair<int,int> >
#define fi first
#define se second
vii empty,v,f[N<<2];
int n,m,p,a[N],tag[N<<2];
vii merge(vii x,vii y){
	v.clear();
	for(int i=0,j=0;(i<x.size())||(j<y.size());){
		pair<int,int> o;
		if ((i<x.size())&&((j==y.size())||(x[i].fi<y[j].fi)))o=x[i++];
		else o=y[j++];
		if ((v.size())&&(o.fi==v[v.size()-1].fi))v[v.size()-1].se+=o.se;
		else v.push_back(o);
	}
	while (v.size()>=p){
		int mn=v[0].se;
		for(int i=1;i<p;i++)mn=min(mn,v[i].se);
		for(int i=p-1;i>=0;i--){
			v[i].se-=mn;
			if (!v[i].se)v.erase(v.begin()+i);
		}
	}
	return v;
}
void upd(int k,int l,int r,int x){
	tag[k]=x;
	f[k].clear();
	f[k].push_back(make_pair(x,r-l+1));
}
void down(int k,int l,int r){
	if (tag[k]){
		upd(L,l,mid,tag[k]);
		upd(R,mid+1,r,tag[k]);
		tag[k]=0;
	}
}
void build(int k,int l,int r){
	if (l==r){
		f[k].push_back(make_pair(a[l],1));
		return;
	}
	build(L,l,mid);
	build(R,mid+1,r);
	f[k]=merge(f[L],f[R]);
}
void update(int k,int l,int r,int x,int y,int z){
	if ((l>y)||(x>r))return;
	if ((x<=l)&&(r<=y)){
		upd(k,l,r,z);
		return;
	}
	down(k,l,r);
	update(L,l,mid,x,y,z);
	update(R,mid+1,r,x,y,z);
	f[k]=merge(f[L],f[R]);
}
vii query(int k,int l,int r,int x,int y){
	if ((l>y)||(x>r))return empty;
	if ((x<=l)&&(r<=y))return f[k];
	down(k,l,r);
	return merge(query(L,l,mid,x,y),query(R,mid+1,r,x,y));
}
int main(){
	scanf("%d%d%d",&n,&m,&p);
	p=100/p+1;
	for(int i=1;i<=n;i++)scanf("%d",&a[i]);
	build(1,1,n);
	for(int i=1;i<=m;i++){
		int p,l,r,x;
		scanf("%d%d%d",&p,&l,&r);
		if (p==1){
			scanf("%d",&x);
			update(1,1,n,l,r,x);
		}
		else{
			v=query(1,1,n,l,r);
			printf("%d ",v.size());
			for(int j=0;j<v.size();j++)printf("%d ",v[j].fi);
			printf("\n");
		}
	}
}


#include <math.h>
#include <cstdio>
#include <map>
#include <algorithm>
using namespace std;
const double eps = 1e-5;
#define REP(i,n) for(int i = 0; i < n; i++)
struct point{double x,y;};
struct line{point a,b;};
point p[110];
int n ;
double ans ;
double dis(point p1,point p2){
  return (p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y);
}
point intersection(line u,line v){
  point ret=u.a;
  double t=((u.a.x-v.a.x)*(v.a.y-v.b.y)-(u.a.y-v.a.y)*(v.a.x-v.b.x))
      /((u.a.x-u.b.x)*(v.a.y-v.b.y)-(u.a.y-u.b.y)*(v.a.x-v.b.x));
  ret.x+=(u.b.x-u.a.x)*t;
  ret.y+=(u.b.y-u.a.y)*t;
  return ret;
}
//外心
point circumcenter(point a,point b,point c){
  line u,v;
  u.a.x=(a.x+b.x)/2;
  u.a.y=(a.y+b.y)/2;
  u.b.x=u.a.x-a.y+b.y;
  u.b.y=u.a.y+a.x-b.x;
  v.a.x=(a.x+c.x)/2;
  v.a.y=(a.y+c.y)/2;
  v.b.x=v.a.x-a.y+c.y;
  v.b.y=v.a.y+a.x-c.x;
  return intersection(u,v);
}
void Init() {
  scanf("%d",&n);
  REP(i,n) {
     scanf("%lf%lf",&p[i].x,&p[i].y);
  }
}
void Gao() {
  ans = -1;
 for(int i = 0; i < n; i++)
 for(int j = i+1; j < n; j++)
 for(int k = j+1; k < n; k++)
    {    double d[3];
        d[0] = dis(p[i],p[j]);
        d[1] = dis(p[i],p[k]);
        d[2] = dis(p[j],p[k]);
        if(d[0] == d[1] + d[2])
        {
          int aim = -1;
            REP(l,n)
            {
              if(l == i || l==j || l==k) continue;
              double d1 = dis(p[i],p[l]);
              double d2 = dis(p[j],p[l]);
              if(d[0] == d1 + d2) aim = l;
            }
            if(aim!=-1)
            {
               point c;
               c.x = (p[i].x+p[j].x) / 2;
               c.y = (p[i].y+p[j].y) / 2;
               double dx = dis(c,p[i]);
               bool f = true;
                 REP(kk,n) {
                      if(kk!=i && kk!=j && kk!=k) {
                      double dd = dis(c,p[kk]) ;
                          if(dd - dx < -eps) {
                          f = false;
                          break;
                         }
                      }
                 }
                 if(f) ans = max(ans,dx);
            }
        }
        sort(d,d+3);
        if(d[0]+d[1] <= d[2]) continue;
        point a = circumcenter(p[i],p[j],p[k]);
        double dx = dis(a,p[i]);
        bool f = true;
        REP(kk,n)
        {
            if(kk!=i && kk!=j && kk!=k) {
              double dd = dis(a,p[kk]) ;
              if(dd - dx < -eps) {
                f = false;
                break;
              }
            }
        }
        if(f) ans = max(ans,dx) ;
    }
    printf("%lf",sqrt(ans));
}
int main(){
  Init();
  Gao();
  return 0;
}


#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <queue>
#include <cstring>
#include <string>
#include <cmath>
#include <ctime>
#pragma comment (linker, "/STACK:256000000")

using namespace std;

struct pt {
	int x, y;
};

bool cmp (pt a, pt b) {
	return a.x < b.x || a.x == b.x && a.y < b.y;
}

bool cw (pt a, pt b, pt c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) < 0;
}

bool ccw (pt a, pt b, pt c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) > 0;
}

void convex_hull (vector<pt> & a) {
	if (a.size() == 1)  return;
	sort (a.begin(), a.end(), &cmp);
	pt p1 = a[0],  p2 = a.back();
	vector<pt> up, down;
	up.push_back (p1);
	down.push_back (p1);
	for (size_t i=1; i<a.size(); ++i) {
		if (i==a.size()-1 || cw (p1, a[i], p2)) {
			while (up.size()>=2 && !cw (up[up.size()-2], up[up.size()-1], a[i]))
				up.pop_back();
			up.push_back (a[i]);
		}
		if (i==a.size()-1 || ccw (p1, a[i], p2)) {
			while (down.size()>=2 && !ccw (down[down.size()-2], down[down.size()-1], a[i]))
				down.pop_back();
			down.push_back (a[i]);
		}
	}
	a.clear();
	for (size_t i=0; i<up.size(); ++i)
		a.push_back (up[i]);
	for (size_t i=down.size()-2; i>0; --i)
		a.push_back (down[i]);
}

const int maxN = 110;
int n;
int x[maxN], y[maxN];
double d[maxN][maxN];
int dd[maxN][maxN];
int a[maxN][maxN][maxN];

double dist(double x1, double y1, double x2, double y2) {
	double dx = x1 - x2;
	double dy = y1 - y2;
	return sqrt(dx * dx + dy * dy);
}

double res = 0.0;
const double eps = 1e-9;

int getScalar(int i, int j, int k) {
	return (x[i] - x[j]) * (x[i] - x[k]) + (y[i] - y[j]) * (y[i] - y[k]);
}

void getCenter(int i, int j, int k, double& u, double& v) {
	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (double)(::a[i][j][k]) / 2.0;
	S = 8.0 * S * S;

	double A = (a * a) / S * getScalar(i, j, k);
	double B = (b * b) / S * getScalar(j, i, k);
	double C = (c * c) / S * getScalar(k, i, j);

	u = (double)(x[i]) * A + (double)(x[j]) * B + (double)(x[k]) * C;
	v = (double)(y[i]) * A + (double)(y[j]) * B + (double)(y[k]) * C;
}

vector < pt > w;
double wS;

double solve(int i, int j, int k) {
	/*int p = dd[i][j];
	int q = dd[i][k];
	int r = dd[j][k];
	if (p > q) {
		swap(p, q);
	}
	if (p > r) {
		swap(p, r);
	}
	if (q > r) {
		swap(q, r);
	}
	if (p + q - r < 0) {
		return 0.0;
	}*/

	double cx, cy;
	getCenter(i, j, k, cx, cy);

	double area = 0.0;
	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		double x1 = (double)(w[i].x) - cx;
		double y1 = (double)(w[i].y) - cy;
		double x2 = (double)(w[j].x) - cx;
		double y2 = (double)(w[j].y) - cy;
		area += fabs(x1 * y2 - x2 * y1);
	}

	if (fabs(area - wS) > eps) {
		return 0.0;
	}

	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		double d = dist(w[i].x, w[i].y, w[j].x, w[j].y);
		double a = dist(w[i].x, w[i].y, cx, cy);
		double b = dist(w[j].x, w[j].y, cx, cy);
		if (fabs(d - a - b) < eps) {
			return 0.0;
		}
	}

	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	S = fabs(S) / 2.0;

	if (fabs(S) < eps) {
		return 0.0;
	}

	double R = (a * b * c) / (4.0 * S);
	double L = max(a, max(b, c)) / 2.0;

	for (int t = 1; t <= n; ++t) {
		double current = dist(x[t], y[t], cx, cy);
		R = min(R, current);
	}

	return R;
}

int getArea(int i, int j, int k) {
	int S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	return (S > 0 ? S : -S);
}

int main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		scanf("%d%d", &x[i], &y[i]);
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			d[i][j] = dist(x[i], y[i], x[j], y[j]);
			dd[i][j] = (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
		}
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			for (int k = 1; k <= n; ++k) {
				a[i][j][k] = getArea(i, j, k);
			}
		}
	}

	for (int i = 1; i <= n; ++i) {
		pt p;
		p.x = x[i];
		p.y = y[i];
		w.push_back(p);
	}
	convex_hull(w);
	wS = 0.0;
	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		wS += w[i].x * w[j].y - w[i].y * w[j].x;
	}
	wS = fabs(wS);

	for (int i = 1; i <= n; ++i) {
		for (int j = i + 1; j <= n; ++j) {
			for (int k = j + 1; k <= n; ++k) {
				res = max(res, solve(i, j, k));
				//int S = a[i][j][k];
				//bool nice = true;

				/*for (int l = 1; l <= n; ++l) {
					if (l == i || l == j || l == k) {
						continue;
					}
					if (a[i][j][l] + a[i][k][l] + a[j][k][l] == S) {
						nice = false;
						break;
					}
				}*/

				//if (nice) {
				//	res = max(res, solve(i, j, k));
				//}
			}
		}
	}

	if (res < eps) {
		printf("-1\n");
		return 0;
	}

	printf("%.10lf\n", res);

	return 0;
}


#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <queue>
#include <cstring>
#include <string>
#include <cmath>
#include <ctime>
#pragma comment (linker, "/STACK:256000000")

using namespace std;

struct pt {
	int x, y;
};

bool cmp (pt a, pt b) {
	return a.x < b.x || a.x == b.x && a.y < b.y;
}

bool cw (pt a, pt b, pt c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) < 0;
}

bool ccw (pt a, pt b, pt c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) > 0;
}

void convex_hull (vector<pt> & a) {
	if (a.size() == 1)  return;
	sort (a.begin(), a.end(), &cmp);
	pt p1 = a[0],  p2 = a.back();
	vector<pt> up, down;
	up.push_back (p1);
	down.push_back (p1);
	for (size_t i=1; i<a.size(); ++i) {
		if (i==a.size()-1 || cw (p1, a[i], p2)) {
			while (up.size()>=2 && !cw (up[up.size()-2], up[up.size()-1], a[i]))
				up.pop_back();
			up.push_back (a[i]);
		}
		if (i==a.size()-1 || ccw (p1, a[i], p2)) {
			while (down.size()>=2 && !ccw (down[down.size()-2], down[down.size()-1], a[i]))
				down.pop_back();
			down.push_back (a[i]);
		}
	}
	a.clear();
	for (size_t i=0; i<up.size(); ++i)
		a.push_back (up[i]);
	for (size_t i=down.size()-2; i>0; --i)
		a.push_back (down[i]);
}

const int maxN = 110;
int n;
int x[maxN], y[maxN];
double d[maxN][maxN];
int dd[maxN][maxN];
int a[maxN][maxN][maxN];

double dist(double x1, double y1, double x2, double y2) {
	double dx = x1 - x2;
	double dy = y1 - y2;
	return sqrt(dx * dx + dy * dy);
}

double res = 0.0;
const double eps = 1e-9;

int getScalar(int i, int j, int k) {
	return (x[i] - x[j]) * (x[i] - x[k]) + (y[i] - y[j]) * (y[i] - y[k]);
}

void getCenter(int i, int j, int k, double& u, double& v) {
	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (double)(::a[i][j][k]) / 2.0;
	S = 8.0 * S * S;

	double A = (a * a) / S * getScalar(i, j, k);
	double B = (b * b) / S * getScalar(j, i, k);
	double C = (c * c) / S * getScalar(k, i, j);

	u = (double)(x[i]) * A + (double)(x[j]) * B + (double)(x[k]) * C;
	v = (double)(y[i]) * A + (double)(y[j]) * B + (double)(y[k]) * C;
}

vector < pt > w;
double wS;

double solve(int i, int j, int k) {
	int p = dd[i][j];
	int q = dd[i][k];
	int r = dd[j][k];
	if (p > q) {
		swap(p, q);
	}
	if (p > r) {
		swap(p, r);
	}
	if (q > r) {
		swap(q, r);
	}
	if (p + q - r < 0) {
		return 0.0;
	}

	double cx, cy;
	getCenter(i, j, k, cx, cy);

	/*double area = 0.0;
	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		double x1 = (double)(w[i].x) - cx;
		double y1 = (double)(w[i].y) - cy;
		double x2 = (double)(w[j].x) - cx;
		double y2 = (double)(w[j].y) - cy;
		area += fabs(x1 * y2 - x2 * y1);
	}

	if (fabs(area - wS) > eps) {
		return 0.0;
	}*/

	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		double d = dist(w[i].x, w[i].y, w[j].x, w[j].y);
		double a = dist(w[i].x, w[i].y, cx, cy);
		double b = dist(w[j].x, w[j].y, cx, cy);
		if (fabs(d - a - b) < eps) {
			return 0.0;
		}
	}

	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	S = fabs(S) / 2.0;

	if (fabs(S) < eps) {
		return 0.0;
	}

	double R = (a * b * c) / (4.0 * S);
	double L = max(a, max(b, c)) / 2.0;

	for (int t = 1; t <= n; ++t) {
		double current = dist(x[t], y[t], cx, cy);
		if (current < R - 1e-6) {
			return 0.0;
			//R = min(R, current);
		}
	}

	return R;
}

int getArea(int i, int j, int k) {
	int S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	return (S > 0 ? S : -S);
}

int main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		scanf("%d%d", &x[i], &y[i]);
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			d[i][j] = dist(x[i], y[i], x[j], y[j]);
			dd[i][j] = (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
		}
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			for (int k = 1; k <= n; ++k) {
				a[i][j][k] = getArea(i, j, k);
			}
		}
	}

	for (int i = 1; i <= n; ++i) {
		pt p;
		p.x = x[i];
		p.y = y[i];
		w.push_back(p);
	}
	convex_hull(w);
	wS = 0.0;
	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		wS += w[i].x * w[j].y - w[i].y * w[j].x;
	}
	wS = fabs(wS);

	for (int i = 1; i <= n; ++i) {
		for (int j = i + 1; j <= n; ++j) {
			for (int k = j + 1; k <= n; ++k) {
				//res = max(res, solve(i, j, k));
				int S = a[i][j][k];
				bool nice = true;

				for (int l = 1; l <= n; ++l) {
					if (l == i || l == j || l == k) {
						continue;
					}
					if (a[i][j][l] + a[i][k][l] + a[j][k][l] == S) {
						nice = false;
						break;
					}
				}

				if (nice) {
					res = max(res, solve(i, j, k));
				}
			}
		}
	}

	if (res < eps) {
		printf("-1\n");
		return 0;
	}

	printf("%.10lf\n", res);

	return 0;
}


#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <queue>
#include <cstring>
#include <string>
#include <cmath>
#include <ctime>
#pragma comment (linker, "/STACK:256000000")

using namespace std;

const int maxN = 110;
int n;
int x[maxN], y[maxN];
double d[maxN][maxN];
int dd[maxN][maxN];
int a[maxN][maxN][maxN];

double dist(double x1, double y1, double x2, double y2) {
	double dx = x1 - x2;
	double dy = y1 - y2;
	return sqrt(dx * dx + dy * dy);
}

double res = 0.0;
const double eps = 1e-9;

int getScalar(int i, int j, int k) {
	return (x[i] - x[j]) * (x[i] - x[k]) + (y[i] - y[j]) * (y[i] - y[k]);
}

void getCenter(int i, int j, int k, double& u, double& v) {
	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (double)(::a[i][j][k]) / 2.0;
	S = 8.0 * S * S;

	double A = (a * a) / S * getScalar(i, j, k);
	double B = (b * b) / S * getScalar(j, i, k);
	double C = (c * c) / S * getScalar(k, i, j);

	u = (double)(x[i]) * A + (double)(x[j]) * B + (double)(x[k]) * C;
	v = (double)(y[i]) * A + (double)(y[j]) * B + (double)(y[k]) * C;
}

double solve(int i, int j, int k) {
	int p = dd[i][j];
	int q = dd[i][k];
	int r = dd[j][k];
	if (p > q) {
		swap(p, q);
	}
	if (p > r) {
		swap(p, r);
	}
	if (q > r) {
		swap(q, r);
	}
	if (p + q - r < 0) {
		return 0.0;
	}

	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	S = fabs(S) / 2.0;

	if (fabs(S) < eps) {
		return 0.0;
	}

	double R = (a * b * c) / (4.0 * S);
	double L = max(a, max(b, c)) / 2.0;

	double cx, cy;
	getCenter(i, j, k, cx, cy);

	for (int i = 1; i <= n; ++i) {
		if (dist(x[i], y[i], cx, cy) < R - eps) {
			return 0.0;
		}
	}

	return R;
}

int getArea(int i, int j, int k) {
	int S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	return (S > 0 ? S : -S);
}

int main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		scanf("%d%d", &x[i], &y[i]);
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			d[i][j] = dist(x[i], y[i], x[j], y[j]);
			dd[i][j] = (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
		}
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			for (int k = 1; k <= n; ++k) {
				a[i][j][k] = getArea(i, j, k);
			}
		}
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = i + 1; j <= n; ++j) {
			for (int k = j + 1; k <= n; ++k) {
				int S = a[i][j][k];
				bool nice = true;

				for (int l = 1; l <= n; ++l) {
					if (l == i || l == j || l == k) {
						continue;
					}
					if (a[i][j][l] + a[i][k][l] + a[j][k][l] == S) {
						nice = false;
						break;
					}
				}

				if (nice) {
					res = max(res, solve(i, j, k));
				}
			}
		}
	}

	if (res < eps) {
		printf("-1\n");
		return 0;
	}

	printf("%.10lf\n", res);

	return 0;
}


#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <queue>
#include <cstring>
#include <string>
#include <cmath>
#include <ctime>
#pragma comment (linker, "/STACK:256000000")

using namespace std;

struct pt {
	int x, y;
};

bool cmp (pt a, pt b) {
	return a.x < b.x || a.x == b.x && a.y < b.y;
}

bool cw (pt a, pt b, pt c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) < 0;
}

bool ccw (pt a, pt b, pt c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) > 0;
}

void convex_hull (vector<pt> & a) {
	if (a.size() == 1)  return;
	sort (a.begin(), a.end(), &cmp);
	pt p1 = a[0],  p2 = a.back();
	vector<pt> up, down;
	up.push_back (p1);
	down.push_back (p1);
	for (size_t i=1; i<a.size(); ++i) {
		if (i==a.size()-1 || cw (p1, a[i], p2)) {
			while (up.size()>=2 && !cw (up[up.size()-2], up[up.size()-1], a[i]))
				up.pop_back();
			up.push_back (a[i]);
		}
		if (i==a.size()-1 || ccw (p1, a[i], p2)) {
			while (down.size()>=2 && !ccw (down[down.size()-2], down[down.size()-1], a[i]))
				down.pop_back();
			down.push_back (a[i]);
		}
	}
	a.clear();
	for (size_t i=0; i<up.size(); ++i)
		a.push_back (up[i]);
	for (size_t i=down.size()-2; i>0; --i)
		a.push_back (down[i]);
}

const int maxN = 110;
int n;
int x[maxN], y[maxN];
double d[maxN][maxN];
int dd[maxN][maxN];
int a[maxN][maxN][maxN];

double dist(double x1, double y1, double x2, double y2) {
	double dx = x1 - x2;
	double dy = y1 - y2;
	return sqrt(dx * dx + dy * dy);
}

double res = 0.0;
const double eps = 1e-9;

int getScalar(int i, int j, int k) {
	return (x[i] - x[j]) * (x[i] - x[k]) + (y[i] - y[j]) * (y[i] - y[k]);
}

void getCenter(int i, int j, int k, double& u, double& v) {
	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (double)(::a[i][j][k]) / 2.0;
	S = 8.0 * S * S;

	double A = (a * a) / S * getScalar(i, j, k);
	double B = (b * b) / S * getScalar(j, i, k);
	double C = (c * c) / S * getScalar(k, i, j);

	u = (double)(x[i]) * A + (double)(x[j]) * B + (double)(x[k]) * C;
	v = (double)(y[i]) * A + (double)(y[j]) * B + (double)(y[k]) * C;
}

vector < pt > w;
double wS;

double solve(int i, int j, int k) {
	/*int p = dd[i][j];
	int q = dd[i][k];
	int r = dd[j][k];
	if (p > q) {
		swap(p, q);
	}
	if (p > r) {
		swap(p, r);
	}
	if (q > r) {
		swap(q, r);
	}
	if (p + q - r < 0) {
		return 0.0;
	}*/

	double cx, cy;
	getCenter(i, j, k, cx, cy);

	double area = 0.0;
	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		double x1 = (double)(w[i].x) - cx;
		double y1 = (double)(w[i].y) - cy;
		double x2 = (double)(w[j].x) - cx;
		double y2 = (double)(w[j].y) - cy;
		area += fabs(x1 * y2 - x2 * y1);
	}

	if (fabs(area - wS) > eps) {
		return 0.0;
	}

	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		double d = dist(w[i].x, w[i].y, w[j].x, w[j].y);
		double a = dist(w[i].x, w[i].y, cx, cy);
		double b = dist(w[j].x, w[j].y, cx, cy);
		if (fabs(d - a - b) < eps) {
			return 0.0;
		}
	}

	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	S = fabs(S) / 2.0;

	if (fabs(S) < eps) {
		return 0.0;
	}

	double R = (a * b * c) / (4.0 * S);
	double L = max(a, max(b, c)) / 2.0;

	for (int t = 1; t <= n; ++t) {
		double current = dist(x[t], y[t], cx, cy);
		if (current < R - eps) {
			return 0.0;
			//R = min(R, current);
		}
	}

	return R;
}

int getArea(int i, int j, int k) {
	int S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	return (S > 0 ? S : -S);
}

int main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		scanf("%d%d", &x[i], &y[i]);
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			d[i][j] = dist(x[i], y[i], x[j], y[j]);
			dd[i][j] = (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
		}
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			for (int k = 1; k <= n; ++k) {
				a[i][j][k] = getArea(i, j, k);
			}
		}
	}

	for (int i = 1; i <= n; ++i) {
		pt p;
		p.x = x[i];
		p.y = y[i];
		w.push_back(p);
	}
	convex_hull(w);
	wS = 0.0;
	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		wS += w[i].x * w[j].y - w[i].y * w[j].x;
	}
	wS = fabs(wS);

	for (int i = 1; i <= n; ++i) {
		for (int j = i + 1; j <= n; ++j) {
			for (int k = j + 1; k <= n; ++k) {
				res = max(res, solve(i, j, k));
				//int S = a[i][j][k];
				//bool nice = true;

				/*for (int l = 1; l <= n; ++l) {
					if (l == i || l == j || l == k) {
						continue;
					}
					if (a[i][j][l] + a[i][k][l] + a[j][k][l] == S) {
						nice = false;
						break;
					}
				}*/

				//if (nice) {
				//	res = max(res, solve(i, j, k));
				//}
			}
		}
	}

	if (res < eps) {
		printf("-1\n");
		return 0;
	}

	printf("%.10lf\n", res);

	return 0;
}


#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <queue>
#include <cstring>
#include <string>
#include <cmath>
#include <ctime>
#pragma comment (linker, "/STACK:256000000")

using namespace std;

const int maxN = 110;
int n;
int x[maxN], y[maxN];
double d[maxN][maxN];
int dd[maxN][maxN];
int a[maxN][maxN][maxN];

double dist(double x1, double y1, double x2, double y2) {
	double dx = x1 - x2;
	double dy = y1 - y2;
	return sqrt(dx * dx + dy * dy);
}

double res = 0.0;
const double eps = 1e-6;

int getScalar(int i, int j, int k) {
	return (x[i] - x[j]) * (x[i] - x[k]) + (y[i] - y[j]) * (y[i] - y[k]);
}

void getCenter(int i, int j, int k, double& u, double& v) {
	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (double)(::a[i][j][k]) / 2.0;
	S = 8.0 * S * S;

	double A = (a * a) / S * getScalar(i, j, k);
	double B = (b * b) / S * getScalar(j, i, k);
	double C = (c * c) / S * getScalar(k, i, j);

	u = (double)(x[i]) * A + (double)(x[j]) * B + (double)(x[k]) * C;
	v = (double)(y[i]) * A + (double)(y[j]) * B + (double)(y[k]) * C;
}

double solve(int i, int j, int k) {
	int p = dd[i][j];
	int q = dd[i][k];
	int r = dd[j][k];
	if (p > q) {
		swap(p, q);
	}
	if (p > r) {
		swap(p, r);
	}
	if (q > r) {
		swap(q, r);
	}
	if (p + q - r < 0) {
		return 0.0;
	}

	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	S = fabs(S) / 2.0;

	if (fabs(S) < eps) {
		return 0.0;
	}

	double R = (a * b * c) / (4.0 * S);
	double L = max(a, max(b, c)) / 2.0;

	double cx, cy;
	getCenter(i, j, k, cx, cy);

	for (int t = 1; t <= n; ++t) {
		double f = dist(x[t], y[t], cx, cy);
		R = min(R, f);
	}

	return R;
}

int getArea(int i, int j, int k) {
	int S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	return (S > 0 ? S : -S);
}

int main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		scanf("%d%d", &x[i], &y[i]);
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			d[i][j] = dist(x[i], y[i], x[j], y[j]);
			dd[i][j] = (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
		}
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			for (int k = 1; k <= n; ++k) {
				a[i][j][k] = getArea(i, j, k);
			}
		}
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = i + 1; j <= n; ++j) {
			for (int k = j + 1; k <= n; ++k) {
				res = max(res, solve(i, j, k));
				//int S = a[i][j][k];
				//bool nice = true;

				/*for (int l = 1; l <= n; ++l) {
					if (l == i || l == j || l == k) {
						continue;
					}
					if (a[i][j][l] + a[i][k][l] + a[j][k][l] == S) {
						nice = false;
						break;
					}
				}*/

				//if (nice) {
				//	res = max(res, solve(i, j, k));
				//}
			}
		}
	}

	if (res < eps) {
		printf("-1\n");
		return 0;
	}

	printf("%.10lf\n", res);

	return 0;
}


#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <queue>
#include <cstring>
#include <string>
#include <cmath>
#include <ctime>
#pragma comment (linker, "/STACK:256000000")

using namespace std;

struct pt {
	int x, y;
};

bool cmp (pt a, pt b) {
	return a.x < b.x || a.x == b.x && a.y < b.y;
}

bool cw (pt a, pt b, pt c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) < 0;
}

bool ccw (pt a, pt b, pt c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) > 0;
}

void convex_hull (vector<pt> & a) {
	if (a.size() == 1)  return;
	sort (a.begin(), a.end(), &cmp);
	pt p1 = a[0],  p2 = a.back();
	vector<pt> up, down;
	up.push_back (p1);
	down.push_back (p1);
	for (size_t i=1; i<a.size(); ++i) {
		if (i==a.size()-1 || cw (p1, a[i], p2)) {
			while (up.size()>=2 && !cw (up[up.size()-2], up[up.size()-1], a[i]))
				up.pop_back();
			up.push_back (a[i]);
		}
		if (i==a.size()-1 || ccw (p1, a[i], p2)) {
			while (down.size()>=2 && !ccw (down[down.size()-2], down[down.size()-1], a[i]))
				down.pop_back();
			down.push_back (a[i]);
		}
	}
	a.clear();
	for (size_t i=0; i<up.size(); ++i)
		a.push_back (up[i]);
	for (size_t i=down.size()-2; i>0; --i)
		a.push_back (down[i]);
}

const int maxN = 110;
int n;
int x[maxN], y[maxN];
double d[maxN][maxN];
int dd[maxN][maxN];
int a[maxN][maxN][maxN];

double dist(double x1, double y1, double x2, double y2) {
	double dx = x1 - x2;
	double dy = y1 - y2;
	return sqrt(dx * dx + dy * dy);
}

double res = 0.0;
const double eps = 1e-7;

int getScalar(int i, int j, int k) {
	return (x[i] - x[j]) * (x[i] - x[k]) + (y[i] - y[j]) * (y[i] - y[k]);
}

void getCenter(int i, int j, int k, double& u, double& v) {
	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (double)(::a[i][j][k]) / 2.0;
	S = 8.0 * S * S;

	double A = (a * a) / S * getScalar(i, j, k);
	double B = (b * b) / S * getScalar(j, i, k);
	double C = (c * c) / S * getScalar(k, i, j);

	u = (double)(x[i]) * A + (double)(x[j]) * B + (double)(x[k]) * C;
	v = (double)(y[i]) * A + (double)(y[j]) * B + (double)(y[k]) * C;
}

vector < pt > w;
double wS;

double solve(int i, int j, int k) {
	/*int p = dd[i][j];
	int q = dd[i][k];
	int r = dd[j][k];
	if (p > q) {
		swap(p, q);
	}
	if (p > r) {
		swap(p, r);
	}
	if (q > r) {
		swap(q, r);
	}
	if (p + q - r < 0) {
		return 0.0;
	}*/

	double cx, cy;
	getCenter(i, j, k, cx, cy);

	double area = 0.0;
	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		double x1 = (double)(w[i].x) - cx;
		double y1 = (double)(w[i].y) - cy;
		double x2 = (double)(w[j].x) - cx;
		double y2 = (double)(w[j].y) - cy;
		area += fabs(x1 * y2 - x2 * y1);
	}

	if (fabs(area - wS) > eps) {
		return 0.0;
	}

	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		double d = dist(w[i].x, w[i].y, w[j].x, w[j].y);
		double a = dist(w[i].x, w[i].y, cx, cy);
		double b = dist(w[j].x, w[j].y, cx, cy);
		if (fabs(d - a - b) < eps) {
			return 0.0;
		}
	}

	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	S = fabs(S) / 2.0;

	if (fabs(S) < eps) {
		return 0.0;
	}

	double R = (a * b * c) / (4.0 * S);
	double L = max(a, max(b, c)) / 2.0;

	for (int t = 1; t <= n; ++t) {
		double current = dist(x[t], y[t], cx, cy);
		R = min(R, current);
	}

	return R;
}

int getArea(int i, int j, int k) {
	int S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	return (S > 0 ? S : -S);
}

int main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		scanf("%d%d", &x[i], &y[i]);
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			d[i][j] = dist(x[i], y[i], x[j], y[j]);
			dd[i][j] = (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
		}
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			for (int k = 1; k <= n; ++k) {
				a[i][j][k] = getArea(i, j, k);
			}
		}
	}

	for (int i = 1; i <= n; ++i) {
		pt p;
		p.x = x[i];
		p.y = y[i];
		w.push_back(p);
	}
	convex_hull(w);
	wS = 0.0;
	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		wS += w[i].x * w[j].y - w[i].y * w[j].x;
	}
	wS = fabs(wS);

	for (int i = 1; i <= n; ++i) {
		for (int j = i + 1; j <= n; ++j) {
			for (int k = j + 1; k <= n; ++k) {
				res = max(res, solve(i, j, k));
				//int S = a[i][j][k];
				//bool nice = true;

				/*for (int l = 1; l <= n; ++l) {
					if (l == i || l == j || l == k) {
						continue;
					}
					if (a[i][j][l] + a[i][k][l] + a[j][k][l] == S) {
						nice = false;
						break;
					}
				}*/

				//if (nice) {
				//	res = max(res, solve(i, j, k));
				//}
			}
		}
	}

	if (res < eps) {
		printf("-1\n");
		return 0;
	}

	printf("%.10lf\n", res);

	return 0;
}


#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <queue>
#include <cstring>
#include <string>
#include <cmath>
#include <ctime>
#pragma comment (linker, "/STACK:256000000")

using namespace std;

struct pt {
	int x, y;
};

bool cmp (pt a, pt b) {
	return a.x < b.x || a.x == b.x && a.y < b.y;
}

bool cw (pt a, pt b, pt c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) < 0;
}

bool ccw (pt a, pt b, pt c) {
	return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y) > 0;
}

void convex_hull (vector<pt> & a) {
	if (a.size() == 1)  return;
	sort (a.begin(), a.end(), &cmp);
	pt p1 = a[0],  p2 = a.back();
	vector<pt> up, down;
	up.push_back (p1);
	down.push_back (p1);
	for (size_t i=1; i<a.size(); ++i) {
		if (i==a.size()-1 || cw (p1, a[i], p2)) {
			while (up.size()>=2 && !cw (up[up.size()-2], up[up.size()-1], a[i]))
				up.pop_back();
			up.push_back (a[i]);
		}
		if (i==a.size()-1 || ccw (p1, a[i], p2)) {
			while (down.size()>=2 && !ccw (down[down.size()-2], down[down.size()-1], a[i]))
				down.pop_back();
			down.push_back (a[i]);
		}
	}
	a.clear();
	for (size_t i=0; i<up.size(); ++i)
		a.push_back (up[i]);
	for (size_t i=down.size()-2; i>0; --i)
		a.push_back (down[i]);
}

const int maxN = 110;
int n;
int x[maxN], y[maxN];
double d[maxN][maxN];
int dd[maxN][maxN];
int a[maxN][maxN][maxN];

double dist(double x1, double y1, double x2, double y2) {
	double dx = x1 - x2;
	double dy = y1 - y2;
	return sqrt(dx * dx + dy * dy);
}

double res = 0.0;
const double eps = 1e-7;

int getScalar(int i, int j, int k) {
	return (x[i] - x[j]) * (x[i] - x[k]) + (y[i] - y[j]) * (y[i] - y[k]);
}

void getCenter(int i, int j, int k, double& u, double& v) {
	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (double)(::a[i][j][k]) / 2.0;
	S = 8.0 * S * S;

	double A = (a * a) / S * getScalar(i, j, k);
	double B = (b * b) / S * getScalar(j, i, k);
	double C = (c * c) / S * getScalar(k, i, j);

	u = (double)(x[i]) * A + (double)(x[j]) * B + (double)(x[k]) * C;
	v = (double)(y[i]) * A + (double)(y[j]) * B + (double)(y[k]) * C;
}

vector < pt > w;
double wS;

double solve(int i, int j, int k) {
	/*int p = dd[i][j];
	int q = dd[i][k];
	int r = dd[j][k];
	if (p > q) {
		swap(p, q);
	}
	if (p > r) {
		swap(p, r);
	}
	if (q > r) {
		swap(q, r);
	}
	if (p + q - r < 0) {
		return 0.0;
	}*/

	double cx, cy;
	getCenter(i, j, k, cx, cy);

	double area = 0.0;
	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		double x1 = (double)(w[i].x) - cx;
		double y1 = (double)(w[i].y) - cy;
		double x2 = (double)(w[j].x) - cx;
		double y2 = (double)(w[j].y) - cy;
		area += fabs(x1 * y2 - x2 * y1);
	}

	if (fabs(area - wS) > eps) {
		return 0.0;
	}

	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		double d = dist(w[i].x, w[i].y, w[j].x, w[j].y);
		double a = dist(w[i].x, w[i].y, cx, cy);
		double b = dist(w[j].x, w[j].y, cx, cy);
		if (fabs(d - a - b) < eps) {
			return 0.0;
		}
	}

	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	S = fabs(S) / 2.0;

	if (fabs(S) < eps) {
		return 0.0;
	}

	double R = (a * b * c) / (4.0 * S);
	double L = max(a, max(b, c)) / 2.0;

	for (int t = 1; t <= n; ++t) {
		double current = dist(x[t], y[t], cx, cy);
		if (current < R - eps) {
			return 0.0;
			//R = min(R, current);
		}
	}

	return R;
}

int getArea(int i, int j, int k) {
	int S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	return (S > 0 ? S : -S);
}

int main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		scanf("%d%d", &x[i], &y[i]);
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			d[i][j] = dist(x[i], y[i], x[j], y[j]);
			dd[i][j] = (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
		}
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			for (int k = 1; k <= n; ++k) {
				a[i][j][k] = getArea(i, j, k);
			}
		}
	}

	for (int i = 1; i <= n; ++i) {
		pt p;
		p.x = x[i];
		p.y = y[i];
		w.push_back(p);
	}
	convex_hull(w);
	wS = 0.0;
	for (int i = 0; i < w.size(); ++i) {
		int j = (i + 1) % w.size();
		wS += w[i].x * w[j].y - w[i].y * w[j].x;
	}
	wS = fabs(wS);

	for (int i = 1; i <= n; ++i) {
		for (int j = i + 1; j <= n; ++j) {
			for (int k = j + 1; k <= n; ++k) {
				res = max(res, solve(i, j, k));
				//int S = a[i][j][k];
				//bool nice = true;

				/*for (int l = 1; l <= n; ++l) {
					if (l == i || l == j || l == k) {
						continue;
					}
					if (a[i][j][l] + a[i][k][l] + a[j][k][l] == S) {
						nice = false;
						break;
					}
				}*/

				//if (nice) {
				//	res = max(res, solve(i, j, k));
				//}
			}
		}
	}

	if (res < eps) {
		printf("-1\n");
		return 0;
	}

	printf("%.10lf\n", res);

	return 0;
}


#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <queue>
#include <cstring>
#include <string>
#include <cmath>
#include <ctime>
#pragma comment (linker, "/STACK:256000000")

using namespace std;

const int maxN = 110;
int n;
int x[maxN], y[maxN];
double d[maxN][maxN];
int dd[maxN][maxN];
int a[maxN][maxN][maxN];

double dist(double x1, double y1, double x2, double y2) {
	double dx = x1 - x2;
	double dy = y1 - y2;
	return sqrt(dx * dx + dy * dy);
}

double res = 0.0;
const double eps = 1e-6;

int getScalar(int i, int j, int k) {
	return (x[i] - x[j]) * (x[i] - x[k]) + (y[i] - y[j]) * (y[i] - y[k]);
}

void getCenter(int i, int j, int k, double& u, double& v) {
	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (double)(::a[i][j][k]) / 2.0;
	S = 8.0 * S * S;

	double A = (a * a) / S * getScalar(i, j, k);
	double B = (b * b) / S * getScalar(j, i, k);
	double C = (c * c) / S * getScalar(k, i, j);

	u = (double)(x[i]) * A + (double)(x[j]) * B + (double)(x[k]) * C;
	v = (double)(y[i]) * A + (double)(y[j]) * B + (double)(y[k]) * C;
}

double solve(int i, int j, int k) {
	int p = dd[i][j];
	int q = dd[i][k];
	int r = dd[j][k];
	if (p > q) {
		swap(p, q);
	}
	if (p > r) {
		swap(p, r);
	}
	if (q > r) {
		swap(q, r);
	}
	if (p + q - r < 0) {
		return 0.0;
	}

	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	S = fabs(S) / 2.0;

	if (fabs(S) < eps) {
		return 0.0;
	}

	double R = (a * b * c) / (4.0 * S);
	double L = max(a, max(b, c)) / 2.0;

	double cx, cy;
	getCenter(i, j, k, cx, cy);

	for (int t = 1; t <= n; ++t) {
		if (dist(x[t], y[t], cx, cy) < R - eps) {
			return 0.0;
		}
	}

	return R;
}

int getArea(int i, int j, int k) {
	int S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	return (S > 0 ? S : -S);
}

int main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		scanf("%d%d", &x[i], &y[i]);
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			d[i][j] = dist(x[i], y[i], x[j], y[j]);
			dd[i][j] = (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
		}
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			for (int k = 1; k <= n; ++k) {
				a[i][j][k] = getArea(i, j, k);
			}
		}
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = i + 1; j <= n; ++j) {
			for (int k = j + 1; k <= n; ++k) {
				res = max(res, solve(i, j, k));
				//int S = a[i][j][k];
				//bool nice = true;

				/*for (int l = 1; l <= n; ++l) {
					if (l == i || l == j || l == k) {
						continue;
					}
					if (a[i][j][l] + a[i][k][l] + a[j][k][l] == S) {
						nice = false;
						break;
					}
				}*/

				//if (nice) {
				//	res = max(res, solve(i, j, k));
				//}
			}
		}
	}

	if (res < eps) {
		printf("-1\n");
		return 0;
	}

	printf("%.10lf\n", res);

	return 0;
}


#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <queue>
#include <cstring>
#include <string>
#include <cmath>
#include <ctime>
#pragma comment (linker, "/STACK:256000000")

using namespace std;

const int maxN = 110;
int n;
int x[maxN], y[maxN];
double d[maxN][maxN];
int dd[maxN][maxN];
int a[maxN][maxN][maxN];

double dist(double x1, double y1, double x2, double y2) {
	double dx = x1 - x2;
	double dy = y1 - y2;
	return sqrt(dx * dx + dy * dy);
}

double res = 0.0;
const double eps = 1e-9;

double solve(int i, int j, int k) {
	int p = dd[i][j];
	int q = dd[i][k];
	int r = dd[j][k];
	if (p > q) {
		swap(p, q);
	}
	if (p > r) {
		swap(p, r);
	}
	if (q > r) {
		swap(q, r);
	}
	if (p + q - r < 0) {
		return 0.0;
	}

	double a = d[j][k];
	double b = d[i][k];
	double c = d[i][j];

	double S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	S = fabs(S) / 2.0;

	if (fabs(S) < eps) {
		return 0.0;
	}

	double R = (a * b * c) / (4.0 * S);

	double L = max(a, max(b, c)) / 2.0;

	if (R <= L - eps) {
		return 0.0;
	}
	return R;
}

int getArea(int i, int j, int k) {
	int S = (x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i]);
	return (S > 0 ? S : -S);
}

int main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		scanf("%d%d", &x[i], &y[i]);
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			d[i][j] = dist(x[i], y[i], x[j], y[j]);
			dd[i][j] = (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
		}
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= n; ++j) {
			for (int k = 1; k <= n; ++k) {
				a[i][j][k] = getArea(i, j, k);
			}
		}
	}

	for (int i = 1; i <= n; ++i) {
		for (int j = i + 1; j <= n; ++j) {
			for (int k = j + 1; k <= n; ++k) {
				int S = a[i][j][k];
				bool nice = true;

				for (int l = 1; l <= n; ++l) {
					if (l == i || l == j || l == k) {
						continue;
					}
					if (a[i][j][l] + a[i][k][l] + a[j][k][l] == S) {
						nice = false;
						break;
					}
				}

				if (nice) {
					res = max(res, solve(i, j, k));
				}
			}
		}
	}

	if (res < eps) {
		printf("-1\n");
		return 0;
	}

	printf("%.10lf\n", res);

	return 0;
}