#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:


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

using state = struct {
	set<int> held_days[CONTEST_TYPE];
	int type[365];
	int score;
};

void input() {
	cin >> D;

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

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

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_type(const state &cur, int type_a, int type_b) {
	const int type_a_idx = type_a - 1;
	const int type_b_idx = type_b - 1;

	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]);
	return ret;
}

state swap_days(const state &cur, int day_a, int day_b) {
	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;
	}
} 


int main(void){
	input();
	const state greedy_init = greedy_solution();
	output(greedy_init);
	return 0;
}

Measured memory_bytes: 3692