Submission #841233

#	Submission time	Handle	Problem	Language	Result	Execution time	Memory
841233	2023-09-01T11:52:22 Z	maroonrk	Radio Towers (IOI22_towers)	C++17	100 / 100	1348 ms	151632 KB

towers

#include "towers.h"
#ifndef LOCAL
#pragma GCC optimize ("Ofast")
#pragma GCC optimize ("unroll-loops")
#endif

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

using ll=long long;
//#define int ll

#define rng(i,a,b) for(int i=int(a);i<int(b);i++)
#define rep(i,b) rng(i,0,b)
#define gnr(i,a,b) for(int i=int(b)-1;i>=int(a);i--)
#define per(i,b) gnr(i,0,b)
#define pb push_back
#define eb emplace_back
#define a first
#define b second
#define bg begin()
#define ed end()
#define all(x) x.bg,x.ed
#define si(x) int(x.size())
#ifdef LOCAL
#define dmp(x) cerr<<__LINE__<<" "<<#x<<" "<<x<<endl
#else
#define dmp(x) void(0)
#endif

template<class t,class u> bool chmax(t&a,u b){if(a<b){a=b;return true;}else return false;}
template<class t,class u> bool chmin(t&a,u b){if(b<a){a=b;return true;}else return false;}

template<class t> using vc=vector<t>;
template<class t> using vvc=vc<vc<t>>;

using pi=pair<int,int>;
using vi=vc<int>;

template<class t,class u>
ostream& operator<<(ostream& os,const pair<t,u>& p){
	return os<<"{"<<p.a<<","<<p.b<<"}";
}

template<class t> ostream& operator<<(ostream& os,const vc<t>& v){
	os<<"{";
	for(auto e:v)os<<e<<",";
	return os<<"}";
}

#define mp make_pair
#define mt make_tuple
#define one(x) memset(x,-1,sizeof(x))
#define zero(x) memset(x,0,sizeof(x))
#ifdef LOCAL
void dmpr(ostream&os){os<<endl;}
template<class T,class... Args>
void dmpr(ostream&os,const T&t,const Args&... args){
	os<<t<<" ";
	dmpr(os,args...);
}
#define dmp2(...) dmpr(cerr,__LINE__,##__VA_ARGS__)
#else
#define dmp2(...) void(0)
#endif

using uint=unsigned;
using ull=unsigned long long;

template<class t,size_t n>
ostream& operator<<(ostream&os,const array<t,n>&a){
	return os<<vc<t>(all(a));
}

template<int i,class T>
void print_tuple(ostream&,const T&){
}

template<int i,class T,class H,class ...Args>
void print_tuple(ostream&os,const T&t){
	if(i)os<<",";
	os<<get<i>(t);
	print_tuple<i+1,T,Args...>(os,t);
}

template<class ...Args>
ostream& operator<<(ostream&os,const tuple<Args...>&t){
	os<<"{";
	print_tuple<0,tuple<Args...>,Args...>(os,t);
	return os<<"}";
}

ll read(){
	ll i;
	cin>>i;
	return i;
}

vi readvi(int n,int off=0){
	vi v(n);
	rep(i,n)v[i]=read()+off;
	return v;
}

pi readpi(int off=0){
	int a,b;cin>>a>>b;
	return pi(a+off,b+off);
}

template<class t>
void print_single(t x,int suc=1){
	cout<<x;
	if(suc==1)
		cout<<"\n";
	if(suc==2)
		cout<<" ";
}

template<class t,class u>
void print_single(const pair<t,u>&p,int suc=1){
	print_single(p.a,2);
	print_single(p.b,suc);
}

template<class T>
void print_single(const vector<T>&v,int suc=1){
	rep(i,v.size())
		print_single(v[i],i==int(v.size())-1?suc:2);
}

template<class T>
void print_offset(const vector<T>&v,ll off,int suc=1){
	rep(i,v.size())
		print_single(v[i]+off,i==int(v.size())-1?suc:2);
}

template<class T,size_t N>
void print_single(const array<T,N>&v,int suc=1){
	rep(i,N)
		print_single(v[i],i==int(N)-1?suc:2);
}

template<class T>
void print(const T&t){
	print_single(t);
}

template<class T,class ...Args>
void print(const T&t,const Args&...args){
	print_single(t,2);
	print(args...);
}

string readString(){
	string s;
	cin>>s;
	return s;
}

template<class T>
T sq(const T& t){
	return t*t;
}

void YES(bool ex=true){
	cout<<"YES\n";
	if(ex)exit(0);
	#ifdef LOCAL
	cout.flush();
	#endif
}
void NO(bool ex=true){
	cout<<"NO\n";
	if(ex)exit(0);
	#ifdef LOCAL
	cout.flush();
	#endif
}
void Yes(bool ex=true){
	cout<<"Yes\n";
	if(ex)exit(0);
	#ifdef LOCAL
	cout.flush();
	#endif
}
void No(bool ex=true){
	cout<<"No\n";
	if(ex)exit(0);
	#ifdef LOCAL
	cout.flush();
	#endif
}
//#define CAPITAL
/*
void yes(bool ex=true){
	#ifdef CAPITAL
	cout<<"YES"<<"\n";
	#else
	cout<<"Yes"<<"\n";
	#endif
	if(ex)exit(0);
	#ifdef LOCAL
	cout.flush();
	#endif
}
void no(bool ex=true){
	#ifdef CAPITAL
	cout<<"NO"<<"\n";
	#else
	cout<<"No"<<"\n";
	#endif
	if(ex)exit(0);
	#ifdef LOCAL
	cout.flush();
	#endif
}*/
void possible(bool ex=true){
	#ifdef CAPITAL
	cout<<"POSSIBLE"<<"\n";
	#else
	cout<<"Possible"<<"\n";
	#endif
	if(ex)exit(0);
	#ifdef LOCAL
	cout.flush();
	#endif
}
void impossible(bool ex=true){
	#ifdef CAPITAL
	cout<<"IMPOSSIBLE"<<"\n";
	#else
	cout<<"Impossible"<<"\n";
	#endif
	if(ex)exit(0);
	#ifdef LOCAL
	cout.flush();
	#endif
}

constexpr ll ten(int n){
	return n==0?1:ten(n-1)*10;
}

const ll infLL=LLONG_MAX/3;

#ifdef int
const int inf=infLL;
#else
const int inf=INT_MAX/2-100;
#endif

