#include <iostream>
#include <vector>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
int n;
vector <int> G[200005];
pair <int,int> p[200005];
void init()
{
    int l,r;
    for(int i=0; i<n; i++)
    {
        scanf("%d %d",&l,&r);
        p[i*2]=make_pair(l*2,i*2);
        p[i*2+1]=make_pair(r*2+1,i*2+1);
        G[i*2].push_back(i*2+1);
        G[i*2+1].push_back(i*2);
    }
    sort(p,p+2*n);
    for (int i = 0; i < n; ++i)
    {
        int x = p[i<<1].second, y = p[i<<1|1].second;
        G[x].push_back(y), G[y].push_back(x);
    }
}
int col[100005];
void dfs(int u,int c)
{
    if(col[u]!=-1) return;
    col[u]=c;
    int m=G[u].size();
    for(int i=0;i<m;i++)
    {
        dfs(G[u][i],c^1);
    }
}
void compute()
{
    memset(col, -1, sizeof(col));
    for(int i=0;i<n;i++)
    {
        dfs(i<<1,0);
        printf("%d ",col[i<<1]);
    }
    cout<<endl;
}
int main()
{
    cin>>n;
    init();
    compute();
    return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <set>
#include <cstring>
#include <vector>
using namespace std;
vector <int> G[100005];
struct Segment
{
    int l,r,i;
} a[100005];
int fa[100005],n;
bool cmp(Segment A,Segment B)
{
    if(A.l!=B.l) return A.l<B.l;
    return A.r>B.r;
}
void scan()
{
    cin>>n;
    for(int i=1; i<=n; i++)
    {
        scanf("%d %d",&a[i].l,&a[i].r);
        a[i].i=i;
    }
}
void get_fa()
{
    set <pair <int ,int> >SET;
    memset(fa,0,sizeof(fa));
    for(int i=1;i<=n;i++)
    {
       // cout<<a[i].l<<" * "<<a[i].r<<" "<<a[i].i<<endl;
        auto p=SET.lower_bound(make_pair(a[i].r,0));
        if(p!=SET.end()) fa[a[i].i]=p->second;
        G[fa[a[i].i]].push_back(a[i].i);
        SET.insert(make_pair(a[i].r,a[i].i));
    }
}
bool ans[100005];
void dfs(int u,bool c)
{
    ans[u]=c;
    int m=G[u].size();
    for(int i=0;i<m;i++)
    {
        c^=1;
        dfs(G[u][i],c);
    }
}
int main()
{
    scan();
    sort(a+1,a+n+1,cmp);
    get_fa();
    //for(int i=1;i<=n;i++) cout<<i<<" "<<fa[i]<<endl;
    dfs(0,1);
    for(int i=1;i<=n-1;i++) printf("%d ",ans[i]);
    printf("%d\n",ans[n]);
    return 0;
}


#include <iostream>
#include <vector>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
int n;
vector <int> G[100005];
pair <int,int> p[200005];
void init()
{
    int l,r;
    for(int i=0; i<n; i++)
    {
        scanf("%d %d",&l,&r);
        p[i*2]=make_pair(l*2,i*2);
        p[i*2+1]=make_pair(r*2+1,i*2+1);
        G[i*2].push_back(i*2+1);
        G[i*2+1].push_back(i*2);
    }
    sort(p,p+2*n);
    for (int i = 0; i < 2*n-1; ++i)
    {
        int x = p[i].second, y = p[i+1].second;
        G[x].push_back(y), G[y].push_back(x);
    }
}
int col[100005];
void dfs(int u,int c)
{
    if(col[u]!=-1) return;
    col[u]=c;
    int m=G[u].size();
    for(int i=0;i<m;i++)
    {
        dfs(G[u][i],c^1);
    }
}
void compute()
{
    memset(col, -1, sizeof(col));
    for(int i=0;i<n;i++)
    {
        dfs(i<<1,0);
        printf("%d ",col[i]);
    }
    cout<<endl;
}
int main()
{
    cin>>n;
    init();
    compute();
    return 0;
}


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <set>
#include <cstring>
#include <vector>
using namespace std;
vector <int> G[100005];
struct Segment
{
    int l,r,i;
} a[100005];
int fa[100005],n;
bool cmp(Segment A,Segment B)
{
    if(A.l!=B.l) return A.l<B.l;
    return A.r>B.r;
}
bool cmp1(Segment A,Segment B)
{
    if(A.r!=B.r) return A.r>B.r;
    return A.l<B.l;
}
void scan()
{
    cin>>n;
    for(int i=1; i<=n; i++)
    {
        scanf("%d %d",&a[i].l,&a[i].r);
        a[i].i=i;
    }
}
void get_fa()
{
    set <pair <int ,int> >SET;
    memset(fa,0,sizeof(fa));
    for(int i=1;i<=n;i++)
    {
        //cout<<a[i].l<<" * "<<a[i].r<<" "<<a[i].i<<endl;
        auto p=SET.lower_bound(make_pair(a[i].r,0));
        if(p!=SET.end()) fa[a[i].i]=p->second;
        //cout<<p->first<<" "<<p->second<<endl;
        G[fa[a[i].i]].push_back(a[i].i);
        SET.insert(make_pair(a[i].r,a[i].i));
    }
}
bool ans[100005];
void dfs(int u,bool c)
{
    ans[u]=c;
    int m=G[u].size();
    for(int i=0;i<m;i++)
    {
        c^=1;
        dfs(G[u][i],c);
    }
}
int main()
{
    scan();
    sort(a+1,a+n+1,cmp);
    get_fa();
    //cout<<"**********************"<<endl;
    //for(int i=1;i<=n;i++) cout<<fa[i]<<" "<<i<<endl;
    dfs(0,1);
    for(int i=1;i<=n-1;i++) printf("%d ",ans[i]);
    printf("%d\n",ans[n]);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define mod 998244353
const int maxi =200001;
bool comp(pair<int,int>a,pair<int,int>b)
{
  return (a.second-a.first)>(b.second-b.first);
}

int main()
{
 ios_base::sync_with_stdio(false);
 cin.tie(NULL);

 ll n,x,y;
 cin>>n>>x>>y;
 vector<ll>v(n);

 ll ans=y/n;
 ll sum=0;
 for(ll i=0;i<n;i++){v[i]=1;sum+=v[i];}

 v[n-1]+=max(y-n,0LL);
 if(sum>y){cout<<"-1"<<endl;return 0;}
 sum=0;
 for(ll i=0;i<n;i++)
 {
  sum+=v[i]*v[i];
 }
 if(sum<x){cout<<"-1"<<endl;return 0;}

 for(ll i=0;i<n;i++)cout<<v[i]<<endl;

}


#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define mod 998244353
const int maxi =200001;
bool comp(pair<int,int>a,pair<int,int>b)
{
  return (a.second-a.first)>(b.second-b.first);
}

int main()
{
 ios_base::sync_with_stdio(false);
 cin.tie(NULL);

 ll n,x,y;
 cin>>n>>x>>y;
 vector<ll>v(n);

 ll ans=y/n;
 for(ll i=0;i<n;i++)v[i]=ans;
 v[n-1]+=y%n;
 ll sum=0;
 for(ll i=0;i<n;i++)
 {
  sum+=v[i]*v[i];
 }
 if(sum<x){cout<<"-1"<<endl;return 0;}

 for(ll i=0;i<n;i++)cout<<v[i]<<endl;

}


#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define mod 998244353
const int maxi =200001;
bool comp(pair<int,int>a,pair<int,int>b)
{
  return (a.second-a.first)>(b.second-b.first);
}

int main()
{
 ios_base::sync_with_stdio(false);
 cin.tie(NULL);

 ll n,x,y;
 cin>>n>>x>>y;
 vector<ll>v(n);

 ll ans=y/n;
 for(ll i=0;i<n;i++)v[i]=1;

 v[n-1]+=max(y-n,0LL);
 ll sum=0;
 for(ll i=0;i<n;i++)
 {
  sum+=v[i]*v[i];
 }
 if(sum<x){cout<<"-1"<<endl;return 0;}

 for(ll i=0;i<n;i++)cout<<v[i]<<endl;

}


//#pragma GCC optimize("Ofast")
//#pragma GGC optimize("no-stack-protectorz")
//#pragma GCC target("avx,avx2")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,popcnt,abm,mmx,tune=native")
//#pragma GCC optimize("unroll-loops")

#define _CRT_SECURE_NO_WARNINGS
#include <climits>
#include <clocale>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <bitset>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <math.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;

signed main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	ios_base::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	srand(time(NULL));

	long long n, x, y;
	cin >> n >> x >> y;
	if (n > x) {
		cout << -1;
		return 0;
	}
	x -= n - 1;
	y -= n - 1;
	long long sq = sqrt(x + 0.01);
	if (sq * sq < x)
		++sq;
	if (!sq || sq > y) {
		cout << -1;
		return 0;
	}
	for (int i = 0; i < n - 1; ++i)
		cout << "1\n";
	cout << sq;

	//system("pause");
}


//#pragma GCC optimize("Ofast")
//#pragma GGC optimize("no-stack-protectorz")
//#pragma GCC target("avx,avx2")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,popcnt,abm,mmx,tune=native")
//#pragma GCC optimize("unroll-loops")

#define _CRT_SECURE_NO_WARNINGS
#include <climits>
#include <clocale>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <bitset>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <math.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;

signed main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	ios_base::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	srand(time(NULL));

	long long n, x, y;
	cin >> n >> x >> y;
	x -= n - 1;
	y -= n - 1;
	long long sq = 0;
	while (sq * sq < x)
		++sq;
	if (sq > y) {
		cout << -1;
		return 0;
	}
	for (int i = 0; i < n - 1; ++i)
		cout << "1\n";
	cout << sq;

	//system("pause");
}


//#pragma GCC optimize("Ofast")
//#pragma GGC optimize("no-stack-protectorz")
//#pragma GCC target("avx,avx2")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,popcnt,abm,mmx,tune=native")
//#pragma GCC optimize("unroll-loops")

#define _CRT_SECURE_NO_WARNINGS
#include <climits>
#include <clocale>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <bitset>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <math.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;

signed main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	ios_base::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	srand(time(NULL));

	long long n, x, y;
	cin >> n >> x >> y;
	if (n > y) {
		cout << -1;
		return 0;
	}
	long long sq = 0;
	while (sq + 1 + n - 1 <= y)
		++sq;
	if (n - 1 + sq * sq < x) {
		cout << -1;
		return 0;
	}
	for (int i = 0; i < n - 1; ++i)
		cout << "1\n";
	cout << sq;

	//system("pause");
}


//#pragma GCC optimize("Ofast")
//#pragma GGC optimize("no-stack-protectorz")
//#pragma GCC target("avx,avx2")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,popcnt,abm,mmx,tune=native")
//#pragma GCC optimize("unroll-loops")

#define _CRT_SECURE_NO_WARNINGS
#include <climits>
#include <clocale>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <bitset>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <math.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;

signed main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	ios_base::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	srand(time(NULL));

	long long n, x, y;
	cin >> n >> x >> y;
	if (n > y) {
		cout << -1;
		return 0;
	}
	x -= n - 1;
	y -= n - 1;
	long long sq = 0;
	while (sq * sq < x)
		++sq;
	if (!sq || sq > y) {
		cout << -1;
		return 0;
	}
	for (int i = 0; i < n - 1; ++i)
		cout << "1\n";
	cout << sq;

	//system("pause");
}


//#pragma GCC optimize("Ofast")
//#pragma GGC optimize("no-stack-protectorz")
//#pragma GCC target("avx,avx2")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,popcnt,abm,mmx,tune=native")
//#pragma GCC optimize("unroll-loops")

#define _CRT_SECURE_NO_WARNINGS
#include <climits>
#include <clocale>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <bitset>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <math.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;

signed main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	ios_base::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	srand(time(NULL));

	long long n, x, y;
	cin >> n >> x >> y;
	if (n > y) {
		cout << -1;
		return 0;
	}
	x -= n - 1;
	y -= n - 1;
	long long sq = sqrt(x + 0.01);
	if (sq * sq < x)
		++sq;
	if (!sq || sq > y) {
		cout << -1;
		return 0;
	}
	for (int i = 0; i < n - 1; ++i)
		cout << "1\n";
	cout << sq;

	//system("pause");
}


