#include <bits/stdc++.h>
#include <sys/types.h>
#include <unistd.h>

#define _overload(_1,_2,_3,name,...) name
#define _rep(i,n) _range(i,0,n)
#define _range(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload(__VA_ARGS__,_range,_rep,)(__VA_ARGS__)

#define _rrep(i,n) _rrange(i,n,0)
#define _rrange(i,a,b) for(int i=int(a)-1;i>=int(b);--i)
#define rrep(...) _overload(__VA_ARGS__,_rrange,_rrep,)(__VA_ARGS__)

#define _all(arg) begin(arg),end(arg)
#define uniq(arg) sort(_all(arg)),(arg).erase(unique(_all(arg)),end(arg))
#define getidx(ary,key) lower_bound(_all(ary),key)-begin(ary)
#define clr(a,b) memset((a),(b),sizeof(a))
#define bit(n) (1LL<<(n))
#define popcount(n) (__builtin_popcountll(n))

using namespace std;

template<class T>bool chmax(T &a, const T &b) { return (a<b)?(a=b,1):0;}
template<class T>bool chmin(T &a, const T &b) { return (b<a)?(a=b,1):0;}

using ll=long long;
using R=long double;
const R EPS=1e-9L; // [-1000,1000]->EPS=1e-8 [-10000,10000]->EPS=1e-7
inline int sgn(const R& r){return(r > EPS)-(r < -EPS);}
inline R sq(R x){return sqrt(max(x,0.0L));}

template<typename T> vector<T> make_vector(size_t sz){
	return vector<T>(sz);
}

template<typename T,typename... Ts> 
auto make_vector(size_t sz, Ts... ts){
	return vector<decltype(make_vector<T>(ts...))>(sz, make_vector<T>(ts...));
}

template<typename T,typename U,typename... V> 
typename enable_if<is_same<T, U>::value!=0>::type 
fill_value(U &u, const V... v){
	u=U(v...);
}

template<typename T,typename U,typename... V>
typename enable_if<is_same<T, U>::value==0>::type
fill_value(U &u, const V... v){
	for(auto &e:u){
		fill_value<T>(e,v...);
	}
}

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

const pid_t pid = getpid();
// Problem Specific Parameter:


class Timer {
private:
	chrono::high_resolution_clock::time_point start_time;
	chrono::high_resolution_clock::time_point elapsed;

public:
	Timer() {}
	void start() { start_time = chrono::system_clock::now();}
	double get_elapsed() {
		elapsed = chrono::system_clock::now();
		return chrono::duration_cast<std::chrono::milliseconds>(elapsed - start_time).count();
	}
};

mt19937 mt;

// Problem Specific Parameter:
using pii = pair<int,int>;
vector<pii> swap_days_ary;
uniform_int_distribution<int> swap_days_rnd;
vector<pii> swap_types_ary;
uniform_int_distribution<int> swap_types_rnd;


const int CONTEST_TYPE = 26;
int D;
int c[CONTEST_TYPE], s[365][CONTEST_TYPE];

struct State {
	set<int> held_days[CONTEST_TYPE];
	int type[365];
	int score;

	bool operator<(const State &another) const
	{
		return score < another.score;
	};

	bool operator>(const State &another) const
	{
		return score > another.score;
	};
};

void input() {
	cin >> D;

	rep(i, CONTEST_TYPE) {
		cin >> c[i];
	}

	rep(i, D) rep(j, CONTEST_TYPE) {
		cin >> s[i][j];
	}

	{
		rep(i, 1, D + 1) rep(j, i + 1, D + 1) {
			swap_days_ary.push_back(pii(i, j));
		}
		const int M = swap_days_ary.size();
		swap_days_rnd = uniform_int_distribution<int>(0, M - 1);
	}

	{
		rep(i, 1, CONTEST_TYPE + 1) rep(j, i + 1, CONTEST_TYPE + 1) {
			swap_types_ary.push_back(pii(i, j));
		}
		const int M = swap_types_ary.size();
		swap_types_rnd = uniform_int_distribution<int>(0, M - 1);
	}
}

State calc_init(const vector<int> &type) {
	const int DAY = type.size();
	vector<int> last(CONTEST_TYPE, 0);

	State ret;
	ret.score = 0;
		
	rep(j, CONTEST_TYPE) {
		ret.held_days[j].insert(0);
		ret.held_days[j].insert(D + 1);
	}

	rep(i, DAY) {
		const int day = i + 1;
		const int type_idx = type[i] - 1;

		ret.held_days[type_idx].insert(day);
		ret.type[i] = type_idx;
		ret.score += s[i][type_idx];

		last[type_idx] = day;

		rep(j, CONTEST_TYPE) {
			ret.score -= c[j] * max(day - last[j], 0);
		}
	}

	return ret;
}