int topbit(signed t){
	return t==0?-1:31-__builtin_clz(t);
}
int topbit(ll t){
	return t==0?-1:63-__builtin_clzll(t);
}
int topbit(ull t){
	return t==0?-1:63-__builtin_clzll(t);
}
int botbit(signed a){
	return a==0?32:__builtin_ctz(a);
}
int botbit(ll a){
	return a==0?64:__builtin_ctzll(a);
}
int botbit(ull a){
	return a==0?64:__builtin_ctzll(a);
}
int popcount(signed t){
	return __builtin_popcount(t);
}
int popcount(ll t){
	return __builtin_popcountll(t);
}
int popcount(ull t){
	return __builtin_popcountll(t);
}
int bitparity(ll t){
	return __builtin_parityll(t);
}
bool ispow2(int i){
	return i&&(i&-i)==i;
}
ll mask(int i){
	return (ll(1)<<i)-1;
}
ull umask(int i){
	return (ull(1)<<i)-1;
}
ll minp2(ll n){
	if(n<=1)return 1;
	else return ll(1)<<(topbit(n-1)+1);
}

bool inc(int a,int b,int c){
	return a<=b&&b<=c;
}

template<class t> void mkuni(vc<t>&v){
	sort(all(v));
	v.erase(unique(all(v)),v.ed);
}

ll rand_int(ll l, ll r) { //[l, r]
	//#ifdef LOCAL
	static mt19937_64 gen;
	/*#else
	static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
	#endif*/
	return uniform_int_distribution<ll>(l, r)(gen);
}

ll rand_int(ll k){ //[0,k)
	return rand_int(0,k-1);
}

template<class t>
void myshuffle(vc<t>&a){
	rep(i,si(a))swap(a[i],a[rand_int(0,i)]);
}

template<class t>
int lwb(const vc<t>&v,const t&a){
	return lower_bound(all(v),a)-v.bg;
}
template<class t>
bool bis(const vc<t>&v,const t&a){
	return binary_search(all(v),a);
}

vvc<int> readGraph(int n,int m){
	vvc<int> g(n);
	rep(i,m){
		int a,b;
		cin>>a>>b;
		//sc.read(a,b);
		a--;b--;
		g[a].pb(b);
		g[b].pb(a);
	}
	return g;
}

vvc<int> readTree(int n){
	return readGraph(n,n-1);
}

template<class t>
vc<t> presum(const vc<t>&a){
	vc<t> s(si(a)+1);
	rep(i,si(a))s[i+1]=s[i]+a[i];
	return s;
}
vc<ll> presum(const vi&a){
	vc<ll> s(si(a)+1);
	rep(i,si(a))s[i+1]=s[i]+a[i];
	return s;
}
//BIT で数列を管理するときに使う (CF850C)
template<class t>
vc<t> predif(vc<t> a){
	gnr(i,1,si(a))a[i]-=a[i-1];
	return a;
}
template<class t>
vvc<ll> imos(const vvc<t>&a){
	int n=si(a),m=si(a[0]);
	vvc<ll> b(n+1,vc<ll>(m+1));
	rep(i,n)rep(j,m)
		b[i+1][j+1]=b[i+1][j]+b[i][j+1]-b[i][j]+a[i][j];
	return b;
}

//verify してないや
void transvvc(int&n,int&m){
	swap(n,m);
}
template<class t,class... Args>
void transvvc(int&n,int&m,vvc<t>&a,Args&...args){
	assert(si(a)==n);
	vvc<t> b(m,vi(n));
	rep(i,n){
		assert(si(a[i])==m);
		rep(j,m)b[j][i]=a[i][j];
	}
	a.swap(b);
	transvvc(n,m,args...);
}
//CF854E
void rotvvc(int&n,int&m){
	swap(n,m);
}
template<class t,class... Args>
void rotvvc(int&n,int&m,vvc<t>&a,Args&...args){
	assert(si(a)==n);
	vvc<t> b(m,vi(n));
	rep(i,n){
		assert(si(a[i])==m);
		rep(j,m)b[m-1-j][i]=a[i][j];
	}
	a.swap(b);
	rotvvc(n,m,args...);
}

//ソートして i 番目が idx[i]
//CF850C
template<class t>
vi sortidx(const vc<t>&a){
	int n=si(a);
	vi idx(n);iota(all(idx),0);
	sort(all(idx),[&](int i,int j){return a[i]<a[j];});
	return idx;
}
//vs[i]=a[idx[i]]
//例えば sortidx で得た idx を使えば単にソート列になって返ってくる
//CF850C
template<class t>
vc<t> a_idx(const vc<t>&a,const vi&idx){
	int n=si(a);
	assert(si(idx)==n);
	vc<t> vs(n);
	rep(i,n)vs[i]=a[idx[i]];
	return vs;
}
//CF850C
vi invperm(const vi&p){
	int n=si(p);
	vi q(n);
	rep(i,n)q[p[i]]=i;
	return q;
}

template<class t,class s=t>
s SUM(const vc<t>&a){
	return accumulate(all(a),s(0));
}

template<class t>
t MAX(const vc<t>&a){
	return *max_element(all(a));
}

template<class t>
pair<t,int> MAXi(const vc<t>&a){
	auto itr=max_element(all(a));
	return mp(*itr,itr-a.bg);
}

template<class t>
t MIN(const vc<t>&a){
	return *min_element(all(a));
}

template<class t>
pair<t,int> MINi(const vc<t>&a){
	auto itr=min_element(all(a));
	return mp(*itr,itr-a.bg);
}

template<class t,class u>
pair<t,u> operator+(const pair<t,u>&a,const pair<t,u>&b){
	return mp(a.a+b.a,a.b+b.b);
}

vi vid(int n){
	vi res(n);iota(all(res),0);
	return res;
}

template<class S>
S revv(S s){
	reverse(all(s));
	return s;
}

pi operator+(pi a,pi b){return pi(a.a+b.a,a.b+b.b);}

template<class t>
t gpp(vc<t>&vs){
	assert(si(vs));
	t res=move(vs.back());
	vs.pop_back();
	return res;
}

template<class t>
void pb(vc<t>&a,const vc<t>&b){
	a.insert(a.ed,all(b));
}

template<class t>
vc<t> cat(vc<t> a,const vc<t>&b){
	pb(a,b);
	return a;
}

template<class t,class u>
vc<t>& operator+=(vc<t>&a,u x){
	for(auto&v:a)v+=x;
	return a;
}

template<class t,class u>
vc<t> operator+(vc<t> a,u x){
	return a+=x;
}

template<class t,class u>
vc<t>& operator-=(vc<t>&a,u x){
	for(auto&v:a)v-=x;
	return a;
}