//#pragma GCC optimize("Ofast")
//#pragma GGC optimize("no-stack-protectorz")
//#pragma GCC target("avx,avx2")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,popcnt,abm,mmx,tune=native")
//#pragma GCC optimize("unroll-loops")

#define _CRT_SECURE_NO_WARNINGS
#include <climits>
#include <clocale>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <bitset>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <math.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;

signed main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	ios_base::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	srand(time(NULL));

	long long n, x, y;
	cin >> n >> x >> y;
	x -= n - 1;
	y -= n - 1;
	long long sq = sqrt(x + 0.01);
	if (sq * sq < x)
		++sq;
	if (!sq || sq > y) {
		cout << -1;
		return 0;
	}
	for (int i = 0; i < n - 1; ++i)
		cout << "1\n";
	cout << sq;

	//system("pause");
}


//#pragma GCC optimize("Ofast")
//#pragma GGC optimize("no-stack-protectorz")
//#pragma GCC target("avx,avx2")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,popcnt,abm,mmx,tune=native")
//#pragma GCC optimize("unroll-loops")

#define _CRT_SECURE_NO_WARNINGS
#include <climits>
#include <clocale>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <bitset>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <math.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;

signed main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	ios_base::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	srand(time(NULL));

	long long n, x, y;
	cin >> n >> x >> y;
	x -= n - 1;
	y -= n - 1;
	int sq = sqrt(x + 0.01);
	if (sq * sq < x)
		++sq;
	if (sq > y) {
		cout << -1;
		return 0;
	}
	for (int i = 0; i < n - 1; ++i)
		cout << "1\n";
	cout << sq;

	//system("pause");
}


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

#define LL long long

int dx[]={1,-1,0,0};
int dy[]={0,0,1,-1};

int main(){
	LL n;
	cin>>n;
	LL a,b;
	cin>>a>>b;

		int num=max(b,n)-min(b,n);
		num++;
		LL ans=pow(num,2);
		for(int i=0; i<n-1;i++)ans+=1;
	//out<<ans<<endl;
		if(ans<a){
			cout<<-1<<endl;
			return 0;
		}
		cout<<num<<endl;
		for(int i=0; i<n-1;i++)cout<<1<<endl;
	return 0;
}


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

#define LL long long

int dx[]={1,-1,0,0};
int dy[]={0,0,1,-1};

int main(){
	LL n;
	cin>>n;
	LL a,b;
	cin>>a>>b;

		int num=max(b,n)-min(b,n);
		num++;
		LL ans=pow(num,2);
		for(int i=0; i<n-1;i++)ans+=1;
	//out<<ans<<endl;
		if(ans<a || ans-pow(num,2)+num>b){
			cout<<-1<<endl;
			return 0;
		}
		cout<<num<<endl;
		for(int i=0; i<n-1;i++)cout<<1<<endl;
	return 0;
}


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

#define LL long long

int dx[]={1,-1,0,0};
int dy[]={0,0,1,-1};

int main(){
	LL n;
	cin>>n;
	LL a,b;
	cin>>a>>b;

		int num=max(b,n)-min(b,n);
		num++;
		LL ans=pow(num,2);
		for(int i=0; i<n-1;i++)ans+=1;
	//out<<ans<<endl;
		if(ans<a || ans>b){
			cout<<-1<<endl;
			return 0;
		}
		cout<<num<<endl;
		for(int i=0; i<n-1;i++)cout<<1<<endl;
	return 0;
}


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

#define LL long long

int dx[]={1,-1,0,0};
int dy[]={0,0,1,-1};

int main(){
	LL n;
	cin>>n;
	LL a,b;
	cin>>a>>b;

		int num=max(b,n)-min(b,n);
///out<<num+1<<endl;
//out<<num<<endl;
		LL ans=pow(num,2);
		for(int i=0; i<n-1;i++)ans+=1;
	//out<<ans<<endl;
		if(ans<a){
			cout<<-1<<endl;
			return 0;
		}
		cout<<num+1<<endl;
		for(int i=0; i<n-1;i++)cout<<1<<endl;
	return 0;
}


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

#define LL long long

int dx[]={1,-1,0,0};
int dy[]={0,0,1,-1};

int main(){
	int n;
	cin>>n;
	LL a,b;
	cin>>a>>b;
	if(b>a){
		cout<<-1<<endl;
		return 0;
	}
	else{
		int num=b-n;
	//out<<num+1<<endl;
		LL ans=(num+1)*(num+1);
		for(int i=0; i<n-1;i++)ans+=i;
		if(ans<a){
			cout<<-1<<endl;
			return 0;
		}
		cout<<num+1<<endl;
		for(int i=0; i<n-1;i++)cout<<1<<endl;
	}
	return 0;
}


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

int main() {

    long long n,x,y,s=0,sum=0;
    cin>>n>>x>>y;
    long long h = floor(sqrt(y)),arr[n];

    //if (x==1 && y==1 && n>x) {cout<<-1; return 0;}
    s = y - n+1;
    for (int i=1;i<n;i++) sum++;

    if (sum+s <= y && sum+s*s >=x && s>0) {cout<<s<<endl; for (int i=1;i<n;i++) cout<<1<<endl;}
    else cout<<-1;

    return 0;
}


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

int main() {

    long long n,x,y,s=0,sum=0;
    cin>>n>>x>>y;
    long long h = floor(sqrt(y)),arr[n];

    s = y - n;
    for (int i=1;i<n;i++) sum++;

    if (sum+s <= y && sum+s*s >=x) {cout<<s<<endl; for (int i=1;i<n;i++) cout<<1<<endl;}
    else cout<<-1;

    return 0;
}


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

int main() {

    long long n,x,y,s=0,sum=0;
    cin>>n>>x>>y;
    long long h = floor(sqrt(y)),arr[n];

    s = y - n;
    for (int i=1;i<n;i++) sum++;

    if (sum+s <= y && sum+s*s >=x) {cout<<s<<endl; for (int i=1;i<n;i++) cout<<1<<endl;}

    return 0;
}


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

int main() {

    long long n,x,y,s=0,sum=0;
    cin>>n>>x>>y;
    long long h = floor(sqrt(y)),arr[n];

    s = y - n+1;
    for (int i=1;i<n;i++) sum++;

    if (sum+s <= y && sum+s*s >=x) {cout<<s<<endl; for (int i=1;i<n;i++) cout<<1<<endl;}
    else cout<<-1;

    return 0;
}


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

int main() {

    long long n,x,y,s=0,sum=0;
    cin>>n>>x>>y;
    long long h = floor(sqrt(y)),arr[n];

    if (x==1 && y==1 && n>1) {cout<<-1; return 0;}
    s = y - n+1;
    for (int i=1;i<n;i++) sum++;

    if (sum+s <= y && sum+s*s >=x) {cout<<s<<endl; for (int i=1;i<n;i++) cout<<1<<endl;}
    else cout<<-1;

    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long int
#define llu unsigned long long int
#define pb push_back
#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
//K-th smallest
//cout << k << "kth smallest: " << *A.find_by_order(k-1) << endl;
//NO OF ELEMENTS < X
//cout << "No of elements less than " << X << " are " << A.order_of_key(X) << endl;
//#define v vector<ll>
//#define vv vector<ll>
void pv(vector<ll> arr, ll size)
{
    for (ll i = 0; i < size; i++)
    {
        cout << arr[i] << '\n';
    }
}
void gv(vector<ll> &arr)
{
    ll size = arr.size();
    for (ll i = 0; i < size; i++)
    {
        cin >> arr[i];
    }
}
int main(void)
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    ll n, x, y;
    cin >> n >> x >> y;
    vector<ll> arr(n);
    for (ll i = 0; i < n - 1; i++)
    {
        arr[i] = 1;
    }
    arr[n - 1] = y - n + 1;
    ll s = 0;
    for (ll i = 0; i < n; i++)
        s += arr[i] * arr[i];
    if (s >= x)
        pv(arr, n);
    else
        cout << -1;
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long int
#define llu unsigned long long int
#define pb push_back
#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
//K-th smallest
//cout << k << "kth smallest: " << *A.find_by_order(k-1) << endl;
//NO OF ELEMENTS < X
//cout << "No of elements less than " << X << " are " << A.order_of_key(X) << endl;
//#define v vector<ll>
//#define vv vector<ll>
void pv(vector<ll> arr, ll size)
{
    for (ll i = 0; i < size; i++)
    {
        cout << arr[i] << '\n';
    }
}
void gv(vector<ll> &arr)
{
    ll size = arr.size();
    for (ll i = 0; i < size; i++)
    {
        cin >> arr[i];
    }
}
int main(void)
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    ll n, x, y;
    cin >> n >> x >> y;
    vector<ll> arr(n);
    for (ll i = 0; i < n - 1; i++)
    {
        arr[i] = 1;
    }
    arr[n - 1] = y - n + 1;
    ll s = 0;
    for (ll i = 0; i < n; i++)
        s += arr[i] * arr[i];
    if (s >= x || n <= y)
        pv(arr, n);
    else
        cout << -1;
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long int
#define llu unsigned long long int
#define pb push_back
#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
//K-th smallest
//cout << k << "kth smallest: " << *A.find_by_order(k-1) << endl;
//NO OF ELEMENTS < X
//cout << "No of elements less than " << X << " are " << A.order_of_key(X) << endl;
//#define v vector<ll>
//#define vv vector<ll>
void pv(vector<ll> arr, ll size)
{
    for (ll i = 0; i < size; i++)
    {
        cout << arr[i] << '\n';
    }
}
void gv(vector<ll> &arr)
{
    ll size = arr.size();
    for (ll i = 0; i < size; i++)
    {
        cin >> arr[i];
    }
}
int main(void)
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    ll n, x, y;
    cin >> n >> x >> y;
    vector<ll> arr(n);
    for (ll i = 0; i < n - 1; i++)
    {
        arr[i] = 1;
    }
    arr[n - 1] = max((ll)1, y - n + 1);
    ll s = 0;
    for (ll i = 0; i < n; i++)
        s += arr[i] * arr[i];
    if (s >= x)
        pv(arr, n);
    else
        cout << -1;
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long int
#define llu unsigned long long int
#define pb push_back
#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
//K-th smallest
//cout << k << "kth smallest: " << *A.find_by_order(k-1) << endl;
//NO OF ELEMENTS < X
//cout << "No of elements less than " << X << " are " << A.order_of_key(X) << endl;
//#define v vector<ll>
//#define vv vector<ll>
void pv(vector<ll> arr, ll size)
{
    for (ll i = 0; i < size; i++)
    {
        cout << arr[i] << '\n';
    }
}
void gv(vector<ll> &arr)
{
    ll size = arr.size();
    for (ll i = 0; i < size; i++)
    {
        cin >> arr[i];
    }
}
int main(void)
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    ll n, x, y;
    cin >> n >> x >> y;
    vector<ll> arr(n);
    for (ll i = 0; i < n - 1; i++)
    {
        arr[i] = 1;
    }
    arr[n - 1] = y - n + 1;
    ll s = 0;
    for (ll i = 0; i < n; i++)
        s += arr[i] * arr[i];
    if (s >= x || n > y)
        pv(arr, n);
    else
        cout << -1;
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long int
#define llu unsigned long long int
#define pb push_back
#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
//K-th smallest
//cout << k << "kth smallest: " << *A.find_by_order(k-1) << endl;
//NO OF ELEMENTS < X
//cout << "No of elements less than " << X << " are " << A.order_of_key(X) << endl;
//#define v vector<ll>
//#define vv vector<ll>
void pv(vector<ll> arr, ll size)
{
    for (ll i = 0; i < size; i++)
    {
        cout << arr[i] << '\n';
    }
}
void gv(vector<ll> &arr)
{
    ll size = arr.size();
    for (ll i = 0; i < size; i++)
    {
        cin >> arr[i];
    }
}
int main(void)
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    ll n, x, y;
    cin >> n >> x >> y;
    vector<ll> arr(n);
    for (ll i = 0; i < n - 1; i++)
    {
        arr[i] = 1;
    }
    arr[n - 1] = y - n + 1;
    ll s = 0;
    for (ll i = 0; i < n; i++)
        s += arr[i] * arr[i];
    if (s >= x && n <= y)
        pv(arr, n);
    else
        cout << -1;
    return 0;
}


