/*int podajD() – zwraca wymiar swiata, w którym zyja Krotka i Entek, wyzej oznaczony przez d.
• int podajK() – zwraca liczbe mozliwych pytan czyCieplo, wyzej oznaczona przez k.
• int podajR() – zwraca dlugosc boku Hiperszesciennego Lasu, wyzej oznaczona przez r.
• int czyCieplo(int pozycja[]) – pozycja musi byc d-elementowa*
tablica liczb calkowitych z przedzialu
[0, r], oznaczajaca aktualna pozycje Entka. Ta funkcja zawsze zwraca 0 lub 1. Podczas dzialania
programu mozna wywolac ja co najwyzej k razy. Przy pierwszym wywolaniu funkcja zwraca wartosc 0.
Przy kazdym kolejnym wywolaniu zwraca wartosc 1 wtedy i tylko wtedy, gdy aktualna pozycja Entka
jest blizsza pozycji Krotki niz jego pozycja przy poprzednim wywolaniu.
• void znalazlem(int pozycja[]) – pozycja musi byc d-elementowa tablica liczb calkowitych z przedzialu
[0, r] oznaczajaca odnaleziona pozycje Krotki. Funkcja ta m*/
#include "cielib.h"
#include <vector>

struct Node{
	int beg;
	int end;
};

std::vector<Node> initNodes(int d, int r){
	std::vector<Node> res;
	res.resize(d);
	for(int i=0; i<d; ++i){
		res[i].beg = 0;
		res[i].end = r+1;
	}
	return res;
}

std::pair<int, int> gratest_diff(std::vector<Node>& nodes){
	int pos = -1, diff = -1;
	for(int i=0; i<nodes.size(); ++i){
		int temp = nodes[i].end - nodes[i].beg;
		if ( temp > diff ) {
			pos = i; diff = temp; 
		}
	}
	return std::pair<int, int> (pos, diff);
}

std::vector<int> middle_vec(std::vector<Node>& nodes){
	std::vector<int> res;
	res.resize(nodes.size());
	for(int i=0; i<nodes.size(); ++i){
		res[i] = (nodes[i].beg + nodes[i].end)/2;
	}
	return res;
}

std::vector<int> bottom_corner(std::vector<Node>& nodes){
	std::vector<int> res;
	res.resize(nodes.size());
	for(int i = 0; i < nodes.size(); ++i){
		res[i] = nodes[i].beg;
	}
	return res;
}

std::vector<int> upper_corner(std::vector<Node>& nodes){
	std::vector<int> res;
	res.resize(nodes.size());
	for(int i=0; i<nodes.size(); ++i){
		res[i] = nodes[i].end-1;
	}
	return res;
}

std::vector<Node> get_small_cube(std::vector<Node>& nodes){
	auto dif_data = gratest_diff(nodes);
	int i = dif_data.first;
	int diff = dif_data.second;
	if ( diff <= 2 ) {
		return nodes;
	}
	else{
		std::vector<int> midd = middle_vec(nodes);
		std::vector<int> bottom = midd;
		std::vector<int> up = midd;
		bottom[i] = nodes[i].beg;
		up[i] = (nodes[i].end-1);
		
		czyCieplo(bottom.data());
		
		int bottom_up = czyCieplo(up.data()); 
		int up_down = czyCieplo(bottom.data());
		
		if( bottom_up == 1 ){
			nodes[i].beg = midd[i];
			return get_small_cube(nodes);
		}
		else if (up_down == 1) {
			nodes[i].end = midd[i];
			return get_small_cube(nodes);
		}
		else{
			if(diff%2 == 1){
				nodes[i].beg = midd[i];
				nodes[i].end = midd[i]+1;
				return get_small_cube(nodes);
			}
			else{
				nodes[i].beg = midd[i] - 1;
				nodes[i].end = midd[i] + 1;
				return get_small_cube(nodes);
			}
		}
	}
}

std::vector<int> be_precise (std::vector<Node> nodes, int r) {
	//tu moze byc blad kiedy przypadkiem trafilismy w to co trzeba
	std::vector<int> b_corner = bottom_corner(nodes);
	std::vector<int> u_corner = upper_corner(nodes);
	
	
	czyCieplo(b_corner.data());
	int a = czyCieplo(u_corner.data());
	int b = czyCieplo(b_corner.data());
	if(a==1 || b==1){
		if(a==1){
			return u_corner;
		}
		else{
			return b_corner;
		}
	}
	
	std::vector<int> res;
	res.resize(nodes.size());
	for (int i = 0; i<nodes.size(); ++i) {
		int beg = nodes[i].beg;
		int end = nodes[i].end;
		if ( end-beg == 1 ){
			res[i] = beg;
			continue;
		}
		if (beg > 0) {
			std::vector<int> help = b_corner;
			help[i] = beg - 1;
			czyCieplo(help.data());
			if(czyCieplo(b_corner.data()) == 1){
				res[i] = beg + 1;
			}
			else{
				res[i] = beg;
			}
		}
		else if(end < r){
			std::vector<int> help = u_corner;
			help[i] = end;
			czyCieplo(help.data());
			if(czyCieplo(u_corner.data())){
				res[i] = beg;
			}
			else{
				res[i] = beg+1;
			}
		}
		else {
			throw 1;
		}
	}
	return res;
}

int main() {
        int d = podajD();
		int k = podajK();
		int r = podajR();

		std::vector<Node> nodes = initNodes(d, r);
		
		nodes = get_small_cube(nodes);
		std::vector<int> res = be_precise(nodes, r+1);
		znalazlem(res.data());
		return 0;
}