template<class t,class u>
vc<t>& operator-(vc<t> a,u x){
	return a-=x;
}

//N() が単位元
//VERIFY: yosupo
//CF407E
template<class N>
struct segtree{
	vc<N> x;
	int n,s;
	segtree(){}
	template<class t>
	segtree(const vc<t>&a){
		n=a.size();
		s=1;
		while(s<n){s*=2;}
		x.resize(s*2);
		rep(i,n)
			x[s+i]=N(a[i]);
		gnr(i,1,s)
			x[i]=N::merge(x[i*2],x[i*2+1]);
	}
	//NOT Verified
	segtree(int nn){
		resize(nn);
	}
	void resize(int nn){
		n=nn;
		s=1;
		while(s<n){s*=2;}
		x.assign(s*2,N());
		gnr(i,1,s)
			x[i]=N::merge(x[i*2],x[i*2+1]);
	}
	template<class t>
	void load(const vc<t>&a){
		n=a.size();
		s=1;
		while(s<n){s*=2;}
		x.resize(s*2);
		rep(i,n)
			x[s+i]=N(a[i]);
		rng(i,n,s)
			x[s+i]=N();
		gnr(i,1,s)
			x[i]=N::merge(x[i*2],x[i*2+1]);
	}
	void clear(){
		rep(i,n)
			x[s+i]=N();
		gnr(i,1,s)
			x[i]=N::merge(x[i*2],x[i*2+1]);
	}
	N point_get(int i){
		assert(inc(0,i,n-1));
		return x[i+s];
	}
	void point_set(int i,const N&t){
		assert(inc(0,i,n-1));
		i+=s;
		x[i]=t;
		while(i>>=1)x[i]=N::merge(x[i*2],x[i*2+1]);
	}
	void point_merge(int i,const N&t){
		assert(inc(0,i,n-1));
		i+=s;
		x[i]=N::merge(x[i],t);
		while(i>>=1)x[i]=N::merge(x[i*2],x[i*2+1]);
	}
	template<class F,class...Args>
	void point_change(int i,F f,Args&&...args){
		assert(inc(0,i,n-1));
		i+=s;
		(x[i].*f)(forward<Args>(args)...);
		while(i>>=1)x[i]=N::merge(x[i*2],x[i*2+1]);
	}
	N composite(int b,int e){
		assert(0<=b&&b<=e&&e<=n);
		N lf,rt;
		for(int l=b+s,r=e+s;l<r;l>>=1,r>>=1){
			if (l&1){
				lf=N::merge(lf,x[l]);
				l++;
			}
			if (r&1){
				r--;
				rt=N::merge(x[r],rt);
			}
		}
		return N::merge(lf,rt);
	}
	N getall(){
		return x[1];
	}
	//UTPC2020E
	//n 超えるかもしれない
	template <class F,class... Args> 
	pair<int,N> max_right(int l,F f,Args&&... args){
		assert((N().*f)(forward<Args>(args)...));
		assert(0<=l&&l<=n);
		if(l==n)return mp(n,N());
		l+=s;
		
		N sm;
		assert((sm.*f)(forward<Args>(args)...));
		do {
			while (l % 2 == 0) l >>= 1;
			if (!(N::merge(sm,x[l]).*f)(forward<Args>(args)...)){
				while (l < s) {
					l = (2 * l);
					N tmp=N::merge(sm,x[l]);
					if ((tmp.*f)(forward<Args>(args)...)) {
						sm = tmp;
						l++;
					}
				}
				return mp(l - s,sm);
			}
			sm = N::merge(sm, x[l]);
			l++;
		} while ((l & -l) != l);
		return mp(n,sm);
	}
	//UTPC2020E
	template <class F,class... Args> 
	pair<int,N> min_left(int r,F f,Args&&... args){
		assert((N().*f)(forward<Args>(args)...));
		assert(0<=r&&r<=n);
        if(r==0)return mp(0,N());
        r+=s;
        N sm;
        do {
            r--;
            while (r > 1 && (r % 2)) r >>= 1;
            if (!(N::merge(x[r],sm).*f)(forward<Args>(args)...)) {
                while (r < s) {
                    r = (2 * r + 1);
                    N tmp=N::merge(x[r],sm);
                    if ((tmp.*f)(forward<Args>(args)...)) {
                        sm = tmp;
                        r--;
                    }
                }
                return mp(r + 1 - s,sm);
            }
            sm = N::merge(x[r], sm);
        } while ((r & -r) != r);
        return mp(0,sm);
    }
    //行列とか乗せて必要なのはベクトルとの積，みたいなときに使える？
    //CF Goodbye 2016 E
	template<class F,class T>
	T accumulate(int l, int r,F f,T t) {
		assert(0<=l&&l<=r&&r<=s);
		if (l == r) return t;

		l+=s;
		r+=s;

		static int buf[2][30];
		int cnt[2]{};
		{
			int l2 = l, r2 = r;
			while (l < r) {
				if (l & 1){
					//(x[l++].*f)(forward<Args>(args)...);
					buf[0][cnt[0]++]=l++;
				}
				if (r & 1){
					//(x[--r].*f)(forward<Args>(args)...);
					buf[1][cnt[1]++]=--r;
				}
				l >>= 1;
				r >>= 1;
			}
			l = l2;
			r = r2;
		}
		rep(i,cnt[0])t=(x[buf[0][i]].*f)(t);
		per(i,cnt[1])t=(x[buf[1][i]].*f)(t);

		return t;
	}
};