#include <iostream>
typedef long long int ll;
using namespace std;

int main() {
	ll x, y, n;
	cin >> n >> x >> y;

	ll a1 = y - (n-1);
	if(a1 >= (x-(n-1))/a1) {
		cout << a1 << endl;
		for(int i = 1; i < n; i++){
			cout << 1 << endl;
		}
	}
	else cout << -1 << endl;
	return 0;
}


#include <iostream>
typedef long long int ll;
using namespace std;

int main() {
	ll x, y, n;
	cin >> n >> x >> y;

	ll a1 = y - (n-1);
	if(a1 <= 0){
		cout << -1 << endl;
	}
	else if(a1 >= (float)(x-(n-1))/a1) {
		cout << a1 << endl;
		for(int i = 1; i < n; i++){
			cout << 1 << endl;
		}
	}
	else cout << -1 << endl;
	return 0;
}


#include <iostream>
typedef long long int ll;
using namespace std;

int main() {
	ll x, y, n;
	cin >> n >> x >> y;

	ll a1 = y - (n-1);
	if(a1 >= (float)(x-(n-1))/a1) {
		cout << a1 << endl;
		for(int i = 1; i < n; i++){
			cout << 1 << endl;
		}
	}
	else cout << -1 << endl;
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

long long n, x, y, a, s;
int main()
{
	cin >> n >> x >> y;
    a = y - n + 1;
	s = a * a + n - 1;
	if(s >= x && a > 0)
	{
		cout << a - 1 << '\n';
		for(int i = 1; i < n; i++)
		{
			puts("1");
		}
	}
	else
	puts("-1");
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
	long n, x, y, s = 0;
	cin >> n >> x >> y;
	long a = y - n;
	s = a * a + n - 1;
	if(s >= x && a > 0)
	{
		cout << a << endl;
		for(int i = 1; i < n; i++)
		{
			cout << "1\n";
		}
	}
	else
	puts("-1");
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
	unsigned long n, x, y, s = 0;
	cin >> n >> x >> y;
	unsigned long a = y - n;
	s = a * a + n - 1;
	if(s >= x && a > 0)
	{
		cout << a << endl;
		for(int i = 1; i < n; i++)
		{
			cout << "1\n";
		}
	}
	else
	puts("-1");
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

long long n, x, y, a, s;
int main()
{
	cin >> n >> x >> y;
    a = y - n + 1;
	s = a * a + n - 1;
	if(s >= x && a > 0)
	{
		for(int i = 1; i < n; i++)
		{
			puts("1");
		}
		cout << y - n + 1 << '\n';
	}
	else
	puts("-1");
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

long long n, x, y, a, s;
int main()
{
	cin >> n >> x >> y;
    a = y - n + 1;
	s = a * a + n - 1;
	if(s >= x && a > 0)
	{
		cout << y << '\n';
		for(int i = 1; i < n; i++)
		{
			puts("1");
		}
	}
	else
	puts("-1");
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
	long long n, x, y, s = 0;
	cin >> n >> x >> y;
	y = y - n;
	s = y * y + n - 1;
	if(s >= x && y > 0)
	{
		cout << y << endl;
		for(int i = 1; i < n; i++)
		{
			cout << "1\n";
		}
	}
	else
	puts("-1");
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
	long long n, x, y;
	cin >> n >> x >> y;
	y = y - n + 1;
	long long s = y * y - n + 1;
	if(s >= x && y > 0)
	{
		cout << y;
		for(int i = 1; i < n; i++)
		{
			cout << "1\n";
		}
	}
	else
	puts("-1");
	return 0;
}


#include <iostream>
#define ll long long

using namespace std;

int main()
{
	ll n, x, y;
	cin >> n >> x >> y;
	if ((n - 1) + (y - n + 1) * (y - n + 1) < x or y<n)
		cout << -1;
	else {
		for (int i = 1; i < n; i++)
			cout << "1\n";
		cout << y - n + 1;
	}
}


#include <iostream>
#define ll long long

using namespace std;

int main()
{
	ll n, x, y;
	cin >> n >> x >> y;
	if ((n - 1) + (y - n + 1) * (y - n + 1) < x)
		cout << -1;
	else {
		for (int i = 1; i < n; i++)
			cout << "1\n";
		cout << y - n + 1;
	}
}


#include<bits/stdc++.h>

using namespace std;

#define ll long long int
#define db(x) cout<<#x<<" -> "<<x<<endl

vector<ll>vec;

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    ll n,x,y;
    cin>>n>>x>>y;
    vec.push_back(y-n+1);
    for(int i=1; i<=n-1; i++){
        vec.push_back(1);
    }
    ll sum = 0;
    for(int i=0; i<vec.size(); i++){
        sum+=(vec[i]*vec[i]);
    }
    if(sum<x){
        cout<<-1<<endl;
        return 0;
    }
    for(int i=0; i<vec.size(); i++){
        cout<<vec[i]<<endl;
    }
    return 0;

}


#include<bits/stdc++.h>

using namespace std;

#define ll long long int
#define db(x) cout<<#x<<" -> "<<x<<endl

vector<ll>vec;

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    ll n,x,y;
    cin>>n>>x>>y;
    vec.push_back(y-n+1);
    for(int i=1; i<=n-1; i++){
        vec.push_back(1);
    }
    unsigned long long int sum = 0;
    for(int i=0; i<vec.size(); i++){
        sum+=(vec[i]*vec[i]);
    }
    if(sum<x){
        cout<<-1<<endl;
        return 0;
    }
    for(int i=0; i<vec.size(); i++){
        cout<<vec[i]<<endl;
    }
    return 0;

}


#include<bits/stdc++.h>

using namespace std;

#define ll long long int
#define db(x) cout<<#x<<" -> "<<x<<endl

vector<ll>vec;

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    ll n,x,y;
    cin>>n>>x>>y;
    if(y-n+1<=0){
        cout<<-1<<endl;
        return 0;
    }
    vec.push_back(y-n+1);
    for(int i=1; i<=n-1; i++){
        vec.push_back(1);
    }
    unsigned long long int sum = 0;
    for(int i=0; i<vec.size(); i++){
        sum+=(vec[i]*vec[i]);
    }
    if(sum<x){
        cout<<-1<<endl;
        return 0;
    }
    for(int i=0; i<vec.size(); i++){
        cout<<vec[i]<<endl;
    }
    return 0;

}


import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner r = new Scanner(System.in);
        int n = r.nextInt();
        long x = r.nextLong();
        long y = r.nextLong();
        long h = y-n+1;
        if ((h*h)+(n-1)>=x && h+n-1<=y && h>0){
        	System.out.println((y - n + 1));
        	for (int i = 0; i < n - 1; i++){
        		System.out.println(1);
        	}
        }
        else{
        	System.out.println(-1);
        }
    }
}


import java.io.*;
import java.util.*;

public class solution {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        long x=in.nextLong();
        int y=in.nextInt();
        if (n>y) {System.out.println(-1);return ;}
        if (n==1) {
            long k=(long)y;
            if (k*k>=x) System.out.println(k);else System.out.println(-1);
            return ;
        }
        StringBuilder sb=new StringBuilder();
        long b=(long)(n-1);
        int l=y-(n-1);long g=(long)l;
        if (g*g+b>=x) {
            for (int i=0;i<n-1;++i) {sb.append(1);sb.append(" ");}
            sb.append(l);System.out.println(sb.toString());
        }
        else System.out.println(-1);
    }
}


import java.io.*;
import java.util.*;

public class solution {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        long x=in.nextLong();
        int y=in.nextInt();
        if (n==1) {
            long k=(long)y;
            if (k*k>=x) System.out.println(k);else System.out.println(-1);
            return ;
        }
        StringBuilder sb=new StringBuilder();
        long b=(long)(n-1);
        int l=y-(n-1);long g=(long)l;
        if (g*g+b>=x) {
            for (int i=0;i<n-1;++i) {sb.append(1);sb.append(" ");}
            sb.append(l);System.out.println(sb.toString());
        }
        else System.out.println(-1);
    }
}


import java.util.*;
import java.io.*;
public class Main {
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        long n1 = scan.nextInt();
        long x1 = scan.nextLong();
        long y1 = scan.nextLong();
        if (y1 < n1){
            System.out.println(-1);
            return;
        }
        long first = y1 - n1 + 1l;
        long max = first * first + y1 - first;
//      px(max);
        if (max < x1){
            System.out.println(-1);
            return;
        }
        out.println(first);
        for (int i = 1; i< n1; i++){
            out.println(1);
        }
        out.flush();
    }
    static PrintWriter out = new PrintWriter(System.out);
    static void px(Object ...objects){
        System.out.println(Arrays.deepToString(objects));
    }
}


import java.util.*;
import java.io.*;

public class Main implements Runnable {

	public void solve() throws IOException {
		int N = nextInt();
                long x = nextLong();
                long y = nextLong();

                long last = y - (N-1);
                if(last < 1 || last * last + (N-1) < x){
                    System.out.println(-1);
                }
                else{
                    System.out.println(last);
                    for(int i = 1; i < N; i++)
                        System.out.println(1);
                }
	}

	//-----------------------------------------------------------
	public static void main(String[] args) {
		new Main().run();
	}

        public void print1Int(int[] a){
                for(int i = 0; i < a.length; i++)
                        System.out.print(a[i] + " ");
                System.out.println();
        }

        public void print2Int(int[][] a){
                for(int i = 0; i < a.length; i++){
                        for(int j = 0; j < a[0].length; j++){
                                System.out.print(a[i][j] + " ");
                        }
                        System.out.println();
                }
        }

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			tok = null;
			solve();
			in.close();
		} catch (IOException e) {
			System.exit(0);
		}
	}

	public String nextToken() throws IOException {
		while (tok == null || !tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	BufferedReader in;
	StringTokenizer tok;
}


import java.util.*;
import java.io.*;

public class Main implements Runnable {

	public void solve() throws IOException {
		int N = nextInt();
                long x = nextLong();
                long y = nextLong();

                long last = y - (N-1);
                if(last * last + (N-1) < x){
                    System.out.println(-1);
                }
                else{
                    System.out.println(last);
                    for(int i = 1; i < N; i++)
                        System.out.println(1);
                }
	}

	//-----------------------------------------------------------
	public static void main(String[] args) {
		new Main().run();
	}

        public void print1Int(int[] a){
                for(int i = 0; i < a.length; i++)
                        System.out.print(a[i] + " ");
                System.out.println();
        }

        public void print2Int(int[][] a){
                for(int i = 0; i < a.length; i++){
                        for(int j = 0; j < a[0].length; j++){
                                System.out.print(a[i][j] + " ");
                        }
                        System.out.println();
                }
        }

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			tok = null;
			solve();
			in.close();
		} catch (IOException e) {
			System.exit(0);
		}
	}

	public String nextToken() throws IOException {
		while (tok == null || !tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	BufferedReader in;
	StringTokenizer tok;
}


import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Task111A {

    public static void main(String... args) throws NumberFormatException,
            IOException {
        Solution.main(System.in, System.out);
    }

    static class Scanner {

        private final BufferedReader br;
        private String[] cache;
        private int cacheIndex;

        Scanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
            cache = new String[0];
            cacheIndex = 0;
        }

        int nextInt() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return Integer.parseInt(cache[cacheIndex++]);
        }

        long nextLong() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return Long.parseLong(cache[cacheIndex++]);
        }

        String next() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return cache[cacheIndex++];
        }

        void close() throws IOException {
            br.close();
        }

    }

    static class Solution {

        public static void main(InputStream is, OutputStream os)
                throws NumberFormatException, IOException {
            PrintWriter pw = new PrintWriter(os);
            Scanner sc = new Scanner(is);

            int n = sc.nextInt();
            long x = sc.nextLong();
            long y = sc.nextLong();

            ArrayList<Long> a = new ArrayList<Long>(n);

            long candForA = y/n;

            for(int i = 0 ; i < n ; i++){
                if(i < y % n) {
                    a.add(candForA + 1);
                }else{
                    a.add(candForA);
                }
            }

            long candForX = 0;
            for(long ai :a ){
                candForX += ai*ai;
            }

            if(candForX < x){
                pw.println(-1);
            } else {
                for(long ai :a){
                    pw.print(ai);
                    pw.print(" ");
                }
            }

            pw.flush();
            sc.close();
        }
    }

}


