#include <iostream>
#include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <string>
#include <tuple>
#include <utility>
#include <functional>
#include <sys/time.h>
#include <iomanip>

using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define REP(i, m, n) for(int i = (m); i < (n); ++i)
#define rep(i, n) REP(i, 0, n)
#define all(s) (s).begin(), (s).end()
#define pb push_back
#define fs first
#define sc second
template <typename T>
bool chmax(T &a, const T b){if(a < b){a = b; return true;} return false;}
template <typename T>
bool chmin(T &a, const T b){if(a > b){a = b; return true;} return false;}
template <typename T>
ll pow2(const T n){return (1LL << n);}
void setp(const int n){cout << fixed << setprecision(n);}
constexpr int INF = 1e9+1;
constexpr ll LINF = 1e18+1;
constexpr ll MOD = 1e9+7;
//constexpr ll MOD = 998244353;
constexpr ld EPS = 1e-11;
const ld PI = acos(-1);

struct Xorshift {
	unsigned int x, y, z, w;
	
	Xorshift() {
		x = 123456789, y = 362436069, z = 521288629, w = 88675123;
	}

	unsigned int rand(){
		unsigned int t = (x^(x<<11));
		x = y; y = z; z = w;
		return w = (w^(w>>19))^(t^(t>>8));
	}

	double rand_d(){
		return (double)rand() / (1LL << 32);
	}
};
Xorshift xor128;

constexpr int BEAM_SIZE = 1000;
constexpr int SZ = 26;
constexpr int D = 365;
array<int, SZ> C;
int SUM = 0;
array<array<int, SZ>, D> S;

struct State {
	array<short, SZ> last = {};
	array<char, D> ans;
	int score = 0, sum = 0;

	void update_score(int d, int t) {
		score += S[d][t];
		sum -= C[t] * (d + 1 - last[t]);
		last[t] = d + 1;
		sum += SUM;
		score -= sum;
	}

	int next_eval(int d, int t){
		int res = score;
		res += S[d][t];
		res += C[t] * (d + 1 - last[t]);
		res -= sum + SUM;
		return res;
	}

	int eval() const {
		return score;
	}

	State place(int d, int t) {
		State res = *this;
		res.ans[d] = t;
		res.update_score(d, t);
		return res;
	}

	array<char, D> answer() {
		return ans;
	}
};

array<char, D> beam_search() {
	State initial_state;
	using f = function<bool(State&, State&)>;
	priority_queue<State, vector<State>, f> cur([](State& a, State& b){return a.eval() > b.eval();});
	cur.push(initial_state);
	priority_queue<State, vector<State>, f> nxt([](State& a, State& b){return a.eval() > b.eval();});
	rep(d, D){
		while(!nxt.empty()) nxt.pop();
		while(!cur.empty()){
			State now = cur.top(); cur.pop();
			rep(t, SZ){
				if(nxt.size() < BEAM_SIZE || now.next_eval(d, t) > nxt.top().eval()) nxt.push(now.place(d, t));
				if(nxt.size() > BEAM_SIZE) nxt.pop();
			}
		}
		swap(cur, nxt);
	}

	State res;
	while(!cur.empty()){
		if(cur.size() == 1) res = cur.top();
		cur.pop();
	}
	cerr << res.eval() << endl;
	return res.answer();
}

constexpr double T0 = 2e3, T1 = 1e2, TL = 1.9;

double temperature(double t, double st){
	t /= TL - st;
	return pow(T0, 1.0 - t) * pow(T1, t);
}

int calc_score(array<char, D> ans){
	int res = 0, sum = 0;
	array<short, SZ> last = {};
	rep(d, D){
		char t = ans[d];
		res += S[d][t];
		sum -= C[t] * (d + 1 - last[t]);
		last[t] = d + 1;
		sum += SUM;
		res -= sum;
	}
	return res;
}

bool is_update(int new_score, int prev_score, double temp){
	if (new_score >= prev_score) return true;
	return exp((double)(new_score - prev_score) / temp) >= xor128.rand_d();
}

int annealing(array<char, D> &ans) {
	int score = calc_score(ans);
	double st = (double)clock() / CLOCKS_PER_SEC;

	while((double)clock() / CLOCKS_PER_SEC < TL){
		double t = (double)clock() / CLOCKS_PER_SEC - st;
		double temp = temperature(t, st);
		// cerr << "temp : " << temp << endl;
		rep(i, 100){
			int d1 = xor128.rand() % (D - 1);
			int d2 = d1 + 1 + xor128.rand() % 10;
			chmin(d2, D - 1);
			swap(ans[d1], ans[d2]);
			if (!is_update(calc_score(ans), score, temp)) swap(ans[d2], ans[d1]);
		}
	}

	return score;
}

int main(void){
	int tmp;
	cin >> tmp;
	rep(i, SZ) cin >> C[i];
	rep(i, SZ) SUM += C[i];
	rep(i, D) rep(j, SZ) cin >> S[i][j];

	auto ans = beam_search();
	cerr << annealing(ans) << endl;
	for (char i : ans) cout << (int)i + 1 << endl;

	return 0;
}


Measured memory_bytes: 4448