//最も基本的な動的 segtree
//ByteCamp 2022 Day4 I
template<class N>
struct psegtree{
	struct N2{
		N v;
		int l,r;
	};
	vc<N2> x;
	int L,s;
	template<class t>
	psegtree(const vc<t>&a,int foresight=0):x(foresight){
		x.clear();
		int n=a.size();
		L=0;
		while((1<<L)<n)L++;
		s=1<<L;
		x.resize(s*2,{N(),0,0});
		rep(i,n)x[s+i].v=N(a[i]);
		gnr(i,1,s){
			x[i].v=N::merge(x[i*2].v,x[i*2+1].v);
			x[i].l=i*2;
			x[i].r=i*2+1;
		}
	}
	psegtree(int foresight=0):x(foresight){}
	int init(int n){
		x.clear();
		L=0;
		while((1<<L)<n)L++;
		s=1<<L;
		int a=nl(N());
		rep(i,L)a=nn(a,a);
		return a;
	}
	int nl(const N&val){
		x.pb({val,-1,-1});
		return si(x)-1;
	}
	int nn(int l,int r){
		x.pb({N::merge(x[l].v,x[r].v),l,r});
		return si(x)-1;
	}
	int point_set(int root,int i,const N&val){
		static int buf[40];
		rep(lv,L){
			buf[lv]=root;
			if((i>>(L-1-lv))&1)root=x[root].r;
			else root=x[root].l;
		}
		int res=nl(val);
		per(lv,L){
			int j=buf[lv];
			if((i>>(L-1-lv))&1){
				res=nn(x[j].l,res);
			}else{
				res=nn(res,x[j].r);
			}
		}
		return res;
	}
	int point_merge(int root,int i,const N&val){
		static int buf[40];
		rep(lv,L){
			buf[lv]=root;
			if((i>>(L-1-lv))&1)root=x[root].r;
			else root=x[root].l;
		}
		int res=nl(N::merge(x[root].v,val));
		per(lv,L){
			int j=buf[lv];
			if((i>>(L-1-lv))&1){
				res=nn(x[j].l,res);
			}else{
				res=nn(res,x[j].r);
			}
		}
		return res;
	}
	N compositedfs(int root,int l,int r,int b,int e){
		if(e<=l||r<=b)return N();
		if(b<=l&&r<=e)return x[root].v;
		int mid=(l+r)/2;
		return N::merge(compositedfs(x[root].l,l,mid,b,e),compositedfs(x[root].r,mid,r,b,e));
	}
	N composite(int root,int b,int e){
		assert(b<=e);
		if(b==e)return N();
		return compositedfs(root,0,s,b,e);
	}
};

struct MaxNode{
	int v;
	MaxNode(int vv=-inf):v(vv){}
	static MaxNode merge(const MaxNode&a,const MaxNode&b){
		return MaxNode(max(a.v,b.v));
	}
	bool ok(int x){return v<x;}
};

struct MinNode{
	pi v;
	MinNode(pi vv=pi(inf,-1)):v(vv){}
	static MinNode merge(const MinNode&a,const MinNode&b){
		return MinNode(min(a.v,b.v));
	}
};

struct SumNode{
	int v;
	SumNode(int vv=0):v(vv){}
	static SumNode merge(const SumNode&a,const SumNode&b){
		return SumNode(a.v+b.v);
	}
};

segtree<MinNode> minseg;
psegtree<SumNode> z(ten(5)*31*2+12345);
vi ls[2];

void init(int n,vi h){
	vc<pi> hi(n);
	rep(i,n)hi[i]=pi(h[i],i);
	minseg.load(hi);
	
	int root=z.init(ten(9));
	rep(phase,2){
		dmp(phase);
		segtree<MaxNode> mx(h);
		ls[phase].resize(n);
		int cur=root;
		auto add=[&](int i,int v){
			if(i<0)return;
			dmp2(i,v);
			cur=z.point_merge(cur,i,v);
		};
		vi pos;
		rep(i,n){
			dmp(i);
			while(si(pos)&&h[pos.back()]>h[i]){
				int j=gpp(pos);
				dmp2(i,j);
				int v=mx.composite(j+1,i).v;
				if(si(pos)){
					int k=pos.back();
					int w=mx.composite(k+1,j).v;
					add(w-h[j],-1);
					chmin(v,w);
				}
				add(v-h[j],1);
			}
			if(si(pos)){
				int k=pos.back();
				int w=mx.composite(k+1,i).v;
				add(w-h[i],1);
			}
			pos.pb(i);
			ls[phase][i]=cur;
		}
		reverse(all(h));
	}
	reverse(all(ls[1]));
}

int max_towers(int l,int r,int d){
	int m=minseg.composite(l,r+1).v.b;
	dmp2(l,m,r);
	int ans=0;
	ans+=z.composite(ls[0][r],d,z.s).v;
	ans-=z.composite(ls[0][m],d,z.s).v;
	dmp(ans);
	ans+=z.composite(ls[1][l],d,z.s).v;
	ans-=z.composite(ls[1][m],d,z.s).v;
	dmp(ans);
	ans++;
	dmp(ans);
	return ans;
}

Subtask #1

4.0 / 4.0

#	Verdict	Execution time	Memory	Grader output
1	Correct	459 ms	76368 KB	Output is correct
2	Correct	941 ms	78952 KB	Output is correct
3	Correct	937 ms	78892 KB	Output is correct
4	Correct	805 ms	78916 KB	Output is correct
5	Correct	833 ms	79560 KB	Output is correct
6	Correct	879 ms	78904 KB	Output is correct
7	Correct	772 ms	79560 KB	Output is correct
8	Correct	30 ms	73168 KB	Output is correct
9	Correct	33 ms	73424 KB	Output is correct
10	Correct	30 ms	73312 KB	Output is correct

Subtask #2

11.0 / 11.0

#	Verdict	Execution time	Memory	Grader output
1	Correct	32 ms	73168 KB	Output is correct
2	Correct	32 ms	73296 KB	Output is correct
3	Correct	36 ms	73364 KB	Output is correct
4	Correct	33 ms	73296 KB	Output is correct
5	Correct	33 ms	73208 KB	Output is correct
6	Correct	34 ms	73296 KB	Output is correct
7	Correct	33 ms	73272 KB	Output is correct
8	Correct	34 ms	73428 KB	Output is correct
9	Correct	31 ms	73276 KB	Output is correct
10	Correct	33 ms	73292 KB	Output is correct
11	Correct	33 ms	73296 KB	Output is correct
12	Correct	30 ms	73316 KB	Output is correct
13	Correct	36 ms	73328 KB	Output is correct
14	Correct	32 ms	73268 KB	Output is correct
15	Correct	33 ms	73224 KB	Output is correct
16	Correct	32 ms	73272 KB	Output is correct
17	Correct	33 ms	73212 KB	Output is correct
18	Correct	30 ms	73296 KB	Output is correct
19	Correct	31 ms	73232 KB	Output is correct
20	Correct	33 ms	73296 KB	Output is correct
21	Correct	32 ms	73288 KB	Output is correct
22	Correct	33 ms	73296 KB	Output is correct
23	Correct	32 ms	73288 KB	Output is correct
24	Correct	32 ms	73276 KB	Output is correct
25	Correct	33 ms	73296 KB	Output is correct
26	Correct	33 ms	73296 KB	Output is correct
27	Correct	33 ms	73416 KB	Output is correct
28	Correct	37 ms	73288 KB	Output is correct
29	Correct	34 ms	73256 KB	Output is correct
30	Correct	36 ms	73360 KB	Output is correct
31	Correct	33 ms	73248 KB	Output is correct
32	Correct	32 ms	73296 KB	Output is correct
33	Correct	32 ms	73288 KB	Output is correct
34	Correct	32 ms	73272 KB	Output is correct
35	Correct	32 ms	73288 KB	Output is correct