State modity(const State &cur, int day, int query) {
	const int day_idx = day - 1;
	const int q_idx = query - 1;
	State ret = cur;

	{
		const int cur_type = ret.type[day_idx];
	
		const auto it = ret.held_days[cur_type].lower_bound(day);
		const auto before_it = prev(it);
		const auto after_it = next(it);
	
		ret.score -= c[cur_type] * (*it - *before_it) * (*after_it - *it);
		ret.score -= s[day_idx][cur_type];
		ret.type[day_idx] = -1;
		ret.held_days[cur_type].erase(it);
	}

	{
		const int next_type = q_idx;
		ret.type[day_idx] = next_type;
		ret.held_days[next_type].insert(day);

		const auto it = ret.held_days[next_type].lower_bound(day);
		const auto before_it = prev(it);
		const auto after_it = next(it);

		ret.score += c[next_type] * (*it - *before_it) * (*after_it - *it);
		ret.score += s[day_idx][next_type];
	}

	return ret;
}


State swap_types(const State &cur, const pii &types) {

	const int type_a_idx = types.first - 1;
	const int type_b_idx = types.second - 1;
	cerr << type_a_idx << " " << type_b_idx << endl;


	State ret = cur;

	for(auto &type_idx: {type_a_idx, type_b_idx}){
		int prev_day = 0;
		const int alt_type_idx = type_a_idx ^ type_b_idx ^ type_idx;
		for(auto &day: ret.held_days[type_idx]) {
			const int day_idx = day - 1;
			if(0 <= day_idx and day_idx < D) {
				ret.score += (s[day_idx][alt_type_idx] - s[day_idx][type_idx]);
			}

			const int duration = day - prev_day;
			ret.score += (c[alt_type_idx] - c[type_idx]) * (duration * (duration - 1) / 2);
			prev_day = day;
		}
	}

	swap(ret.held_days[type_a_idx], ret.held_days[type_b_idx]);
	cerr << type_a_idx << " " << type_b_idx << endl;
	return ret;
}

State swap_days(const State &cur, const pii &days) {
	const int day_a = days.first;
	const int day_b = days.second;

 	const int day_a_idx = day_a - 1;
	const int day_b_idx = day_b - 1;

	const int type_a = cur.type[day_a_idx] + 1;
	const int type_b = cur.type[day_b_idx] + 1;

	const State tmp = modity(cur, day_a, type_b);
	const State ret = modity(tmp, day_b, type_a);

	return ret;
}

State greedy_solution() {
	vector<int> type(D, 1);

	vector<int> last(CONTEST_TYPE, 0);
	int score = 0;

	rep(i, D) {
		const int day = i + 1;
		rep(j, CONTEST_TYPE) {
			score -= c[j] * max(day - last[j], 0);
		}

		int cmax = score;

		rep(j, CONTEST_TYPE) {
			int nscore = score;
			nscore += s[i][j];
			nscore += c[j] * max(day - last[j], 0);
			if(chmax(cmax, nscore)) {
				type[i] = j + 1;
			}
		}

		score = cmax;
		last[type[i] - 1] = day;
	}

	return calc_init(type);
}

void output(const State &cur) {
	rep(i, D) {
		cout << cur.type[i] + 1 << endl;
	}
} 

State simulation(const R duration){

	State best_state;
	State cur_state;

	uniform_real_distribution<R> R_rand(0.0,1.0);

	const R startTemp = 0.1;
	const R endTemp = 0.0001;


	best_state = cur_state =  greedy_solution();

	Timer timer;
	timer.start();

	const R saTimeStart = 0.0;
	const R saTimeEnd = duration;
	R saTimeCurrent = saTimeStart;

	while ((saTimeCurrent = timer.get_elapsed()) < saTimeEnd){
		{
			const int pos = swap_days_rnd(mt);
			State next_state = swap_days(cur_state, swap_days_ary[pos]);

			const R T = duration;
			const R t = saTimeCurrent-saTimeStart;
			const R temp = startTemp + (endTemp - startTemp) * t / T;
			const R probability = exp((cur_state.score - next_state.score) / temp);
			const bool FORCE_NEXT = probability > R_rand(mt);

			if(cur_state < next_state || FORCE_NEXT){
				cur_state = next_state;
				// cerr << "Cur: " << cur_state.score << " " << t  << endl;
			}

			if(chmax(best_state, cur_state)){
				cerr << "Best: " << best_state.score << " " << t  << endl;
			}
		}

		// {
		// 	const int pos = swap_types_rnd(mt);
		// 	State next_state = swap_types(cur_state, swap_types_ary[pos]);

		// 	const R T = duration;
		// 	const R t = saTimeCurrent-saTimeStart;
		// 	const R temp = startTemp + (endTemp - startTemp) * t / T;
		// 	const R probability = exp((cur_state.score - next_state.score) / temp);
		// 	const bool FORCE_NEXT = probability > R_rand(mt);

		// 	if(cur_state < next_state || FORCE_NEXT){
		// 		cur_state = next_state;
		// 		// cerr << "Cur: " << cur_state.score << " " << t  << endl;
		// 	}

		// 	if(chmax(best_state, cur_state)){
		// 		cerr << "Best: " << best_state.score << " " << t  << endl;
		// 	}
		// }
	}

	return best_state;
}



int main(void){
	input();
	const R duration = 1900.0;
	const State best_state = simulation(duration); 
	output(best_state);
	return 0;
}

Measured memory_bytes: 4500