#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <list>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include "cielib.h"

//int d_v, k_v, r_v;
//
//void init(void);
//
//int podajD(void) {
//	init();
//
//	return d_v;
//}
//
//int podajK(void) {
//	init();
//
//	return k_v;
//}
//
//int podajR(void) {
//	init();
//
//	return r_v;
//}
//
//int pos[500];
//
//void init(void) {
//	static int initialized = -1;
//	if (initialized != -1) {
//		return;
//	}
//	initialized = 1;
//
//	printf("Podaj d: ");
//	scanf("%d", &d_v);
//	printf("Podaj k: ");
//	scanf("%d", &k_v);
//	printf("Podaj r: ");
//	scanf("%d", &r_v);
//
//	printf("Podaj pozycje Krotki:\n");
//	for (int i = 0; i < podajD(); ++i) {
//		scanf("%d", &pos[i]);
//	}
//}
//
//int call = 0;
//
//int czyCieplo(int answer[]) {
//	init();
//
//	call += 1;
//	if (call > podajK()) {
//		printf("Przekroczono limit k = %d.", k_v);
//		exit(1);
//	}
//
//	static int ldiff = -1;
//	int diff = 0;
//
//	for (int d, i = 0; i < podajD(); ++i) {
//		d = pos[i] - answer[i];
//		d = (d<0) ? -d : d;
//
//		diff = (d > diff) ? d : diff;
//	}
//
//	const int result = (diff < ldiff) ? 1 : 0;
//	ldiff = diff;
//
//	return result;
//}
//
//void znalazlem(int answer[]) {
//	init();
//
//	printf("Podano:\n");
//	for (int i = 0; i < podajD(); ++i) {
//		printf("%d%c", pos[i], (i + 1 == podajD()) ? '\n' : ' ');
//	}
//
//	int k = 1;
//	for (int i = 0; i < podajD(); ++i) {
//		if (answer[i] != pos[i]) {
//			printf("NIE %d na %d!\n", answer[i], i);
//			k = -1;
//		}
//	}
//
//	if (k == 1) {
//		printf("OK --- %d zapytan\n", call);
//	}
//
//	exit(0);
//}



using namespace std;

#define FOR(i,n) for(int i=0;i<n;++i)
#define FORB(i,b,n) for(int i=b;i<n;++i)
#define REV(i,n) for(int i=n;i>=0;--i)
#define FOREACH(T, it, v) for(T::iterator it = v.begin(); it !=v.end(); ++it)

typedef unsigned int u32;
typedef unsigned int uint;
const int INF = (0u - 11) / 2;

typedef long long ll;
typedef set<int> SI;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef set<long long> SL;
typedef map<int, int> MII;



int DEBUG = 1;

#define print(STRING,INT) printf("%s= %d\n", STRING, INT)

#define scan(INT) scanf("%d", &INT)


void log(char* S, int a)
{
	if (DEBUG)
	{
		print(S, a);
	}
}

const int MAX_SHORT = 65536;

const int MEMORY_SECTOR_SIZE = 1000012;





int Win[MEMORY_SECTOR_SIZE];
int Draw[MEMORY_SECTOR_SIZE];

void zadanieKAR()
{
	int N, M;
	int a, b;
	char c;
	bool win = false;
	scan(N);
	scan(M);
	FOR(i, N + 1)
	{
		Win[i] = 0;
		Draw[i] = 0;
	}
	FOR(i, M)
	{
		scanf("%d %c %d", &a, &c, &b);
		if (c == '>')
		{
			Win[b]++;
			if (Win[b] == N)
			{
				win = true;
			}
		}
		else
		{
			Draw[b]++;
		}
	}
	if (win)
	{
		printf("WYGRANA\n");
		return;
	}
	FORB(i, 1, N + 1)
	{
		if (Draw[i] == 0)
		{
			printf("REMIS\n");
			return;
		}
	}
	printf("PRZEGRANA\n");
}

void zadanie2B()
{
	int n;
	int tab[132];
	int len = 0;
	scan(n);
	if (n == 1)
	{
		printf("1\n");
		return;
	}
	while (n > 0)
	{
		tab[len++] = n & 1;
		n >>= 1;
	}
	string S;
	string for1 = "*(1+(1+1)";
	string for0 = "*(1+1)";
	if (tab[0] == 1)
	{
		S = "1+(1+1)";
	}
	else
	{
		S = "(1+1)";
	}
	int bracketToClose = 0;
	FORB(i, 1, len - 1)
	{
		if (tab[i] == 1)
		{
			S += for1;
			bracketToClose++;
		}
		else
		{
			S += for0;
		}
	}
	FOR(i, bracketToClose)
	{
		S += ")";
	}
	printf("%s\n", S.c_str());
}