Subtask #3

12.0 / 12.0

#	Verdict	Execution time	Memory	Grader output
1	Correct	32 ms	73168 KB	Output is correct
2	Correct	32 ms	73296 KB	Output is correct
3	Correct	36 ms	73364 KB	Output is correct
4	Correct	33 ms	73296 KB	Output is correct
5	Correct	33 ms	73208 KB	Output is correct
6	Correct	34 ms	73296 KB	Output is correct
7	Correct	33 ms	73272 KB	Output is correct
8	Correct	34 ms	73428 KB	Output is correct
9	Correct	31 ms	73276 KB	Output is correct
10	Correct	33 ms	73292 KB	Output is correct
11	Correct	33 ms	73296 KB	Output is correct
12	Correct	30 ms	73316 KB	Output is correct
13	Correct	36 ms	73328 KB	Output is correct
14	Correct	32 ms	73268 KB	Output is correct
15	Correct	33 ms	73224 KB	Output is correct
16	Correct	32 ms	73272 KB	Output is correct
17	Correct	33 ms	73212 KB	Output is correct
18	Correct	30 ms	73296 KB	Output is correct
19	Correct	31 ms	73232 KB	Output is correct
20	Correct	33 ms	73296 KB	Output is correct
21	Correct	32 ms	73288 KB	Output is correct
22	Correct	33 ms	73296 KB	Output is correct
23	Correct	32 ms	73288 KB	Output is correct
24	Correct	32 ms	73276 KB	Output is correct
25	Correct	33 ms	73296 KB	Output is correct
26	Correct	33 ms	73296 KB	Output is correct
27	Correct	33 ms	73416 KB	Output is correct
28	Correct	37 ms	73288 KB	Output is correct
29	Correct	34 ms	73256 KB	Output is correct
30	Correct	36 ms	73360 KB	Output is correct
31	Correct	33 ms	73248 KB	Output is correct
32	Correct	32 ms	73296 KB	Output is correct
33	Correct	32 ms	73288 KB	Output is correct
34	Correct	32 ms	73272 KB	Output is correct
35	Correct	32 ms	73288 KB	Output is correct
36	Correct	109 ms	76192 KB	Output is correct
37	Correct	189 ms	151508 KB	Output is correct
38	Correct	191 ms	151504 KB	Output is correct
39	Correct	209 ms	151624 KB	Output is correct
40	Correct	205 ms	151512 KB	Output is correct
41	Correct	213 ms	151632 KB	Output is correct
42	Correct	204 ms	151508 KB	Output is correct
43	Correct	50 ms	78916 KB	Output is correct
44	Correct	43 ms	79620 KB	Output is correct
45	Correct	84 ms	78668 KB	Output is correct
46	Correct	75 ms	79172 KB	Output is correct
47	Correct	180 ms	151516 KB	Output is correct
48	Correct	203 ms	151604 KB	Output is correct
49	Correct	202 ms	151504 KB	Output is correct
50	Correct	43 ms	79572 KB	Output is correct
51	Correct	45 ms	78864 KB	Output is correct
52	Correct	186 ms	151628 KB	Output is correct
53	Correct	206 ms	151632 KB	Output is correct
54	Correct	205 ms	151620 KB	Output is correct
55	Correct	43 ms	79556 KB	Output is correct
56	Correct	92 ms	78672 KB	Output is correct
57	Correct	214 ms	151440 KB	Output is correct
58	Correct	189 ms	151544 KB	Output is correct
59	Correct	182 ms	151508 KB	Output is correct
60	Correct	199 ms	151624 KB	Output is correct
61	Correct	201 ms	151624 KB	Output is correct
62	Correct	231 ms	151608 KB	Output is correct
63	Correct	199 ms	151616 KB	Output is correct
64	Correct	44 ms	78912 KB	Output is correct
65	Correct	43 ms	79524 KB	Output is correct
66	Correct	100 ms	78628 KB	Output is correct
67	Correct	47 ms	79516 KB	Output is correct

Subtask #4

14.0 / 14.0

#	Verdict	Execution time	Memory	Grader output
1	Correct	862 ms	151496 KB	Output is correct
2	Correct	1049 ms	151520 KB	Output is correct
3	Correct	1027 ms	151620 KB	Output is correct
4	Correct	1027 ms	151516 KB	Output is correct
5	Correct	943 ms	151504 KB	Output is correct
6	Correct	804 ms	151632 KB	Output is correct
7	Correct	1014 ms	151516 KB	Output is correct
8	Correct	623 ms	78912 KB	Output is correct
9	Correct	692 ms	79500 KB	Output is correct
10	Correct	758 ms	78872 KB	Output is correct
11	Correct	810 ms	79436 KB	Output is correct
12	Correct	745 ms	78876 KB	Output is correct
13	Correct	714 ms	79504 KB	Output is correct
14	Correct	32 ms	73160 KB	Output is correct
15	Correct	33 ms	73296 KB	Output is correct
16	Correct	31 ms	73288 KB	Output is correct
17	Correct	196 ms	151516 KB	Output is correct
18	Correct	206 ms	151620 KB	Output is correct
19	Correct	209 ms	151504 KB	Output is correct
20	Correct	44 ms	79584 KB	Output is correct
21	Correct	45 ms	78848 KB	Output is correct
22	Correct	194 ms	151620 KB	Output is correct
23	Correct	213 ms	151492 KB	Output is correct
24	Correct	213 ms	151504 KB	Output is correct
25	Correct	44 ms	79536 KB	Output is correct
26	Correct	95 ms	78800 KB	Output is correct
27	Correct	33 ms	73288 KB	Output is correct
28	Correct	33 ms	73296 KB	Output is correct
29	Correct	32 ms	73408 KB	Output is correct
30	Correct	31 ms	73244 KB	Output is correct
31	Correct	31 ms	73288 KB	Output is correct
32	Correct	33 ms	73296 KB	Output is correct
33	Correct	34 ms	73220 KB	Output is correct
34	Correct	34 ms	73284 KB	Output is correct
35	Correct	31 ms	73296 KB	Output is correct
36	Correct	32 ms	73288 KB	Output is correct

Subtask #5

17.0 / 17.0