import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Task111A {

    public static void main(String... args) throws NumberFormatException,
            IOException {
        Solution.main(System.in, System.out);
    }

    static class Scanner {

        private final BufferedReader br;
        private String[] cache;
        private int cacheIndex;

        Scanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
            cache = new String[0];
            cacheIndex = 0;
        }

        int nextInt() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return Integer.parseInt(cache[cacheIndex++]);
        }

        long nextLong() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return Long.parseLong(cache[cacheIndex++]);
        }

        String next() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return cache[cacheIndex++];
        }

        void close() throws IOException {
            br.close();
        }

    }

    static class Solution {

        public static void main(InputStream is, OutputStream os)
                throws NumberFormatException, IOException {
            PrintWriter pw = new PrintWriter(os);
            Scanner sc = new Scanner(is);

            int n = sc.nextInt();
            long x = sc.nextLong();
            long y = sc.nextLong();

            if(n > y){
                pw.println(-1);
                pw.flush();
                sc.close();
                return;
            }

            ArrayList<Long> a = new ArrayList<Long>(n);

            a.add(y-n+1);

            for(int i = 1 ; i < n ; i++){
                    a.add(1L);
            }

            long candForX = 0;
            for(long ai :a ){
                candForX += ai*ai;
            }

            if(candForX < x){
                pw.println(-1);
            } else {
                for(long ai :a){
                    pw.print(ai);
                    pw.print(" ");
                }
            }

            pw.flush();
            sc.close();
        }
    }

}


import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Task111A {

    public static void main(String... args) throws NumberFormatException,
            IOException {
        Solution.main(System.in, System.out);
    }

    static class Scanner {

        private final BufferedReader br;
        private String[] cache;
        private int cacheIndex;

        Scanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
            cache = new String[0];
            cacheIndex = 0;
        }

        int nextInt() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return Integer.parseInt(cache[cacheIndex++]);
        }

        long nextLong() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return Long.parseLong(cache[cacheIndex++]);
        }

        String next() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return cache[cacheIndex++];
        }

        void close() throws IOException {
            br.close();
        }

    }

    static class Solution {

        public static void main(InputStream is, OutputStream os)
                throws NumberFormatException, IOException {
            PrintWriter pw = new PrintWriter(os);
            Scanner sc = new Scanner(is);

            int n = sc.nextInt();
            long x = sc.nextLong();
            long y = sc.nextLong();

            ArrayList<Long> a = new ArrayList<Long>(n);

            long candForA = y/n;

            for(int i = 0 ; i < n ; i++){
                if(i < n % y) {
                    a.add(candForA + 1);
                }else{
                    a.add(candForA);
                }
            }

            long candForX = 0;
            for(long ai :a ){
                candForX += ai*ai;
            }

            if(candForX < x){
                pw.println(-1);
            } else {
                for(long ai :a){
                    pw.print(ai);
                    pw.print(" ");
                }
            }

            pw.flush();
            sc.close();
        }
    }

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

public class PetyaandInequiations {

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		StringBuilder q = new StringBuilder("");
		String y = in.readLine();
		String yy[] = y.split(" ");
		int a = Integer.parseInt(yy[0]);
		long b = Long.parseLong(yy[1]);
		int c = Integer.parseInt(yy[2]);
		int ans=c/a;
		long answer=ans*ans*a;
		if(answer>=b){
			for (int i = 0; i < a; i++) {
				q.append(ans+"\n");
			}
		}
		else{
			q.append(-1+"\n");
		}
		out.print(q);
		out.close();

	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;

public class PetyaandInequiations {

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		StringBuilder q = new StringBuilder("");
		String y = in.readLine();
		String yy[] = y.split(" ");
		int a = Integer.parseInt(yy[0]);
		long b = Long.parseLong(yy[1]);
		int c = Integer.parseInt(yy[2]);
		if (a > c) {
			q.append(-1 + "\n");
		} else {
			BigInteger answer = BigInteger.valueOf(a - 1).add(
					BigInteger.valueOf(c - a + 1).pow(2));
			// System.out.println((c-a+1)*(c-a+1));
			if (answer.compareTo(BigInteger.valueOf(b)) > -1) {
				for (int i = 0; i < a - 1; i++) {
					q.append(1 + "\n");
				}
				q.append((c - a + 1) + "\n");
			} else {
				q.append(-1 + "\n");
			}
		}
		out.print(q);
		out.close();

	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

public class PetyaandInequiations {

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		StringBuilder q = new StringBuilder("");
		String y = in.readLine();
		String yy[] = y.split(" ");
		int a = Integer.parseInt(yy[0]);
		long b = Long.parseLong(yy[1]);
		int c = Integer.parseInt(yy[2]);
		int ans=c/a;
		long answer=(a-1)+(c-a+1)*(c-a+1);
		if(answer>=b){
			for (int i = 0; i < a-1; i++) {
				q.append(1+"\n");
			}
			q.append((c-a+1)+"\n");
		}
		else{
			q.append(-1+"\n");
		}
		out.print(q);
		out.close();

	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;

public class PetyaandInequiations {

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		StringBuilder q = new StringBuilder("");
		String y = in.readLine();
		String yy[] = y.split(" ");
		int a = Integer.parseInt(yy[0]);
		long b = Long.parseLong(yy[1]);
		int c = Integer.parseInt(yy[2]);
		BigInteger answer=BigInteger.valueOf(a-1).add(BigInteger.valueOf(c-a+1).pow(2));
		//System.out.println((c-a+1)*(c-a+1));
		if(answer.compareTo(BigInteger.valueOf(b))>-1){
			for (int i = 0; i < a-1; i++) {
				q.append(1+"\n");
			}
			q.append((c-a+1)+"\n");
		}
		else{
			q.append(-1+"\n");
		}
		out.print(q);
		out.close();

	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;

public class PetyaandInequiations {

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		StringBuilder q = new StringBuilder("");
		String y = in.readLine();
		String yy[] = y.split(" ");
		int a = Integer.parseInt(yy[0]);
		long b = Long.parseLong(yy[1]);
		int c = Integer.parseInt(yy[2]);
		BigInteger answer=BigInteger.valueOf(a-1).add(BigInteger.valueOf(c-a+1).pow(2));
		System.out.println((c-a+1)*(c-a+1));
		if(answer.compareTo(BigInteger.valueOf(b))>-1){
			for (int i = 0; i < a-1; i++) {
				q.append(1+"\n");
			}
			q.append((c-a+1)+"\n");
		}
		else{
			q.append(-1+"\n");
		}
		out.print(q);
		out.close();

	}

}


import java.util.Scanner;

public class Main {
    public static void main(String args[]) {
        Scanner scan = new Scanner(System.in);
        int n=scan.nextInt();
        long x=scan.nextInt();
        long y=scan.nextInt();
        if(n>y){
            System.out.print(-1);
            //System.out.println("metida de pata 1");
        }
        else{
            if(((long)Math.pow(y-n+1,2)+n-1)<x){
                System.out.print(-1);
                //System.out.println("metida de pata 2");
            }
            else{
                System.out.println(y-n+1);
                for(int i=0;i<(n-1);i++){
                    System.out.println(1);
                    //System.out.println("metida de pata 3"+ "i="+i+" n-1="+n-1);
                }
            }

        }
        scan.close();
    }

}


import java.util.Scanner;

public class Main {
    public static void main(String args[]) {
        Scanner scan = new Scanner(System.in);
        int n=scan.nextInt();
        int x=scan.nextInt();
        int y=scan.nextInt();
        if(n>y){
            System.out.print(-1);
            //System.out.println("metida de pata 1");
        }
        else{
            if(((int)Math.pow(y-n+1,2)+n-1)<x){
                System.out.print(-1);
                //System.out.println("metida de pata 2");
            }
            else{
                System.out.println(y-n+1);
                for(int i=0;i<(n-1);i++){
                    System.out.println(1);
                    //System.out.println("metida de pata 3"+ "i="+i+" n-1="+n-1);
                }
            }

        }
        scan.close();
    }

}


import java.util.Scanner;

public class Main {
    public static void main(String args[]) {
        Scanner scan = new Scanner(System.in);
        int n=scan.nextInt();
        long x=scan.nextLong();
        long y=scan.nextLong();
        if(n>y){
            System.out.print(-1);
            //System.out.println("metida de pata 1");
        }
        else{
            if(((long)Math.pow(y-n+1,2)+n-1)<x){
                System.out.print(-1);
                //System.out.println("metida de pata 2");
            }
            else{
                System.out.println(y-n+1);
                for(int i=0;i<(n-1);i++){
                    System.out.println(1);
                    //System.out.println("metida de pata 3"+ "i="+i+" n-1="+n-1);
                }
            }

        }
        scan.close();
    }

}


import java.util.*;

public class PetyaAndInequiations {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        long x = cin.nextLong();
        long y = cin.nextLong();
        cin.close();
        long max = y - n + 1;
        if (max > 0 && n - 1 + max * max >= x) {
            for (int i = 0; i < n - 1; i++) {
                System.out.println(1);
            }
            System.out.println(max);
        } else {
            System.out.println(-1);
        }
    }
}


import java.io.InputStreamReader;
import java.io.IOException;
import java.util.InputMismatchException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.Writer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Niyaz Nigmatullin
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		FastScanner in = new FastScanner(inputStream);
		FastPrinter out = new FastPrinter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, FastScanner in, FastPrinter out) {
        int n = in.nextInt();
        long x = in.nextLong();
        int y = in.nextInt();
        y -= n - 1;
        x -= n - 1;
        if ((long) y * y < x) {
            out.println(-1);
            return;
        }
        out.println(y);
        for (int i = 0; i < n - 1; i++) {
            out.println(1);
        }
    }
}

class FastScanner extends BufferedReader {

    boolean isEOF;

    public FastScanner(InputStream is) {
        super(new InputStreamReader(is));
    }

    public int read() {
        try {
            int ret = super.read();
            if (isEOF && ret < 0) {
                throw new InputMismatchException();
            }
            isEOF = ret == -1;
            return ret;
        } catch (IOException e) {
            throw new InputMismatchException();
        }
    }

    public String next() {
        StringBuilder sb = new StringBuilder();
        int c = read();
        while (isWhiteSpace(c)) {
            c = read();
        }
        if (c < 0) {
            return null;
        }
        while (c >= 0 && !isWhiteSpace(c)) {
            sb.appendCodePoint(c);
            c = read();
        }
        return sb.toString();
    }

    static boolean isWhiteSpace(int c) {
        return c >= 0 && c <= 32;
    }

    public int nextInt() {
        int c = read();
        while (isWhiteSpace(c)) {
            c = read();
        }
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int ret = 0;
        while (!isWhiteSpace(c)) {
            if (c < '0' || c > '9') {
                throw new NumberFormatException("digit expected " + (char) c
                        + " found");
            }
            ret = ret * 10 + c - '0';
            c = read();
        }
        return ret * sgn;
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    }

class FastPrinter extends PrintWriter {

    public FastPrinter(OutputStream out) {
        super(out);
    }

    public FastPrinter(Writer out) {
        super(out);
    }

}


import java.io.InputStreamReader;
import java.io.IOException;
import java.util.InputMismatchException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.Writer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Niyaz Nigmatullin
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		FastScanner in = new FastScanner(inputStream);
		FastPrinter out = new FastPrinter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, FastScanner in, FastPrinter out) {
        int n = in.nextInt();
        long x = in.nextLong();
        int y = in.nextInt();
        y -= n - 1;
        x -= n - 1;
        if (y <= 0 || (long) y * y < x) {
            out.println(-1);
            return;
        }
        out.println(y);
        for (int i = 0; i < n - 1; i++) {
            out.println(1);
        }
    }
}

class FastScanner extends BufferedReader {

    boolean isEOF;