int main1A()
{
	//int nodes = NumberOfNodes();
	int n;
	scan(n);
	FOR(i, n)
	{
		zadanieKAR();
	}
	//printf("%d\n", out);
	return 0;
}

int main1B()
{
	int n;
	int t;
	scan(n);
	n = 1 << n;
	scan(t);
	vector<int> V(n, 0);
	FOR(i, n)
	{
		scan(V[i]);
	}
	if (t & 0x1)
	{
		std::reverse(V.begin(), V.end());
	}
	FOR(i, n)
	{
		printf("%d ", V[i]);
	}
	printf("\n");
	return 0;
}

int main2B()
{
	int n;
	scan(n);
	FOR(i, n)
	{
		zadanie2B();
	}
	return 0;
}

int main2A_V1()
{
	int n;
	int m;
	scan(n);
	scan(m);

	int a, b;
	char c;
	const int MAX_N = 5; //1002;
	VI followers(MAX_N, 0);
	VVI like(MAX_N, VI(MAX_N, 0));
	VVI likeLists(MAX_N, VI());
	VVI dislike(MAX_N, VI(MAX_N, 0));
	VVI dislikeLists(MAX_N, VI());
	FOR(i, m)
	{
		scanf("%d %d %c", &a, &b, &c);
		a--;
		b--;
		if (c == 'T')
		{
			like[a][b] = 1;
			likeLists[a].push_back(b);
			followers[b]++;
		}
		else
		{
			dislike[a][b] = 1;
			dislikeLists[a].push_back(b);
		}
	}
	//spread hate
	VI Q;
	int iter = 0;
	FOR(i, n)
	{
		if (followers[i] == 0)
		{
			Q.push_back(i);
		}
	}

	int source;
	int target;
	while (iter < Q.size())
	{
		source = Q[iter];
		FOREACH(VI, it, likeLists[Q[iter]])
		{
			target = *it;
			FOREACH(VI, it, dislikeLists[Q[iter]])
			{
				if (dislike[target][*it] == 0)
				{
					dislike[target][*it] = 1;
					dislikeLists[target].push_back(*it);
				}
			}
			followers[target]--;
			if (followers[target] == 0)
			{
				Q.push_back(target);
			}
		}
		iter++;
	}
	if (iter != n)
	{
		printf("NIE\n");   //pokazuja na siebie
	}
	FOR(i, n)
	{
		FOR(j, n)
		{
			if (dislike[i][j] == 1 && like[i][j] == 1)
			{
				printf("NIE\n");
			}
		}
	}

	//printf("\n");
	return 0;
}