#	Verdict	Execution time	Memory	Grader output
1	Correct	330 ms	74564 KB	Output is correct
2	Correct	973 ms	151588 KB	Output is correct
3	Correct	1206 ms	151568 KB	Output is correct
4	Correct	1046 ms	151620 KB	Output is correct
5	Correct	973 ms	151516 KB	Output is correct
6	Correct	1207 ms	151504 KB	Output is correct
7	Correct	1212 ms	151600 KB	Output is correct
8	Correct	832 ms	78916 KB	Output is correct
9	Correct	761 ms	79556 KB	Output is correct
10	Correct	758 ms	78868 KB	Output is correct
11	Correct	840 ms	79436 KB	Output is correct
12	Correct	187 ms	151624 KB	Output is correct
13	Correct	201 ms	151556 KB	Output is correct
14	Correct	204 ms	151620 KB	Output is correct
15	Correct	48 ms	79472 KB	Output is correct
16	Correct	90 ms	78672 KB	Output is correct
17	Correct	181 ms	151428 KB	Output is correct
18	Correct	188 ms	151508 KB	Output is correct
19	Correct	186 ms	151504 KB	Output is correct
20	Correct	205 ms	151580 KB	Output is correct
21	Correct	205 ms	151580 KB	Output is correct
22	Correct	207 ms	151504 KB	Output is correct
23	Correct	208 ms	151628 KB	Output is correct
24	Correct	43 ms	78912 KB	Output is correct
25	Correct	49 ms	79540 KB	Output is correct
26	Correct	100 ms	78668 KB	Output is correct
27	Correct	47 ms	79556 KB	Output is correct
28	Correct	33 ms	73288 KB	Output is correct
29	Correct	34 ms	73296 KB	Output is correct
30	Correct	31 ms	73340 KB	Output is correct
31	Correct	31 ms	73416 KB	Output is correct
32	Correct	31 ms	73288 KB	Output is correct
33	Correct	32 ms	73296 KB	Output is correct
34	Correct	32 ms	73296 KB	Output is correct
35	Correct	32 ms	73256 KB	Output is correct
36	Correct	34 ms	73296 KB	Output is correct
37	Correct	34 ms	73232 KB	Output is correct
38	Correct	34 ms	73348 KB	Output is correct
39	Correct	33 ms	73216 KB	Output is correct
40	Correct	31 ms	73340 KB	Output is correct
41	Correct	38 ms	73288 KB	Output is correct
42	Correct	31 ms	73288 KB	Output is correct
43	Correct	32 ms	73424 KB	Output is correct

Subtask #6

19.0 / 19.0

#	Verdict	Execution time	Memory	Grader output
1	Correct	32 ms	73168 KB	Output is correct
2	Correct	32 ms	73296 KB	Output is correct
3	Correct	36 ms	73364 KB	Output is correct
4	Correct	33 ms	73296 KB	Output is correct
5	Correct	33 ms	73208 KB	Output is correct
6	Correct	34 ms	73296 KB	Output is correct
7	Correct	33 ms	73272 KB	Output is correct
8	Correct	34 ms	73428 KB	Output is correct
9	Correct	31 ms	73276 KB	Output is correct
10	Correct	33 ms	73292 KB	Output is correct
11	Correct	33 ms	73296 KB	Output is correct
12	Correct	30 ms	73316 KB	Output is correct
13	Correct	36 ms	73328 KB	Output is correct
14	Correct	32 ms	73268 KB	Output is correct
15	Correct	33 ms	73224 KB	Output is correct
16	Correct	32 ms	73272 KB	Output is correct
17	Correct	33 ms	73212 KB	Output is correct
18	Correct	30 ms	73296 KB	Output is correct
19	Correct	31 ms	73232 KB	Output is correct
20	Correct	33 ms	73296 KB	Output is correct
21	Correct	32 ms	73288 KB	Output is correct
22	Correct	33 ms	73296 KB	Output is correct
23	Correct	32 ms	73288 KB	Output is correct
24	Correct	32 ms	73276 KB	Output is correct
25	Correct	33 ms	73296 KB	Output is correct
26	Correct	33 ms	73296 KB	Output is correct
27	Correct	33 ms	73416 KB	Output is correct
28	Correct	37 ms	73288 KB	Output is correct
29	Correct	34 ms	73256 KB	Output is correct
30	Correct	36 ms	73360 KB	Output is correct
31	Correct	33 ms	73248 KB	Output is correct
32	Correct	32 ms	73296 KB	Output is correct
33	Correct	32 ms	73288 KB	Output is correct
34	Correct	32 ms	73272 KB	Output is correct
35	Correct	32 ms	73288 KB	Output is correct
36	Correct	109 ms	76192 KB	Output is correct
37	Correct	189 ms	151508 KB	Output is correct
38	Correct	191 ms	151504 KB	Output is correct
39	Correct	209 ms	151624 KB	Output is correct
40	Correct	205 ms	151512 KB	Output is correct
41	Correct	213 ms	151632 KB	Output is correct
42	Correct	204 ms	151508 KB	Output is correct
43	Correct	50 ms	78916 KB	Output is correct
44	Correct	43 ms	79620 KB	Output is correct
45	Correct	84 ms	78668 KB	Output is correct
46	Correct	75 ms	79172 KB	Output is correct
47	Correct	180 ms	151516 KB	Output is correct
48	Correct	203 ms	151604 KB	Output is correct
49	Correct	202 ms	151504 KB	Output is correct
50	Correct	43 ms	79572 KB	Output is correct
51	Correct	45 ms	78864 KB	Output is correct
52	Correct	186 ms	151628 KB	Output is correct
53	Correct	206 ms	151632 KB	Output is correct
54	Correct	205 ms	151620 KB	Output is correct
55	Correct	43 ms	79556 KB	Output is correct
56	Correct	92 ms	78672 KB	Output is correct
57	Correct	214 ms	151440 KB	Output is correct
58	Correct	189 ms	151544 KB	Output is correct
59	Correct	182 ms	151508 KB	Output is correct
60	Correct	199 ms	151624 KB	Output is correct
61	Correct	201 ms	151624 KB	Output is correct
62	Correct	231 ms	151608 KB	Output is correct
63	Correct	199 ms	151616 KB	Output is correct
64	Correct	44 ms	78912 KB	Output is correct
65	Correct	43 ms	79524 KB	Output is correct
66	Correct	100 ms	78628 KB	Output is correct
67	Correct	47 ms	79516 KB	Output is correct
68	Correct	862 ms	151496 KB	Output is correct
69	Correct	1049 ms	151520 KB	Output is correct
70	Correct	1027 ms	151620 KB	Output is correct
71	Correct	1027 ms	151516 KB	Output is correct
72	Correct	943 ms	151504 KB	Output is correct
73	Correct	804 ms	151632 KB	Output is correct
74	Correct	1014 ms	151516 KB	Output is correct
75	Correct	623 ms	78912 KB	Output is correct
76	Correct	692 ms	79500 KB	Output is correct
77	Correct	758 ms	78872 KB	Output is correct
78	Correct	810 ms	79436 KB	Output is correct
79	Correct	745 ms	78876 KB	Output is correct
80	Correct	714 ms	79504 KB	Output is correct
81	Correct	32 ms	73160 KB	Output is correct
82	Correct	33 ms	73296 KB	Output is correct
83	Correct	31 ms	73288 KB	Output is correct
84	Correct	196 ms	151516 KB	Output is correct
85	Correct	206 ms	151620 KB	Output is correct
86	Correct	209 ms	151504 KB	Output is correct
87	Correct	44 ms	79584 KB	Output is correct
88	Correct	45 ms	78848 KB	Output is correct
89	Correct	194 ms	151620 KB	Output is correct
90	Correct	213 ms	151492 KB	Output is correct
91	Correct	213 ms	151504 KB	Output is correct
92	Correct	44 ms	79536 KB	Output is correct
93	Correct	95 ms	78800 KB	Output is correct
94	Correct	33 ms	73288 KB	Output is correct
95	Correct	33 ms	73296 KB	Output is correct
96	Correct	32 ms	73408 KB	Output is correct
97	Correct	31 ms	73244 KB	Output is correct
98	Correct	31 ms	73288 KB	Output is correct
99	Correct	33 ms	73296 KB	Output is correct
100	Correct	34 ms	73220 KB	Output is correct
101	Correct	34 ms	73284 KB	Output is correct
102	Correct	31 ms	73296 KB	Output is correct
103	Correct	32 ms	73288 KB	Output is correct
104	Correct	790 ms	151276 KB	Output is correct
105	Correct	1073 ms	151496 KB	Output is correct
106	Correct	1050 ms	151624 KB	Output is correct
107	Correct	935 ms	151508 KB	Output is correct
108	Correct	1095 ms	151620 KB	Output is correct
109	Correct	1165 ms	151612 KB	Output is correct
110	Correct	1110 ms	151496 KB	Output is correct
111	Correct	762 ms	78820 KB	Output is correct
112	Correct	714 ms	79512 KB	Output is correct
113	Correct	942 ms	78676 KB	Output is correct
114	Correct	894 ms	79428 KB	Output is correct