    public FastScanner(InputStream is) {
        super(new InputStreamReader(is));
    }

    public int read() {
        try {
            int ret = super.read();
            if (isEOF && ret < 0) {
                throw new InputMismatchException();
            }
            isEOF = ret == -1;
            return ret;
        } catch (IOException e) {
            throw new InputMismatchException();
        }
    }

    public String next() {
        StringBuilder sb = new StringBuilder();
        int c = read();
        while (isWhiteSpace(c)) {
            c = read();
        }
        if (c < 0) {
            return null;
        }
        while (c >= 0 && !isWhiteSpace(c)) {
            sb.appendCodePoint(c);
            c = read();
        }
        return sb.toString();
    }

    static boolean isWhiteSpace(int c) {
        return c >= 0 && c <= 32;
    }

    public int nextInt() {
        int c = read();
        while (isWhiteSpace(c)) {
            c = read();
        }
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int ret = 0;
        while (!isWhiteSpace(c)) {
            if (c < '0' || c > '9') {
                throw new NumberFormatException("digit expected " + (char) c
                        + " found");
            }
            ret = ret * 10 + c - '0';
            c = read();
        }
        return ret * sgn;
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    }

class FastPrinter extends PrintWriter {

    public FastPrinter(OutputStream out) {
        super(out);
    }

    public FastPrinter(Writer out) {
        super(out);
    }

}


import java.util.Scanner;

public class Main {
	public static void main (String [] args) {
		Scanner s = new Scanner(System.in);

		int n;
		long x,y;
		n = s.nextInt();
		x = s.nextLong();
		y = s.nextInt();

		long[] sec = new long[n];
		for(int i = 0 ; i < n ; i++) {
			sec[i] = 1;
		}

		if(y-n+1 >= 0) {
			sec[0] = y-n+1;
			if(suma(sec) <= y && suma2(sec) >= x) {
				imprimir(sec);
			}
			else
				System.out.println(-1);
		}
		else
			System.out.println(-1);

	}

	public static long suma(long [] arr) {
		long suma = 0;
		for (int i = 0 ; i < arr.length ; i++) {
			suma+= arr[i];
		}
		return suma;
	}

	public static long suma2(long [] arr) {
		long suma = 0;
		for (int i = 0 ; i < arr.length ; i++) {
			suma+= (arr[i])*(arr[i]);
		}
		return suma;
	}

	public static void imprimir(long [] arr) {
		for (int i = 0 ; i < arr.length ; i++)
			System.out.println(arr[i]);
	}
}


import java.util.Scanner;

public class Main {
	public static void main (String [] args) {
		Scanner s = new Scanner(System.in);

		int n,y;
		long x;
		n = s.nextInt();
		x = s.nextLong();
		y = s.nextInt();

		int[] sec = new int[n];
		for(int i = 0 ; i < n ; i++) {
			sec[i] = y/n;
		}

		if(suma(sec) <= y && suma2(sec) >= x) {
			imprimir(sec);
		}
		else
			System.out.println(-1);

	}

	public static long suma(int [] arr) {
		long suma = 0;
		for (int i = 0 ; i < arr.length ; i++) {
			suma+= arr[i];
		}
		return suma;
	}

	public static long suma2(int [] arr) {
		long suma = 0;
		for (int i = 0 ; i < arr.length ; i++) {
			suma+= (arr[i])*(arr[i]);
		}
		return suma;
	}

	public static void imprimir(int [] arr) {
		for (int i = 0 ; i < arr.length ; i++)
			System.out.println(arr[i]);
	}
}


import java.util.Scanner;

public class Main {
	public static void main (String [] args) {
		Scanner s = new Scanner(System.in);

		int n;
		long x,y;
		n = s.nextInt();
		x = s.nextLong();
		y = s.nextInt();

		long[] sec = new long[n];
		for(int i = 0 ; i < n ; i++) {
			sec[i] = 1;
		}

		if(y-n+1 > 0) {
			sec[0] = y-n+1;
			if(suma(sec) <= y && suma2(sec) >= x) {
				imprimir(sec);
			}
			else
				System.out.println(-1);
		}
		else
			System.out.println(-1);

	}

	public static long suma(long [] arr) {
		long suma = 0;
		for (int i = 0 ; i < arr.length ; i++) {
			suma+= arr[i];
		}
		return suma;
	}

	public static long suma2(long [] arr) {
		long suma = 0;
		for (int i = 0 ; i < arr.length ; i++) {
			suma+= (arr[i])*(arr[i]);
		}
		return suma;
	}

	public static void imprimir(long [] arr) {
		for (int i = 0 ; i < arr.length ; i++)
			System.out.println(arr[i]);
	}
}


import java.util.Scanner;

public class Main {
	public static void main (String [] args) {
		Scanner s = new Scanner(System.in);

		int n;
		long x,y;
		n = s.nextInt();
		x = s.nextLong();
		y = s.nextInt();

		long[] sec = new long[n];
		for(int i = 0 ; i < n ; i++) {
			sec[i] = 1;
		}

		sec[0] = y-n+1;
		if(suma(sec) <= y && suma2(sec) >= x) {
			imprimir(sec);
		}
		else
			System.out.println(-1);

	}

	public static long suma(long [] arr) {
		long suma = 0;
		for (int i = 0 ; i < arr.length ; i++) {
			suma+= arr[i];
		}
		return suma;
	}

	public static long suma2(long [] arr) {
		long suma = 0;
		for (int i = 0 ; i < arr.length ; i++) {
			suma+= (arr[i])*(arr[i]);
		}
		return suma;
	}

	public static void imprimir(long [] arr) {
		for (int i = 0 ; i < arr.length ; i++)
			System.out.println(arr[i]);
	}
}


import java.util.Scanner;

public class Main {
	public static void main (String [] args) {
		Scanner s = new Scanner(System.in);

		int n,y;
		long x;
		n = s.nextInt();
		x = s.nextLong();
		y = s.nextInt();

		int[] sec = new int[n];
		for(int i = 0 ; i < n ; i++) {
			sec[i] = 1;
		}

		sec[n-1] = y-n+1;
		if(suma(sec)<=y && suma2(sec)>=x) {
			imprimir(sec);
		}
		else {
			System.out.println(-1);
		}

	}

	public static long suma(int [] arr) {
		long suma = 0;
		for (int i = 0 ; i < arr.length ; i++) {
			suma+= arr[i];
		}
		return suma;
	}

	public static long suma2(int [] arr) {
		long suma = 0;
		for (int i = 0 ; i < arr.length ; i++) {
			suma+= (arr[i])*(arr[i]);
		}
		return suma;
	}

	public static void imprimir(int [] arr) {
		for (int i = 0 ; i < arr.length ; i++)
			System.out.println(arr[i]);
	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class Main {
	public static void main(String[] args) throws IOException {
		new Thread(null, new Runnable() {
			public void run() {
				try {
					long prevTime = System.currentTimeMillis();
					new Main().run();
					System.err.println("Total time: "
							+ (System.currentTimeMillis() - prevTime) + " ms");
					System.err.println("Memory status: " + memoryStatus());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}, "1", 1L << 24).start();
	}

	void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		Object o = solve();
		if (o != null)
			out.println(o);
		out.close();
		in.close();
	}

	private Object solve() throws IOException {
		int n = ni();
		long x = nl();
		long y = nl();

		long[] check = new long[n];
		Arrays.fill(check, 1L);
		check[0]= y - (long) (n-1);
		if(check[0]<=0L)
			return -1;
		long aux=0;
		for(long a : check)
			aux += a*a;
		if(aux>=x){
			printArray(check);
			return null;
		}else{
			return -1;
		}

	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer strTok = new StringTokenizer("");

	String nextToken() throws IOException {
		while (!strTok.hasMoreTokens())
			strTok = new StringTokenizer(in.readLine());
		return strTok.nextToken();
	}

	int ni() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nl() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nd() throws IOException {
		return Double.parseDouble(nextToken());
	}

	int[] nia(int size) throws IOException {
		int[] ret = new int[size];
		for (int i = 0; i < size; i++)
			ret[i] = ni();
		return ret;
	}

	long[] nla(int size) throws IOException {
		long[] ret = new long[size];
		for (int i = 0; i < size; i++)
			ret[i] = nl();
		return ret;
	}

	double[] nda(int size) throws IOException {
		double[] ret = new double[size];
		for (int i = 0; i < size; i++)
			ret[i] = nd();
		return ret;
	}

	String nextLine() throws IOException {
		strTok = new StringTokenizer("");
		return in.readLine();
	}

	boolean EOF() throws IOException {
		while (!strTok.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			strTok = new StringTokenizer(s);
		}
		return false;
	}

	void printRepeat(String s, int count) {
		for (int i = 0; i < count; i++)
			out.print(s);
	}

	void printArray(int[] array) {
		for (int i = 0; i < array.length; i++) {
			if (i > 0)
				out.print(' ');
			out.print(array[i]);
		}
		out.println();
	}

	void printArray(long[] array) {
		for (int i = 0; i < array.length; i++) {
			if (i > 0)
				out.print(' ');
			out.print(array[i]);
		}
		out.println();
	}

	void printArray(double[] array) {
		for (int i = 0; i < array.length; i++) {
			if (i > 0)
				out.print(' ');
			out.print(array[i]);
		}
		out.println();
	}

	void printArray(double[] array, String spec) {
		for (int i = 0; i < array.length; i++) {
			if (i > 0)
				out.print(' ');
			out.printf(Locale.US, spec, array[i]);
		}
		out.println();
	}

	void printArray(Object[] array) {
		boolean blank = false;
		for (Object x : array) {
			if (blank)
				out.print(' ');
			else
				blank = true;
			out.print(x);
		}
		out.println();
	}

	@SuppressWarnings("rawtypes")
	void printCollection(Collection collection) {
		boolean blank = false;
		for (Object x : collection) {
			if (blank)
				out.print(' ');
			else
				blank = true;
			out.print(x);
		}
		out.println();
	}

	static String memoryStatus() {
		return (Runtime.getRuntime().totalMemory()
				- Runtime.getRuntime().freeMemory() >> 20)
				+ "/" + (Runtime.getRuntime().totalMemory() >> 20) + " MB";
	}

	public void pln() {
		out.println();
	}

	public void pln(int arg) {
		out.println(arg);
	}

	public void pln(long arg) {
		out.println(arg);
	}

	public void pln(double arg) {
		out.println(arg);
	}

	public void pln(String arg) {
		out.println(arg);
	}

	public void pln(boolean arg) {
		out.println(arg);
	}

	public void pln(char arg) {
		out.println(arg);
	}

	public void pln(float arg) {
		out.println(arg);
	}

	public void pln(Object arg) {
		out.println(arg);
	}

	public void p(int arg) {
		out.print(arg);
	}

	public void p(long arg) {
		out.print(arg);
	}

	public void p(double arg) {
		out.print(arg);
	}

	public void p(String arg) {
		out.print(arg);
	}

	public void p(boolean arg) {
		out.print(arg);
	}

	public void p(char arg) {
		out.print(arg);
	}

	public void p(float arg) {
		out.print(arg);
	}

	public void p(Object arg) {
		out.print(arg);
	}

}


import java.util.Scanner;

public class PetyaAndInequations {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long N = sc.nextLong(), X = sc.nextLong(), Y = sc.nextLong();
        long max = Y - (N - 1);
        if (N - 1 + max * max >= X) {
            for (int i = 0; i < N - 1; i++)
                System.out.println(1);
            System.out.println(max);
        } else {
            System.out.println(-1);
        }

    }

}


import java.util.Scanner;

public class PetyaAndInequations {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long N = sc.nextLong(), X = sc.nextLong(), Y = sc.nextLong();
        long max = Y - (N - 1);
        if (max > 0 && N - 1 + max * max >= X) {
            for (int i = 0; i < N - 1; i++)
                System.out.println(1);
            System.out.println(max);
        } else {
            System.out.println(-1);
        }

    }

}


import java.io.*;
import java.util.*;

public class p111a
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        long x = sc.nextLong();
        long y = sc.nextLong();
        long max = y-n+1;
        if(max>0 && n-1+max*max>=x)
        {
            for(int i=0;i<n-1;i++) System.out.println(1);
            System.out.println(max);
        } else System.out.println(-1);
    }
}


import java.util.Scanner;

public class Task{

