#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);++i)
#define ALL(A) A.begin(), A.end()
#define SUBMIT 1

using namespace std;

typedef long long ll;
typedef pair<int, int> P;

#if !SUBMIT
const double TIME_LIMIT = 1.96 * 2.0;
const int64_t CYCLES_PER_SEC = 2000000000;	// for Local
//const int64_t CYCLES_PER_SEC = 2400000000;	// for server
#else
const double TIME_LIMIT = 1.96;
const int64_t CYCLES_PER_SEC = 2800000000;	// for SUBMIT
#endif

unsigned Rand(){ 
	static unsigned x=123456789;
	static unsigned y=362436069;
	static unsigned z=521288629;
	static unsigned w=88675123; 
	unsigned t=x^(x<<11);
	x=y; y=z; z=w;

	return w=(w^(w>>19))^(t^(t>>8));
}

struct Timer {
	int64_t start;
	int counter;
	double t;

	Timer() {
		reset();
	}

	void plus(double a){
		start -= a * CYCLES_PER_SEC;
	}

	int64_t getCycle() {
		uint32_t low, high;
		__asm__ volatile ("rdtsc" : "=a" (low), "=d" (high));
		return ((int64_t)low) | ((int64_t)high << 32);
	}

	void reset(){
		counter = 0;
		start = getCycle();
		t = 0.0;
	}

	double get(){
		return t = (double)(getCycle() - start) / CYCLES_PER_SEC;
	}
};

class IHC{
public:
	vector<int> solve(int _D, vector<int> _c, vector<vector<int>> _s){
		init(_D,_c,_s);

		out = geneRes();
		ll score = calcScore(out);
		bestScore = score;
        int iter = 0;
        int restore = 0;

		while((currentTime = timer.get()) < TIME_LIMIT){
			int day = (Rand() % D) + 1;
			int post = Rand() % 26;
			int prev = out[day];
            ll diff = diffScore(day, post);
			score += diff;
			if (score >= bestScore){
				bestScore = score;
			}else{ // restore
				score -= diff;
				out[day] = prev;
				st[post].erase(day);
				st[prev].insert(day);
                restore++;
			} // end if
            iter++;
		} // end while
		cerr << "iter: " << iter << " ratio: " << (double)restore / (double)iter * 100.0 << " bestScore: " << bestScore << endl;

		return makeSolution(out);
	}
		
private:

	Timer timer;
	double startTime;
	double endTime;
	double currentTime;

	int D;
	vector<int> c;
	vector<vector<int>> s;
	vector<int> out;

	vector<int> last;
	set<int> st[26];
	vector<int> sat;

	ll bestScore;

	ll diffScore(int day, int post){
		int prev = out[day];
		st[prev].erase(day);

		auto itrp = st[prev].lower_bound(day);
		auto itrq = st[post].lower_bound(day);
		int rp = *itrp, rq = *itrq;
		itrp--;
		itrq--;
		int lp = *itrp, lq = *itrq;

		ll diff = (ll)s[day-1][post] - (ll)s[day-1][prev];
		diff -= (ll)(day - lp) * (rp - day) * c[prev];
		diff += (ll)(day - lq) * (rq - day) * c[post];

        out[day] = post;
        st[post].insert(day);

		return diff;
	}

	int calcScore(vector<int> out){
		for (int d = 1; d <= D; d++){
			st[out[d]].insert(d);
			sat[d] = sat[d-1] + s[d-1][out[d]];
			last[out[d]] = d;
			rep (j, 26){
				sat[d] -= (d - last[j]) * c[j];
        	} // end rep
    	} // end for
        int res = sat[D];
//        cerr << "score: " << res << endl;
		return res;
	}

	vector<int> makeSolution(vector<int> out){
		vector<int> ret(D, 0);
		rep (i, D){
			ret[i] = out[i+1] + 1;
		} // end rep
		return ret;
	}

	vector<int> geneRes(void){
		vector<int> res(D+1, 0);
		for (int d = 1; d <= D; d++){
			res[d] = Rand() % 26;
		} // end rep
		return res;
	}

	void init(int _D, vector<int> _c, vector<vector<int>> _s){
		startTime = timer.get();
		endTime = TIME_LIMIT;
		D = _D;
		c = _c;
		s = _s;
		out.clear(); out.resize(D+1, 0);
		last.clear(); last.resize(26, 0);
		rep (i, 26){
			st[i].clear();
		} // end rep
		rep (i, 26){
			st[i].insert(0);
			st[i].insert(D+1);
    	} // end rep		
		sat.clear(); sat.resize(D + 1, 0);
	}
};

int main()
{
	IHC ihc;

	ios_base::sync_with_stdio(0);
	cin.tie(0);
	int D; cin >> D;
	vector<int> c(26, 0);
	rep (i, 26){
		cin >> c[i];
	} // end rep
	vector<vector<int>> s(D, vector<int>(26, 0));
	rep (i, D){
		rep (j, 26){
			cin >> s[i][j];
		} // end rep
	} // end rep

	vector<int> ret = ihc.solve(D,c,s);
	rep (i, (int)ret.size()){
		cout << ret[i] << endl;
	} // end rep

	return 0;
}


Measured memory_bytes: 4052