Subtask #7

23.0 / 23.0

#	Verdict	Execution time	Memory	Grader output
1	Correct	459 ms	76368 KB	Output is correct
2	Correct	941 ms	78952 KB	Output is correct
3	Correct	937 ms	78892 KB	Output is correct
4	Correct	805 ms	78916 KB	Output is correct
5	Correct	833 ms	79560 KB	Output is correct
6	Correct	879 ms	78904 KB	Output is correct
7	Correct	772 ms	79560 KB	Output is correct
8	Correct	30 ms	73168 KB	Output is correct
9	Correct	33 ms	73424 KB	Output is correct
10	Correct	30 ms	73312 KB	Output is correct
11	Correct	32 ms	73168 KB	Output is correct
12	Correct	32 ms	73296 KB	Output is correct
13	Correct	36 ms	73364 KB	Output is correct
14	Correct	33 ms	73296 KB	Output is correct
15	Correct	33 ms	73208 KB	Output is correct
16	Correct	34 ms	73296 KB	Output is correct
17	Correct	33 ms	73272 KB	Output is correct
18	Correct	34 ms	73428 KB	Output is correct
19	Correct	31 ms	73276 KB	Output is correct
20	Correct	33 ms	73292 KB	Output is correct
21	Correct	33 ms	73296 KB	Output is correct
22	Correct	30 ms	73316 KB	Output is correct
23	Correct	36 ms	73328 KB	Output is correct
24	Correct	32 ms	73268 KB	Output is correct
25	Correct	33 ms	73224 KB	Output is correct
26	Correct	32 ms	73272 KB	Output is correct
27	Correct	33 ms	73212 KB	Output is correct
28	Correct	30 ms	73296 KB	Output is correct
29	Correct	31 ms	73232 KB	Output is correct
30	Correct	33 ms	73296 KB	Output is correct
31	Correct	32 ms	73288 KB	Output is correct
32	Correct	33 ms	73296 KB	Output is correct
33	Correct	32 ms	73288 KB	Output is correct
34	Correct	32 ms	73276 KB	Output is correct
35	Correct	33 ms	73296 KB	Output is correct
36	Correct	33 ms	73296 KB	Output is correct
37	Correct	33 ms	73416 KB	Output is correct
38	Correct	37 ms	73288 KB	Output is correct
39	Correct	34 ms	73256 KB	Output is correct
40	Correct	36 ms	73360 KB	Output is correct
41	Correct	33 ms	73248 KB	Output is correct
42	Correct	32 ms	73296 KB	Output is correct
43	Correct	32 ms	73288 KB	Output is correct
44	Correct	32 ms	73272 KB	Output is correct
45	Correct	32 ms	73288 KB	Output is correct
46	Correct	109 ms	76192 KB	Output is correct
47	Correct	189 ms	151508 KB	Output is correct
48	Correct	191 ms	151504 KB	Output is correct
49	Correct	209 ms	151624 KB	Output is correct
50	Correct	205 ms	151512 KB	Output is correct
51	Correct	213 ms	151632 KB	Output is correct
52	Correct	204 ms	151508 KB	Output is correct
53	Correct	50 ms	78916 KB	Output is correct
54	Correct	43 ms	79620 KB	Output is correct
55	Correct	84 ms	78668 KB	Output is correct
56	Correct	75 ms	79172 KB	Output is correct
57	Correct	180 ms	151516 KB	Output is correct
58	Correct	203 ms	151604 KB	Output is correct
59	Correct	202 ms	151504 KB	Output is correct
60	Correct	43 ms	79572 KB	Output is correct
61	Correct	45 ms	78864 KB	Output is correct
62	Correct	186 ms	151628 KB	Output is correct
63	Correct	206 ms	151632 KB	Output is correct
64	Correct	205 ms	151620 KB	Output is correct
65	Correct	43 ms	79556 KB	Output is correct
66	Correct	92 ms	78672 KB	Output is correct
67	Correct	214 ms	151440 KB	Output is correct
68	Correct	189 ms	151544 KB	Output is correct
69	Correct	182 ms	151508 KB	Output is correct
70	Correct	199 ms	151624 KB	Output is correct
71	Correct	201 ms	151624 KB	Output is correct
72	Correct	231 ms	151608 KB	Output is correct
73	Correct	199 ms	151616 KB	Output is correct
74	Correct	44 ms	78912 KB	Output is correct
75	Correct	43 ms	79524 KB	Output is correct
76	Correct	100 ms	78628 KB	Output is correct
77	Correct	47 ms	79516 KB	Output is correct
78	Correct	862 ms	151496 KB	Output is correct
79	Correct	1049 ms	151520 KB	Output is correct
80	Correct	1027 ms	151620 KB	Output is correct
81	Correct	1027 ms	151516 KB	Output is correct
82	Correct	943 ms	151504 KB	Output is correct
83	Correct	804 ms	151632 KB	Output is correct
84	Correct	1014 ms	151516 KB	Output is correct
85	Correct	623 ms	78912 KB	Output is correct
86	Correct	692 ms	79500 KB	Output is correct
87	Correct	758 ms	78872 KB	Output is correct
88	Correct	810 ms	79436 KB	Output is correct
89	Correct	745 ms	78876 KB	Output is correct
90	Correct	714 ms	79504 KB	Output is correct
91	Correct	32 ms	73160 KB	Output is correct
92	Correct	33 ms	73296 KB	Output is correct
93	Correct	31 ms	73288 KB	Output is correct
94	Correct	196 ms	151516 KB	Output is correct
95	Correct	206 ms	151620 KB	Output is correct
96	Correct	209 ms	151504 KB	Output is correct
97	Correct	44 ms	79584 KB	Output is correct
98	Correct	45 ms	78848 KB	Output is correct
99	Correct	194 ms	151620 KB	Output is correct
100	Correct	213 ms	151492 KB	Output is correct
101	Correct	213 ms	151504 KB	Output is correct
102	Correct	44 ms	79536 KB	Output is correct
103	Correct	95 ms	78800 KB	Output is correct
104	Correct	33 ms	73288 KB	Output is correct
105	Correct	33 ms	73296 KB	Output is correct
106	Correct	32 ms	73408 KB	Output is correct
107	Correct	31 ms	73244 KB	Output is correct
108	Correct	31 ms	73288 KB	Output is correct
109	Correct	33 ms	73296 KB	Output is correct
110	Correct	34 ms	73220 KB	Output is correct
111	Correct	34 ms	73284 KB	Output is correct
112	Correct	31 ms	73296 KB	Output is correct
113	Correct	32 ms	73288 KB	Output is correct
114	Correct	330 ms	74564 KB	Output is correct
115	Correct	973 ms	151588 KB	Output is correct
116	Correct	1206 ms	151568 KB	Output is correct
117	Correct	1046 ms	151620 KB	Output is correct
118	Correct	973 ms	151516 KB	Output is correct
119	Correct	1207 ms	151504 KB	Output is correct
120	Correct	1212 ms	151600 KB	Output is correct
121	Correct	832 ms	78916 KB	Output is correct
122	Correct	761 ms	79556 KB	Output is correct
123	Correct	758 ms	78868 KB	Output is correct
124	Correct	840 ms	79436 KB	Output is correct
125	Correct	187 ms	151624 KB	Output is correct
126	Correct	201 ms	151556 KB	Output is correct
127	Correct	204 ms	151620 KB	Output is correct
128	Correct	48 ms	79472 KB	Output is correct
129	Correct	90 ms	78672 KB	Output is correct
130	Correct	181 ms	151428 KB	Output is correct
131	Correct	188 ms	151508 KB	Output is correct
132	Correct	186 ms	151504 KB	Output is correct
133	Correct	205 ms	151580 KB	Output is correct
134	Correct	205 ms	151580 KB	Output is correct
135	Correct	207 ms	151504 KB	Output is correct
136	Correct	208 ms	151628 KB	Output is correct
137	Correct	43 ms	78912 KB	Output is correct
138	Correct	49 ms	79540 KB	Output is correct
139	Correct	100 ms	78668 KB	Output is correct
140	Correct	47 ms	79556 KB	Output is correct
141	Correct	33 ms	73288 KB	Output is correct
142	Correct	34 ms	73296 KB	Output is correct
143	Correct	31 ms	73340 KB	Output is correct
144	Correct	31 ms	73416 KB	Output is correct
145	Correct	31 ms	73288 KB	Output is correct
146	Correct	32 ms	73296 KB	Output is correct
147	Correct	32 ms	73296 KB	Output is correct
148	Correct	32 ms	73256 KB	Output is correct
149	Correct	34 ms	73296 KB	Output is correct
150	Correct	34 ms	73232 KB	Output is correct
151	Correct	34 ms	73348 KB	Output is correct
152	Correct	33 ms	73216 KB	Output is correct
153	Correct	31 ms	73340 KB	Output is correct
154	Correct	38 ms	73288 KB	Output is correct
155	Correct	31 ms	73288 KB	Output is correct
156	Correct	32 ms	73424 KB	Output is correct
157	Correct	790 ms	151276 KB	Output is correct
158	Correct	1073 ms	151496 KB	Output is correct
159	Correct	1050 ms	151624 KB	Output is correct
160	Correct	935 ms	151508 KB	Output is correct
161	Correct	1095 ms	151620 KB	Output is correct
162	Correct	1165 ms	151612 KB	Output is correct
163	Correct	1110 ms	151496 KB	Output is correct
164	Correct	762 ms	78820 KB	Output is correct
165	Correct	714 ms	79512 KB	Output is correct
166	Correct	942 ms	78676 KB	Output is correct
167	Correct	894 ms	79428 KB	Output is correct
168	Correct	31 ms	73216 KB	Output is correct
169	Correct	686 ms	75600 KB	Output is correct
170	Correct	1267 ms	151492 KB	Output is correct
171	Correct	1341 ms	151504 KB	Output is correct
172	Correct	1342 ms	151508 KB	Output is correct
173	Correct	1308 ms	151628 KB	Output is correct
174	Correct	1320 ms	151612 KB	Output is correct
175	Correct	1348 ms	151596 KB	Output is correct
176	Correct	832 ms	78916 KB	Output is correct
177	Correct	855 ms	79556 KB	Output is correct
178	Correct	927 ms	78916 KB	Output is correct
179	Correct	1002 ms	79044 KB	Output is correct