	public static void main(String args[]){
		Solver s = new Solver();
		s.solve();
	}
}

class Solver{

	private Scanner sc = new Scanner(System.in);

	public void solve(){
		int n = sc.nextInt();
		long x = sc.nextLong();
		int y = sc.nextInt();
		x -= n-1;
		y -= n-1;
		for (int i=1;i<=y;i++)
			if ((long)i*i>=x){
				System.out.println(i);
				for (int j=0;j<n-1;j++)
					System.out.println(1);
				return;
			}
		System.out.println(-1);
	}
}


import java.io.*;

/**
 * Created by KC on 4/13/14.
 */
public class PetyaInequiation {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    public static void main(String[] args) throws IOException{

        String[] p = bufferedReader.readLine().split(" ");
        long n = Long.parseLong(p[0]);
        long x = Long.parseLong(p[1]);
        long y = Long.parseLong(p[2]);

         if( n > y){
             printWriter.println(-1);
             printWriter.flush();
             printWriter.close();
             return;
         }
        long max = y - (n -1);
        if(max*max + n - 1 < x){
            printWriter.println(-1);
            printWriter.flush();
            printWriter.close();
            return;
        }

      printWriter.println(max);
        for(int i = 0; i < n-1; i++)
            printWriter.println(1);
        printWriter.flush();
        printWriter.close();
        return;

    }
}


import java.io.*;

/**
 * Created by KC on 4/13/14.
 */
public class PetyaInequiation {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    public static void main(String[] args) throws IOException{

        String[] p = bufferedReader.readLine().split(" ");
        int n = Integer.parseInt(p[0]);
        int x = Integer.parseInt(p[1]);
        int y = Integer.parseInt(p[2]);

        if( x < y){
            printWriter.println(-1);
            printWriter.flush();
            printWriter.close();
            return;
        }

        int max = y - (n -1);
        if(max*max + n - 1 < x){
            printWriter.println(-1);
            printWriter.flush();
            printWriter.close();
            return;
        }
      printWriter.println(max);
        for(int i = 0; i < n-1; i++)
            printWriter.println(1);
        printWriter.flush();
        printWriter.close();
        return;

    }
}


import java.io.*;

/**
 * Created by KC on 4/13/14.
 */
public class PetyaInequiation {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    public static void main(String[] args) throws IOException{

        String[] p = bufferedReader.readLine().split(" ");
        long n = Long.parseLong(p[0]);
        long x = Long.parseLong(p[1]);
        long y = Long.parseLong(p[2]);

        if( x < y){
            printWriter.println(-1);
            printWriter.flush();
            printWriter.close();
            return;
        }

        long max = y - (n -1);
        if(max*max + n - 1 < x){
            printWriter.println(-1);
            printWriter.flush();
            printWriter.close();
            return;
        }
      printWriter.println(max);
        for(int i = 0; i < n-1; i++)
            printWriter.println(1);
        printWriter.flush();
        printWriter.close();
        return;

    }
}


import java.io.*;

/**
 * Created by KC on 4/13/14.
 */
public class PetyaInequiation {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    public static void main(String[] args) throws IOException{

        String[] p = bufferedReader.readLine().split(" ");
        long n = Long.parseLong(p[0]);
        long x = Long.parseLong(p[1]);
        long y = Long.parseLong(p[2]);

        if( x < y){
            printWriter.println(-1);
            printWriter.flush();
            printWriter.close();
            return;
        }
         if( n > y){
             printWriter.println(-1);
             printWriter.flush();
             printWriter.close();
             return;
         }
        long max = y - (n -1);
        if(max*max + n - 1 < x){
            printWriter.println(-1);
            printWriter.flush();
            printWriter.close();
            return;
        }

      printWriter.println(max);
        for(int i = 0; i < n-1; i++)
            printWriter.println(1);
        printWriter.flush();
        printWriter.close();
        return;

    }
}


import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;

/**
 * Created by KC on 4/8/14.
 */
public class PageNumbers {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    public static void main(String[] args) throws IOException{
        // read the number into an array, use a hash set to guarantee that only one element is
        // included in. then sort the array, get the consecutitives number
        // if there is only one, just input it

        String[] p = bufferedReader.readLine().trim().split(",");
        HashSet<Integer> set = new HashSet<Integer>();
        ArrayList<Integer> content = new ArrayList<Integer>();
        for(int i = 0; i < p.length; i++){
            int tmp = Integer.parseInt(p[i]);
            if(!set.contains(tmp)){
                content.add(tmp);
                set.add(tmp);
            }
        }

        Collections.sort(content);

        int i = 0;
        int size = content.size();

        while (i < size){

            int base = i;
            int pre = content.get(base);
            i++;
            while (i < size &&  pre+1 == content.get(i)  ){
                  pre++;
                  i++;
            }

            int count = i - base;
            if(count == 1){
                printWriter.print(content.get(base));
                if(i < size)
                printWriter.print(",");
            }
            else {
                printWriter.print(content.get(base));
                printWriter.print("-");
                printWriter.print(content.get(i-1));
                if(i < size)
                printWriter.print(",");
            }

        }

        printWriter.flush();
        printWriter.close();

    }
}


import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner r = new Scanner(System.in);
        int n = r.nextInt();
        long x = r.nextLong();
        long y = r.nextLong();
        long h = y-n+1;
        if ((h*h)+(n-1)>=x && h<=y-n+1){
        	System.out.println((y - n + 1));
        	for (int i = 0; i < n - 1; i++){
        		System.out.println(1);
        	}
        }
        else{
        	System.out.println(-1);
        }
    }
}


import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner r = new Scanner(System.in);
        int n = r.nextInt();
        long x = r.nextLong();
        long y = r.nextLong();
        long h = y-n+1;
        if (h*h>=x && h+n-1<=y){
        	System.out.println((y - n + 1));
        	for (int i = 0; i < n - 1; i++){
        		System.out.println(1);
        	}
        }
        else{
        	System.out.println(-1);
        }
    }
}


import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner r = new Scanner(System.in);
        int n = r.nextInt();
        long x = r.nextLong();
        long y = r.nextLong();
        long h = y-n+1;
        if ((h*h)+(n-1)>=x && h+n-1<=y && h>0){
        	System.out.println((y - n + 1));
        	for (int i = 0; i < n - 1; i++){
        		System.out.println(1);
        	}
        }
        else{
        	System.out.println(-1);
        }
    }
}


import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner r = new Scanner(System.in);
        int n = r.nextInt();
        long x = r.nextLong();
        long y = r.nextLong();
        long h = y-n+1;
        if ((h*h)+(n-1)>=x && (h+n-1)<=y){
        	System.out.println((y - n + 1));
        	for (int i = 0; i < n - 1; i++){
        		System.out.println(1);
        	}
        }
        else{
        	System.out.println(-1);
        }
    }
}


import java.util.Arrays;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner r = new Scanner(System.in);
        int n = r.nextInt();
        long x = r.nextLong();
        long y = r.nextLong();
        int[] a = new int[n];
        Arrays.fill(a, 1);
        if (n - 1 + (y - n + 1) * (y - n + 1) >= x && (y - n + 1) > 0){
        	System.out.println((y - n + 1));
        	for (int i = 0; i < n - 1; i++){
        		System.out.println(1);
        	}
        }
        else{
        	System.out.println(-1);
        }
    }
}


#include <bits/stdc++.h>
using namespace std;
int main()
{
	int i,n,x,y,s1=0,s2=0;
    cin>>n>>x>>y;
    int sum=0;
    sum=y-(n+1);
    sum*=sum;
    sum+=n-1;
    if(sum<x&&sum>y){
    	cout<<-1<<endl;
	}
	else {

		for(i=0;i<n-1;i++){
			cout<<1<<endl;
		}
		cout<<y-(n+1)<<endl;
	}
}


#include <bits/stdc++.h>
using namespace std;
int main()
{
	int i,n,x,y,s1=0,s2=0;
    cin>>n>>x>>y;
    int sum=0;
    sum=x-(n-1);
    sum*=sum;
    sum+=n-1;
    if(sum<x&&sum>y){
    	cout<<-1<<endl;
	}
	else {

		for(i=0;i<n-1;i++){
			cout<<1<<endl;
		}
		cout<<x-(n-1)<<endl;
	}
}


#include <bits/stdc++.h>
using namespace std;
int main()
{
	int i,n,x,y,s1=0,s2=0;
    cin>>n>>x>>y;
    int sum=0;
    sum=y-(n-1);
    sum*=sum;
    sum+=n-1;
    if(sum<x&&sum>y){
    	cout<<-1<<endl;
	}
	else {

		for(i=0;i<n-1;i++){
			cout<<1<<endl;
		}
		cout<<y-(n-1)<<endl;
	}
}