int main2A()
{
	int n;
	int m;
	scan(n);
	scan(m);

	int a, b;
	char c;
	//const int MAX_N = 5; //1002;
	const int MAX_N = 1002;
	VI boss(MAX_N, -2);
	VI used(MAX_N, 0);
	VI followers(MAX_N, 0);
	VI hejters(MAX_N, 0);
	VVI like(MAX_N, VI(MAX_N, 0));
	VVI likeLists(MAX_N, VI());
	VVI followedByLists(MAX_N, VI());
	VVI dislike(MAX_N, VI(MAX_N, 0));
	VVI dislikeLists(MAX_N, VI());
	FOR(i, m)
	{
		scanf("%d %d %c", &a, &b, &c);
		a--;
		b--;
		if (c == 'T')
		{
			like[a][b] = 1;
			likeLists[a].push_back(b);
			followers[b]++;
			dislike[b][a] = 1;
			dislikeLists[b].push_back(a);
			followedByLists[b].push_back(a);
			hejters[a]++;
	//		printf("Like\n");
		}
		else
		{
			dislike[a][b] = 1;
			dislikeLists[a].push_back(b);
			hejters[b]++;
	//		printf("Hate\n");
		}
	}
	int currentBoss = -1;
//	printf("Find boss\n");
	int assigned = 0;
	FOR(i, n)
	{
		if (hejters[i] == 0)
		{
			boss[i] = currentBoss;
			assigned++;
			used[i] = 1;
			currentBoss = i;
	//		printf("Dodal Bossa %d pod %d\n", i, boss[i]);
			FOR(j, n)
			{
				if (dislike[currentBoss][j] == 1)
				{
					dislike[currentBoss][j] = 0;
					hejters[j]--;
				}
			}
		}
	}
//	printf("assigned bossow %d\n", assigned);
	if (assigned == 0)
	{
		printf("NIE\n");
		return 0;
	}
	FOR(i, n)
	{
		if (used[i] == 0)
		{
			boss[i] = currentBoss;
		}
	}

	int i = 0;
	while (i < n)
	{
		if (used[i] == 0)
		{
	//		printf("pool dla %d\n", i);
			currentBoss = boss[i];
			VI pool(MAX_N, 0);
			VI poolList(1, i);
			pool[i] = 1;
			int iter = 0;
			while (iter < poolList.size())
			{
				int source = poolList[iter];
				//add followed
				FOREACH(VI, it, likeLists[source])
				{
					int target = *it;
					if (used[target] == 0 && boss[target] == boss[i] && pool[target] == 0)
					{
						poolList.push_back(target);
						pool[target] = 1;
					}
				}
				//add who follow
				FOREACH(VI, it, followedByLists[source])
				{
					int target = *it;
					if (used[target] == 0 && boss[target] == boss[i] && pool[target] == 0)
					{
						poolList.push_back(target);
						pool[target] = 1;
					}
				}
				iter++;
			}
			int poolSize = poolList.size();
			//recalculate Haters rate
			FOR(j, poolSize)
			{
				hejters[poolList[j]] = 0;
			}
			FOR(j, poolSize)
			{
				int iter = 0;
				int source = poolList[j];
				int size = dislikeLists[source].size();
				while (iter < size)
				{
					//nie z puli, nie ma znaczenia
					if (pool[dislikeLists[source][iter]] == 0)
					{
						swap(dislikeLists[source][iter], dislikeLists[source][size - 1]);
						dislikeLists[source].pop_back();
						size--;
					}
					else
					{
						hejters[dislikeLists[source][iter]]++;
						iter++;
					}
				}
			}
			VI Queue;
			iter = 0;
			FOR(j, poolSize)
			{
				if (hejters[poolList[j]] == 0)
				{
					Queue.push_back(poolList[j]);
				}
			}
			if (Queue.size() == 0)
			{
				printf("NIE\n");
				return 0;
			}
			while (iter < Queue.size())
			{
				int current = Queue[iter];
				boss[current] = currentBoss;
				assigned++;
				//printf("assign %d\n", current);
				used[current] = 1;
				currentBoss = current;

				//FOREACH(VI, it, dislike[current])
				//{
				//	//nie z puli, nie ma znaczenia
				//	if (pool[dislike[j][iter]] == 0)
				//	{
				//		swap(dislike[j][iter], dislike[j][size - 1]);
				//		dislike[j].pop_back();
				//		size--;
				//	}
				//	else
				//	{
				//		hejters[dislike[j][iter]]++;
				//		iter++;
				//	}
				//}
				iter++;
			}
			FOR(j, poolSize)
			{
				if (used[poolList[j]] == 0)
				{
					boss[poolList[j]] = currentBoss;
				}
			}
		}
		if (used[i] == 1)
		{
			i++;
		}
		else
		{
//			printf("tried %d\n", i);
		}
	}
//	printf("WHY, WTF %d %d\n", assigned, n);
	if (assigned != n)
	{
	//	printf("WHY, WTF %d %d\n", assigned, n);
	//	return 0;
	}
	FOR(i, n)
	{
		printf("%d\n", boss[i] + 1);
	}
	//FOR(i, n)
	//{
	//	if (used[i] == 0)
	//	printf("nie uzyty %d\n", i);
	//}
//	printf("TAK\n");
	return 0;
}

int main3B()
{
	int R = podajR();
	int D = podajD();
	VI min(D, 0);
	VI max(D, R);
	VI found(D, 0);
	int toBeFound = D;
	int current[1000];
	set<int> kolejka;
	FOR(i, D)
	{
		current[i] = R / 2;
		kolejka.insert((max[i] - min[i]) * 1000 + i);
	}
	while (!kolejka.empty())
	{
		set<int>::reverse_iterator iter = kolejka.rbegin();
		int i = (*iter) % 1000;
		kolejka.erase(*iter);
		current[i] = min[i];
		czyCieplo(current);
		current[i] = max[i];
		bool a = czyCieplo(current);
		current[i] = min[i];
		bool b = czyCieplo(current);
		int range = max[i] - min[i];
		int srodek = (max[i] + min[i]) / 2;
		if (a)
		{
			min[i] = srodek + 1;
		}
		else if (b)
		{
			max[i] = srodek;
			if ((range & 1) == 0)
			{
				max[i]--;
			}
		}
		else
		{
			if ((range & 1) == 0)
			{
				current[i] = srodek;
				toBeFound--;
				found[i] = 1;
				continue;
			}
			min[i] = srodek;
			max[i] = srodek + 2;
		}
		range = max[i] - min[i];
		if (range == 0)
		{
			current[i] = min[i];
			toBeFound--;
			found[i] = 1;
			continue;
		}
		if (range == 1)
		{
			if (max[i] < R) max[i]++;
			else min[i]--;
		}
			current[i] = (max[i] + min[i]) / 2;
			kolejka.insert((max[i] - min[i]) * 1000 + i);
	}
	znalazlem(current);
	return 0;
}

int main()
{
	main3B();
	return 0;
}