#define _CRT_SECURE_NO_WARNINGS

//cieplo-zimno
#include <cstdio>
#include <stdio.h>
#include <iostream>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <vector>
#include "cielib.h"

typedef long long lLong;
typedef unsigned long uLong;
typedef unsigned long long ulLong;
typedef unsigned int uInt;
typedef unsigned char Byte;

using namespace std;

#define FOR(x, b, e) for(int x=b; x<=(e); ++x)
#define ALL(i) (i).begin(), (i).end()
#define CONTAINS(i,v) (find(ALL(i),v)!=(i).end())
typedef vector<bool> bit_vector;
typedef vector<int> int_vector;
typedef vector<ulLong> VI;
typedef vector<ulLong> VLL;


#define MAX_D 500

class Wymiar
{

public:
	Wymiar()
	{
		Poczatek = 0;
		Koniec = 0;
		OstatnieCieplo = -1;
		CzyKoniec = false;	
	}	
	int Poczatek;
	int Koniec;
	int OstatnieCieplo;
	bool CzyKoniec;

	int WyznaczSrodek(int kierunek)
	{
		if (Poczatek >= Koniec)
		{
			CzyKoniec = true;
			return Poczatek;
		}
		if(kierunek>0)
			return (Poczatek + Koniec + 1 ) / 2;
		else 
			return (Poczatek + Koniec) / 2;
	}
};

class PrzypadekTestowy
{
private:
	int _d, _k, _r;		
	int _wynik[MAX_D];
	Wymiar _wymiary[MAX_D];
	bool _globalFinish;
public:	
	inline void Wykonaj()
	{		
		_globalFinish = false;
		WczytajPrzypadekTestowy();
		Wyszukaj();
		WypiszWynik();
	}

	inline void UstawPoSrodku()
	{
		for (int i = 0; i < _d; i++)
		{
			_wynik[i] = _wymiary[i].WyznaczSrodek(1);
		}
	}
	inline int PobierzMaxSzerokosc()
	{
		int result = 0;
		for (int i = 0; i < _d; i++)
		{
			if (_wymiary[i].CzyKoniec) continue;
			result = max(result, _wymiary[i].Koniec - _wymiary[i].Poczatek);
		}		
		return result;
	}

	inline bool DokonczWyszukiwanie(int startIdx)
	{
		if (_globalFinish) return true;
		if (_wymiary[startIdx].CzyKoniec)
		{			
			return (startIdx + 1 >= _d)
				? false
				: DokonczWyszukiwanie(startIdx + 1);
		}
		/*for (int i = startIdx+1; i < _d; i++)
		{
			if (i == startIdx || _wymiary[i].CzyKoniec) continue;
			if (DokonczWyszukiwanie(i))	return true;
		}
*/
		_wynik[startIdx] = (_wynik[startIdx] == _wymiary[startIdx].Poczatek)
			? _wymiary[startIdx].Koniec
			: _wymiary[startIdx].Poczatek;
		if (SprawdzCzyCieploOstatni()) return true;

		if (startIdx+1 < _d) return DokonczWyszukiwanie(startIdx + 1);

		_wynik[startIdx] = (_wynik[startIdx] == _wymiary[startIdx].Poczatek)
			? _wymiary[startIdx].Koniec
			: _wymiary[startIdx].Poczatek;
		if (SprawdzCzyCieploOstatni()) return true;

		if (startIdx+1 < _d) return DokonczWyszukiwanie(startIdx + 1);		
		
		return false;
	}
	inline bool SprawdzCzyCieploOstatni()
	{
		if (czyCieplo(_wynik))
		{
			return true;
			for (int i = 0; i < _d; i++)
			{
				_wymiary[i].CzyKoniec = true;
			}
			_globalFinish = true;
		}
		return false;
	}
	inline void Wyszukaj()
	{		
		bool isOver = false;
		int kierunek = 1;

		//1. Ustaw wszystkie punkty na środku - tak aby dla każdego wymiaru można było osiągnąć ekstremum
		UstawPoSrodku();
		
		//2. wywołanie inicjujące - teraz max odległość wynosi 1/2 R
		czyCieplo(_wynik); //wywolanie inicjalizujace w punkcie 0n

		//3. Dla każdebo wymiaru szukamy w której połówce znajduje się punkt w tym wymiarze
		int licznik = 1;
		int maxSzerokosc = 0;
		while(!isOver && licznik<=_k)
		{			
			if (maxSzerokosc == 1)
			{
				if (!DokonczWyszukiwanie(0))
				{
					DokonczWyszukiwanie(0);
				}
				break;
			}
			isOver = true;
			maxSzerokosc = 0;
			for (int i = 0; i < _d; i++)
			{
				int srodek = _wynik[i];				
				if (_wymiary[i].CzyKoniec) continue;

				_wynik[i] = _wymiary[i].Poczatek;
				isOver = false;
				//a. Jeśli dla krańcowej (początkowej) wartości czyCieplo zwroci prawde, to znaczy, że punkt jest 
				//w przedziale 
				maxSzerokosc=max(maxSzerokosc,_wymiary[i].Koniec -_wymiary[i].Poczatek);
				if (czyCieplo(_wynik))
				{						
					_wymiary[i].Koniec = srodek;					
				}
				else
				{
					_wynik[i] = _wymiary[i].Koniec;
					if (czyCieplo(_wynik))
					{						
						_wymiary[i].Poczatek = srodek;						
					}
					else
					{						
						_wymiary[i].Koniec = srodek;												
					}
					licznik++;
				}
				//ustawienie w trefie w której różnica |p-x| będzie mniejsza od 1/2 szerokości aktualnego przedziału
				_wynik[i] = _wymiary[i].WyznaczSrodek(1);				
				czyCieplo(_wynik); 
				licznik++;
			}			
		}	
	}
	inline void WypiszWynik()
	{
		znalazlem(_wynik);
	}
	inline void WczytajPrzypadekTestowy()
	{
		_d = podajD();
		_k = podajK();
		_r = podajR();
		memset(_wynik, 0, sizeof(_wynik));
		for (int i = 0; i < _d; i++)
		{
			_wymiary[i].Koniec = _r;
		}
	}
};

int main(int argc, char **argv)
{
	PrzypadekTestowy *p = new PrzypadekTestowy();
	p->Wykonaj();	
	delete(p);
	return 0;
}