#include<bits/stdc++.h>
using namespace std;
long long n,x,y,s1,max1;
int main(){
	int i;
    cin>>n>>x>>y;
    s1=y-n+1;
    max1=s1*s1+n-1;
    if(max1<x||n>y)cout<<"-1";
    else {
		for(i=0;i<n-1;i++)
		cout<<1<<endl;
		cout<<y-n+1<<endl;
	}
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
int main()
{
	int i,n,x,y,s1=0,s2=0;
    cin>>n>>x>>y;
    if(x>y){
    	cout<<-1<<endl;
	}
	else {
		for(i=0;i<n-1;i++){
			cout<<1<<endl;
		}
		cout<<x-(n-1)<<endl;
	}
}


#include<bits/stdc++.h>

using namespace std;
const int maxn = 1e5 + 5;
bool solve(int n, long long x, int y)
{
    int k = sqrt(x); long long z = k*k;
    for(int i=1; i<n; ++i) k++, z++;
    if (k <= y && z >= x) {
        cout << (int)sqrt(x) << "\n";
        for(int i=1; i<n; ++i) cout << 1 << "\n";
        return true;
    }
    return false;
}

int main()
{
    int n, y; long long x;
    cin >> n >> x >> y;
    if (solve(n, x, y)) return 0;
    x = sqrt(x) + 1;
    if (x + n-1 > y) return cout << -1, 0;
    cout << x << "\n";
    for(int i=1; i<n; ++i) cout << 1 << "\n";
}


#include<bits/stdc++.h>

using namespace std;
const int maxn = 1e5 + 5;
bool solve(int n, long long x, int y)
{
    int k = sqrt(x); long long z = 1LL*k*k;
    for(int i=1; i<n; ++i) k++, z++;
    if (k <= y && z >= x) {
        cout << (int)sqrt(x) << "\n";
        for(int i=1; i<n; ++i) cout << 1 << "\n";
        cout << -1;
        return true;
    }
    return false;
}

int main()
{
    int n, y; long long x;
    cin >> n >> x >> y;
    if (solve(n, x, y)) return 0;
    x = sqrt(x) + 1;
    if (x + n-1 > y) return cout << -1, 0;
    cout << x << "\n";
    for(int i=1; i<n; ++i) cout << 1 << "\n";
}


#include<bits/stdc++.h>

using namespace std;
const int maxn = 1e5 + 5;
bool solve(int n, long long x, int y)
{
    int k = sqrt(x); long long z = 1LL*k*k;
    for(int i=1; i<n; ++i) k++, z++;
    if (k <= y && z >= x) {
        cout << (int)sqrt(x) << "\n";
        for(int i=1; i<n; ++i) cout << 1 << "\n";
        return true;
    }
    return false;
}

int main()
{
    int n, y; long long x;
    cin >> n >> x >> y;
    if (solve(n, x, y)) return 0;
    x = sqrt(x) + 1;
    if (x + n-1 > y) return cout << -1, 0;
    cout << x << "\n";
    for(int i=1; i<n; ++i) cout << 1 << "\n";
}


#include<bits/stdc++.h>

using namespace std;
const int maxn = 1e5 + 5;
bool solve(int n, long long x, int y)
{
    int k = sqrt(x); long long z = k*k;
    for(int i=1; i<n; ++i) k++, z++;
    if (k <= y && z >= x) {
        cout << (int)sqrt(x) << "\n";
        for(int i=1; i<n; ++i) cout << 1 << "\n";
        cout << -1;
        return true;
    }
    return false;
}

int main()
{
    int n, y; long long x;
    cin >> n >> x >> y;
    if (solve(n, x, y)) return 0;
    x = sqrt(x) + 1;
    if (x + n-1 > y) return cout << -1, 0;
    cout << x << "\n";
    for(int i=1; i<n; ++i) cout << 1 << "\n";
}


#include<bits/stdc++.h>

using namespace std;
const int maxn = 1e5 + 5;
bool check(long long x)
{
    int y = sqrt(x);
    return (1LL*y*y != x);
}
bool solve(int n, long long x, int y)
{
    int k = sqrt(x); long long z = x*x;
    for(int i=1; i<n; ++i) k++, z++;
    if (k <= y && z >= x) {
        cout << (int)sqrt(x) << "\n";
        for(int i=1; i<n; ++i) cout << 1 << "\n";
        return true;
    }
    return false;
}

int main()
{
    int n, y; long long x;
    cin >> n >> x >> y;
    if (solve(n, x, y)) return 0;
    x = sqrt(x) + check(x);
    if (x + n-1 > y) return cout << -1, 0;
    cout << x << "\n";
    for(int i=1; i<n; ++i) cout << 1 << "\n";
}


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

long long n, x, y;
int main() {
	cin >> n >> x >> y;
	long long maxa = y - (n - 1);
	long long suma = maxa * maxa + n - 1;
	if (suma < x) {
		cout << -1 << endl;
	} else {
		cout << maxa << endl;
		n--;
		while (n--) {
			cout << 1 << endl;
		}
	}
	return 0;
}


AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA


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

long long n, x, y;
int main() {
	cin >> n >> x >> y;
	long long maxa = y - (n - 1);
	long long suma = maxa * maxa + n - 1;
	if (suma < x || maxa < 0) {
		cout << -1 << endl;
	} else {
		cout << maxa << endl;
		n--;
		while (n--) {
			cout << 1 << endl;
		}
	}
	return 0;
}


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

long long n, x, y;
int main() {
	cin >> n >> x >> y;
	long long maxa = y - (n - 1);
	long long suma = maxa * maxa + n - 1;
	if (suma < x || maxa <= 0) {
		cout << -1 << endl;
	} else {
		cout << maxa << endl;
		n--;
		while (n--) {
			cout << 1 << endl;
		}
	}
	return 0;
}


AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA


FADFADFAESDFEWSQDWQEDWQDX
ASDDACDSXWQRDF3EWQRFQQQQFQFQFQFQFQ
FQFQFQFFFFFFEDWFEDEGER
WGTERFWQEDWQDWQFEQDWQDWQFWQFWQFDW
QDWQWQFWQEFWQEDWQGBVB BFDGVERFHBGFRNGFRNBRTG


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n, x, y;

int main(){
	cin>>n>>x>>y;
	ll s = 0;
	vector<ll> res;
	if (n>y){
		cout<<-1<<endl;
		return 0;
	}
	for (int i=0; i<n-1; i++){
		res.push_back(1LL);
	}
	res.push_back(y-n+1LL);
	for (int i=0; i<n; i++){
		s+=res[i]*res[i];
	}
	if (s<x){
		cout<<-1<<endl;
	}
	else{
		for (int i=0; i<n; i++){
			cout<<res[i]<<endl;
		}
	}
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n, x, y;

int main(){
	cin>>n>>x>>y;
	ll s = 0;
	vector<ll> res;
	if (n>y){
		cout<<-1<<endl;
		return 0;
	}
	for (int i=0; i<n-1; i++){
		res.push_back(1LL);
	}
	res.push_back(y-n+1LL);
	for (int i=0; i<n; i++){
		s+=res[i]*res[i];
	}
	if (s<x){
		cout<<-1<<endl;
	}
	else{
		for (int i=0; i<n; i++){
			cout<<res[i]<<endl;
		}
	}
}


#include <iostream>
#include <stdio.h>
#include <fstream>
#include <string.h>

#include <string>
#include <vector>
#include <map>
#include <set>
#include <list>
#include <set>
#include <deque>
#include <utility>
#include <sstream>
#include <queue>
#include <stack>
#include <bitset>

#include <math.h>
#include <iomanip>
#include <algorithm>
#include <limits.h>

#define MP   make_pair
#define PB   push_back
#define FI   first
#define SE   second

#define MAX  50

#define INF  ( 1<<29 )

typedef long long ll;

using namespace std;

ll n, x, y, w, z;

int main( ) {

    ios_base::sync_with_stdio( 0 );
    cin.tie( 0 );
    cout.tie( 0 );

    cin >> n >> x >> y;

    if( (y-n+1)*(y-n+1) >= x ) {
        for( int i = 0; i < n-1; i++ ) cout << 1 << "\n";
        cout << (y-n+1) << "\n";
    }
    else cout << -1 << "\n";

    return 0;

}


#include <iostream>
#include <stdio.h>
#include <fstream>
#include <string.h>

#include <string>
#include <vector>
#include <map>
#include <set>
#include <list>
#include <set>
#include <deque>
#include <utility>
#include <sstream>
#include <queue>
#include <stack>
#include <bitset>

#include <math.h>
#include <iomanip>
#include <algorithm>
#include <limits.h>

#define MP   make_pair
#define PB   push_back
#define FI   first
#define SE   second

#define MAX  50

#define INF  ( 1<<29 )

typedef long long ll;

using namespace std;

ll n, x, y, w, z;

int main( ) {

    ios_base::sync_with_stdio( 0 );
    cin.tie( 0 );
    cout.tie( 0 );

    cin >> n >> x >> y;

    if( y-n+1LL > 0 && (y-n+1LL)*(y-n+1LL)+(n-1) >= x ) {
        for( int i = 0; i < n-1; i++ ) cout << 1 << "\n";
        cout << (y-n+1) << "\n";
    }
    else cout << -1 << "\n";

    return 0;

}


// tle

#include <iostream>
#include <set>
#include <map>
#include <algorithm>
#include <vector>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define b2e(C) C.begin(), C.end()
using namespace std;
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;

struct station { int x, r, f, id; };
bool operator<(const station& a, int f) { return a.f < f; }

vector<station> s;
int n, k;

station* lb(int f) { return &*lower_bound(b2e(s), f); }

struct node {
	int val;
	ll cnt, lcnt, rcnt;
	node *l, *r;
};

ll solve(int f) {
	vector<station> left(lb(f), lb(f+1));
	vector<station> right(lb(f - k), lb(f+k+1));
	sort(b2e(left), [](auto a, auto b) { return a.x < b.x; });
	sort(b2e(right), [](auto a, auto b) { return a.x - a.r < b.x - b.r; });
	auto r = right.begin();
	ll ans = 0;
	ordered_set xs;
	for(auto it : left) {
		while(r != right.end() && r->x - r->r <= it.x) {
			xs.insert(r->x);
			++r;
		}
		ll d = xs.order_of_key(it.x+it.r+1) - xs.order_of_key(it.x);
		ans += d;
		// for(auto y = ma; y != mb; y++) {
		// 	cerr << "match " << it.id << " " << y->second << endl;
		// }
	}
	return ans - left.size();
}

int main() {
	cin >> n >> k;
	s.resize(n);
	for(int i=0; i<n; i++) {
		cin >> s[i].x >> s[i].r >> s[i].f;
		s[i].id = i;
	}
	sort(&s[0], &s[n], [](auto a, auto b) { return a.f < b.f; });
	int f = 0;
	ll ans = 0;
	for(station &i : s) {
		if(i.f != f) {
			ans += solve(i.f);
			f = i.f;
		}
	}
	cout << ans << endl;
}


#include <iostream>
#include <set>
#include <map>
#include <algorithm>
#include <vector>
#define ll long long
#define b2e(C) C.begin(), C.end()
using namespace std;

struct station { int x, r, f, id; };
bool operator<(const station& a, int f) { return a.f < f; }

vector<station> s;
int n, k;

station* lb(int f) { return &*lower_bound(b2e(s), f); }

ll solve(int f) {
	vector<station> left(lb(f), lb(f + 1));
	vector<station> right(lb(f - k), lb(f + k + 1));
	sort(b2e(left), [](auto a, auto b) { return a.x < b.x; });
	sort(b2e(right), [](auto a, auto b) { return a.x - a.r < b.x - b.r; });
	auto r = right.begin();
	set<pair<int,int>> xs;
	ll ans = 0;
	for(auto it : left) {
		while(r != right.end() && r->x - r->r <= it.x) {
			xs.insert(make_pair(r->x, r->id));
			++r;
		}
		auto ma = xs.lower_bound(make_pair(it.x,0));
		auto mb = xs.lower_bound(make_pair(it.x + it.r + 1,0));
		ans += distance(ma, mb);
		// for(auto y = ma; y != mb; y++) {
		// 	cout << "match " << it.id << " " << y->second << endl;
		// }
	}
	return ans - left.size();
}

int main() {
	cin >> n >> k;
	s.resize(n);
	for(int i=0; i<n; i++) {
		cin >> s[i].x >> s[i].r >> s[i].f;
		s[i].id = i;
	}
	sort(&s[0], &s[n], [](auto a, auto b) { return a.f < b.f; });
	int f = 0;
	ll ans = 0;
	for(station &i : s) {
		if(i.f != f) {
			ans += solve(i.f);
			f = i.f;
		}
	}
	cout << ans << endl;
}


// tle

#include <iostream>
#include <set>
#include <map>
#include <algorithm>
#include <vector>
#define ll long long
#define b2e(C) C.begin(), C.end()
using namespace std;

struct station { int x, r, f, id; };
bool operator<(const station& a, int f) { return a.f < f; }

vector<station> s;
int n, k;

station* lb(int f) { return &*lower_bound(b2e(s), f); }

struct node {
	int val;
	ll cnt, lcnt, rcnt;
	node *l, *r;
};

void insert(node **n, int val) {
	if(!*n) {
		*n = new node{val, 1, 0, 0, nullptr, nullptr};
	} else if(val == (**n).val) {
		(**n).cnt++;
	} else if(val < (**n).val) {
		(**n).lcnt++;
		insert(&((**n).l), val);
	} else {
		(**n).rcnt++;
		insert(&((**n).r), val);
	}
}

ll nright(node *n, int val) {
	if(!n) return 0;
	if(n->val >= val) return n->cnt + n->rcnt + nright(n->l, val);
	return nright(n->r, val);
}

void del(node *n) {
	if(!n) return;
	del(n->l);
	del(n->r);
	delete n;
}

ll solve(int f) {
	vector<station> left(lb(f), lb(f+1));
	vector<station> right(lb(f - k), lb(f+k+1));
	sort(b2e(left), [](auto a, auto b) { return a.x < b.x; });
	sort(b2e(right), [](auto a, auto b) { return a.x - a.r < b.x - b.r; });
	auto r = right.begin();
	node *n = 0;
	set<pair<int,int>> xs;
	ll ans = 0;
	for(auto it : left) {
		while(r != right.end() && r->x - r->r <= it.x) {
			xs.insert(make_pair(r->x, r->id));
			insert(&n, r->x);
			++r;
		}
		ll d = nright(n, it.x) - nright(n, it.x+it.r+1);
		ans += d;
		// for(auto y = ma; y != mb; y++) {
		// 	cerr << "match " << it.id << " " << y->second << endl;
		// }
	}
	del(n);
	return ans - left.size();
}

int main() {
	cin >> n >> k;
	s.resize(n);
	for(int i=0; i<n; i++) {
		cin >> s[i].x >> s[i].r >> s[i].f;
		s[i].id = i;
	}
	sort(&s[0], &s[n], [](auto a, auto b) { return a.f < b.f; });
	int f = 0;
	ll ans = 0;
	for(station &i : s) {
		if(i.f != f) {
			ans += solve(i.f);
			f = i.f;
		}
	}
	cout << ans << endl;
}


// tle

#include <iostream>
#include <set>
#include <map>
#include <algorithm>
#include <vector>
#define ll long long
#define b2e(C) C.begin(), C.end()
using namespace std;

struct station { int x, r, f, id; };
bool operator<(const station& a, int f) { return a.f < f; }

vector<station> s;
int n, k;

station* lb(int f) { return &*lower_bound(b2e(s), f); }

struct node {
	int val;
	ll cnt, lcnt, rcnt;
	node *l, *r;
};

void insert(node **n, int val) {
	if(!*n) {
		*n = new node{val, 1, 0, 0, nullptr, nullptr};
	} else if(val == (**n).val) {
		(**n).cnt++;
	} else if(val < (**n).val) {
		(**n).lcnt++;
		insert(&((**n).l), val);
	} else {
		(**n).rcnt++;
		insert(&((**n).r), val);
	}
}

ll nright(node *n, int val) {
	if(!n) return 0;
	if(n->val >= val) return n->cnt + n->rcnt + nright(n->l, val);
	return nright(n->r, val);
}

void del(node *n) {
	if(!n) return;
	del(n->l);
	del(n->r);
	delete n;
}

ll solve(int f) {
	vector<station> left(lb(f), lb(f+1));
	vector<station> right(lb(f - k), lb(f+k+1));
	sort(b2e(left), [](auto a, auto b) { return a.x < b.x; });
	sort(b2e(right), [](auto a, auto b) { return a.x - a.r < b.x - b.r; });
	auto r = right.begin();
	node *n = 0;
	ll ans = 0;
	for(auto it : left) {
		while(r != right.end() && r->x - r->r <= it.x) {
			insert(&n, r->x);
			++r;
		}
		ll d = nright(n, it.x) - nright(n, it.x+it.r+1);
		ans += d;
		// for(auto y = ma; y != mb; y++) {
		// 	cerr << "match " << it.id << " " << y->second << endl;
		// }
	}
	del(n);
	return ans - left.size();
}

int main() {
	cin >> n >> k;
	s.resize(n);
	for(int i=0; i<n; i++) {
		cin >> s[i].x >> s[i].r >> s[i].f;
		s[i].id = i;
	}
	sort(&s[0], &s[n], [](auto a, auto b) { return a.f < b.f; });
	int f = 0;
	ll ans = 0;
	for(station &i : s) {
		if(i.f != f) {
			ans += solve(i.f);
			f = i.f;
		}
	}
	cout << ans << endl;
}


// Accepted

#include <iostream>
#include <string>
using namespace std;

string a, b;
int l[100000], r[100000];
int nl, nr;

void subl() {
	nl = 0;
	l[nl] = 0;
	while(1) {
		if(l[nl] == a.size()) break;
		if(a[l[nl]] == b[nl]) {
			l[nl+1] = l[nl]+1;
			++nl;
		} else {
			++l[nl];
		}
	}
}

void subr() {
	nr = 0;
	r[0] = (int)a.size() - 1;
	while(1) {
		if(r[nr] < 0) break;
		if(a[r[nr]] == b[b.size()-1-nr]) {
			r[nr+1] = r[nr]-1;
			++nr;
		} else {
			--r[nr];
		}
	}
}

int main() {
	cin >> a >> b;
	subl();
	subr();
	int mr = nr;
	while(nl && nr && l[nl-1] >= r[nr-1]) --nr;
	int bl = nl, br = nr;
	while(nr < mr) {
		++nr;
		while(nl && nr && l[nl-1] >= r[nr-1]) --nl;
		if(nl + nr > bl + br) bl = nl, br = nr;
	}
	nl = bl, nr = br;
	if(nl == 0 && nr == 0) {
		cout << "-" << endl;
	} else {
		while(nl + nr > b.size()) {
			if(nl) --nl;
			else --nr;
		}
		for(int i = 0; i < nl; i++) {
			cout << b[i];
		}
		for(int i = b.size() - nr; i < b.size(); i++) {
			cout << b[i];
		}
	}
	cout << endl;
}


#include <bits/stdc++.h>

using namespace std;

#define len(x) ((int)(x).size())
#define pb push_back
#define mp make_pair
#define debug(x) cerr << #x << " is " << x << '\n';
#define bin(x,b) bitset<b> vb(x); cout << vb << '\n';

#if ( ( _WIN32 || __WIN32__ ) && __cplusplus < 201103L)
    #define lld "%I64d"
#else
    #define lld "%lld"
#endif
#define tmax(a,b,c) max((a),max((b),(c)))
#define cmax(a,b,c,d) max((a),(tmax(a,b,c)))

typedef long long ll;
typedef pair <int,int> pi;

const long double EPS = 1e-10;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
const long double PI = 3.1415926535897932384626433832795028841;

map <string ,int> ssol;
void checkAdd(string vs){ if (ssol.find(vs) != ssol.end()){ return; } ssol[vs] = 1; }

bool TST = 0;
ll powmod(ll a,ll b) {ll res=1;a%=MOD;for(;b;b>>=1){if(b&1)res=res*a%MOD;a=a*a%MOD;}return res;}
void Show(int *QQ,int N){ if (not TST){ return; } for (int x = 0;x < N;x++){ cout << QQ[x]; if (x != N-1){ cout << ','; } } cout << '\n'; }
void ShowLL(ll *QQ,int N){ if (not TST){ return; } for (int x = 0;x < N;x++){ cout << QQ[x]; if (x != N-1){ cout << ','; } } cout << '\n'; }

const int maxn = 1e5 + 100;
const int maxf = 1e4 + 100;
const int fwmax = 1e7 + 100;

map <int , int > c; // coordinates
int x[maxn] , r[maxn] ;
vector <int> f[maxf];

ll FW[fwmax]; // fenwick

void inc(int i,ll v){
	while (i < maxn){
		FW[i] += v;
		i += i & (-i);
	}
}
ll get(int i){
	ll sol = 0;
	while (i > 0){
		sol += FW[i];
		i -= i & (-i);
	}
	return sol;
}
bool compare( pi a, pi b){
	int a_pos = a.second ? x[a.first] : x[a.first]-r[a.first];
	int b_pos = b.second ? x[b.first] : x[b.first]-r[b.first];
	if (a_pos != b_pos){
		return a_pos < b_pos;
	}
	return a.second < b.second;
}
int main(){
	int n , k; cin >> n >> k;

	vector <int> points;

	for (int i = 1;i <= n;i++){
		int freq;
		cin >> x[i] >> r[i] >> freq;
		f[freq].push_back(i);
		points.push_back(x[i]);
		points.push_back(x[i] + r[i]);
	}
	sort(points.begin(),points.end());

	int last = -1;
	int cnt = 1;
	for (int i = 0;i < points.size();i++){
		if (points[i] != last) c[points[i]] = cnt++;
		last = points[i];
	}

	ll sol = 0;
	for (int i = 1;i <= maxf;i++){ // for each freq
		//cout << "freq " << i << ": \n";
		vector <pi> Q;
		for (int j = max(1,i - k);j <= min(maxf,i + k);j++){
 			//cout << "add f " << j << '\n';
 			for (int qw = 0;qw < f[j].size();qw++){
 				if (i == j) Q.push_back( mp(f[j][qw] , 1) );
 				Q.push_back( mp(f[j][qw] , 0) );
 			}
		}

		sort( Q.begin() , Q.end() , compare);
		//cout << "qz = " << Q.size() << '\n';
		for (int j = 0;j < Q.size();j++){
			if (Q[j].second == 0){
				int p = c[x[Q[j].first]];
				inc(p , 1);
				//cout << "inc " << x[Q[j].first] << '\n';
			}
			if (Q[j].second == 1){
				int p1 = c[x[Q[j].first]];
				int p2 = c[x[Q[j].first]+r[Q[j].first]];
				//cout << p1 << ' ' << p2 << '\n';
				ll v = get(p2) - get(p1-1);
				//cout << "add " << Q[j].first << ":" << v <<  '\n';
				sol += v-1;
				//inc(p2 , 1);
			}
		}
		for (int j = 0;j < Q.size();j++){
			if (Q[j].second == 0){
				int p = c[x[Q[j].first]];
				inc(p , -1);
			}
		}

	}
	cout << sol << '\n';
}


#include <bits/stdc++.h>

using namespace std;

#define len(x) ((int)(x).size())
#define pb push_back
#define mp make_pair
#define debug(x) cerr << #x << " is " << x << '\n';
#define bin(x,b) bitset<b> vb(x); cout << vb << '\n';

#if ( ( _WIN32 || __WIN32__ ) && __cplusplus < 201103L)
    #define lld "%I64d"
#else
    #define lld "%lld"
#endif
#define tmax(a,b,c) max((a),max((b),(c)))
#define cmax(a,b,c,d) max((a),(tmax(a,b,c)))

typedef long long ll;
typedef pair <int,int> pi;

const long double EPS = 1e-10;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
const long double PI = 3.1415926535897932384626433832795028841;

map <string ,int> ssol;
void checkAdd(string vs){ if (ssol.find(vs) != ssol.end()){ return; } ssol[vs] = 1; }

bool TST = 0;
ll powmod(ll a,ll b) {ll res=1;a%=MOD;for(;b;b>>=1){if(b&1)res=res*a%MOD;a=a*a%MOD;}return res;}
void Show(int *QQ,int N){ if (not TST){ return; } for (int x = 0;x < N;x++){ cout << QQ[x]; if (x != N-1){ cout << ','; } } cout << '\n'; }
void ShowLL(ll *QQ,int N){ if (not TST){ return; } for (int x = 0;x < N;x++){ cout << QQ[x]; if (x != N-1){ cout << ','; } } cout << '\n'; }

const int maxn = 1e5 + 100;
const int maxf = 1e4 + 100;
const int fwmax = (1<<18)+1;

map <int , int > c; // coordinates
int x[maxn] , r[maxn] ;
vector <int> f[maxf];

ll FW[fwmax]; // fenwick

void inc(int i,ll v){
	while (i < fwmax){
		FW[i] += v;
		i += i & (-i);
	}
}
ll get(int i){
	ll sol = 0;
	while (i > 0){
		sol += FW[i];
		i -= i & (-i);
	}
	return sol;
}
bool compare( pi a, pi b){
	int a_pos = a.second ? x[a.first] : x[a.first]-r[a.first];
	int b_pos = b.second ? x[b.first] : x[b.first]-r[b.first];
	if (a_pos != b_pos){
		return a_pos < b_pos;
	}
	return a.second < b.second;
}
int main(){
	int n , k; scanf("%d%d",&n,&k);

	vector <int> points;

	for (int i = 1;i <= n;i++){
		int freq;
		scanf("%d%d%d",&x[i],&r[i],&freq);
		f[freq].push_back(i);
		points.push_back(x[i]);
		points.push_back(x[i] + r[i]);
	}
	sort(points.begin(),points.end());

	int last = -1;
	int cnt = 1;
	for (int i = 0;i < points.size();i++){
		if (points[i] != last) c[points[i]] = cnt++;
		last = points[i];
	}

	ll sol = 0;
	for (int i = 1;i <= maxf;i++){ // for each freq
		//cout << "freq " << i << ": \n";
		vector <pi> Q;
		for (int j = max(1,i - k);j <= min(maxf,i + k);j++){
 			//cout << "add f " << j << '\n';
 			for (int qw = 0;qw < f[j].size();qw++){
 				if (i == j) Q.push_back( mp(f[j][qw] , 1) );
 				Q.push_back( mp(f[j][qw] , 0) );
 			}
		}

		sort( Q.begin() , Q.end() , compare);
		//cout << "qz = " << Q.size() << '\n';
		for (int j = 0;j < Q.size();j++){
			if (Q[j].second == 0){
				int p = c[x[Q[j].first]];
				inc(p , 1);
				//cout << "inc " << x[Q[j].first] << '\n';
			}
			if (Q[j].second == 1){
				int p1 = c[x[Q[j].first]];
				int p2 = c[x[Q[j].first]+r[Q[j].first]];
				//cout << p1 << ' ' << p2 << '\n';
				ll v = get(p2) - get(p1-1);
				//cout << "add " << Q[j].first << ":" << v <<  '\n';
				sol += v-1;
				//inc(p2 , 1);
			}
		}
		for (int j = 0;j < Q.size();j++){
			if (Q[j].second == 0){
				int p = c[x[Q[j].first]];
				inc(p , -1);
			}
		}

	}
	printf(lld,sol);
}