#include <bits/stdc++.h>
using std::cin, std::cout, std::bitset, std::complex;
using std::vector, std::array, std::string, std::pair, std::list, std::queue;
using std::priority_queue, std::set, std::map, std::unordered_map;
using std::sort, std::min, std::max, std::reverse;
using std::min_element, std::max_element, std::accumulate;

using vi = vector<int>; using vvi = vector<vi>; using vvvi = vector<vvi>;
using ull = unsigned long long int;
using ll = long long int;
using vll = vector<ll>; using vvll = vector<vll>; using vvvll = vector<vvll>;
using vd = vector<double>; using vvd = vector<vd>; using vvvd = vector<vvd>;
using P = pair<int, int>;
using Pll = pair<ll, ll>;
using cdouble = complex<double>;

const double eps = 1e-7;
#define Loop(i, n) for(int i = 0; i < int(n); i++)
#define Loopll(i, n) for(ll i = 0; i < ll(n); i++)
#define Loop1(i, n) for(int i = 1; i <= int(n); i++)
#define Loopll1(i, n) for(ll i = 1; i <= ll(n); i++)
#define Loopr(i, n) for(int i = int(n) - 1; i >= 0; i--)
#define Looprll(i, n) for(ll i = ll(n) - 1; i >= 0; i--)
#define Loopr1(i, n) for(int i = int(n); i >= 1; i--)
#define Looprll1(i, n) for(ll i = ll(n); i >= 1; i--)
#define Foreach(buf, container) for(const auto &buf : container)
#define Foreachr(buf, container)  for(const auto &buf : reversed(container))
#define Loopdiag(i, j, h, w, sum) for(int i = ((sum) >= (h) ? (h) - 1 : (sum)), j = (sum) - i; i >= 0 && j < (w); i--, j++)
#define Loopdiagr(i, j, h, w, sum) for(int j = ((sum) >= (w) ? (w) - 1 : (sum)), i = (sum) - j; j >= 0 && i < (h); j--, i++)
#define Loopdiagsym(i, j, h, w, gap) for (int i = ((gap) >= 0 ? (gap) : 0), j = i - (gap); i < (h) && j < (w); i++, j++)
#define Loopdiagsymr(i, j, h, w, gap) for (int i = ((gap) > (h) - (w) - 1 ? (h) - 1 : (w) - 1 + (gap)), j = i - (gap); i >= 0 && j >= 0; i--, j--)
#define Loopitr(itr, container) for(auto itr = container.begin(); itr != container.end(); itr++)
#define quickio() std::ios::sync_with_stdio(false); std::cin.tie(0);
#define bitmanip(m,val) static_cast<bitset<(int)m>>(val)
#define Comp(type_t) bool operator<(const type_t &another) const
#define fst first
#define snd second
bool feq(double x, double y) { return abs(x - y) <= eps; }
bool inrange(ll x, ll t) { return x >= 0 && x < t; }
bool inrange(vll xs, ll t) { Foreach(x, xs) if (!(x >= 0 && x < t)) return false; return true; }
int ceillog2(ll x) { int m = int(log2(x)); return m + ((1LL << m) < x ? 1 : 0); }
int floorlog2(ll x) { int m = int(log2(x)); return m - ((1LL << m) > x ? 1 : 0); }
const string endl = "\n";
template<class T> T reversed(T container) { reverse(container.begin(), container.end()); return container; }
template<class T> void printv(const vector<T> &v) { for (const T &x : v) cout << x << " "; cout << endl; }
template<class T> void printmx(const vector<vector<T>> &mx) { for (const vector<T> &v : mx) printv(v); }
ll rndf(double x) { return (ll)(x + (x >= 0 ? 0.5 : -0.5)); }
ll floorsqrt(ll x) { ll m = (ll)sqrt((double)x); return m + (m*  m <= x ? 0 : -1); }
ll ceilsqrt(ll x) { ll m = (ll)sqrt((double)x); return m + (x <= m * m ? 0 : 1); }
ll rnddiv(ll a, ll b) { return (a / b + (a % b * 2 >= b ? 1 : 0)); }
ll ceildiv(ll a, ll b) { return (a / b + (a % b == 0 ? 0 : 1)); }
ll gcd(ll m, ll n) { if (n == 0) return m; else return gcd(n, m % n); }
ll lcm(ll m, ll n) { return ll(m) * ll(n) / gcd(m, n); }

//========================================================================//

class Random_Dynamic_Int {
private:
	std::mt19937 *mt;
	std::uniform_real_distribution<> *distr_real;
public:
	Random_Dynamic_Int() {
		mt = new std::mt19937((uint64_t)(
			std::chrono::duration_cast<std::chrono::nanoseconds>(
				std::chrono::high_resolution_clock::now().time_since_epoch()
				).count()
			));
		distr_real = new std::uniform_real_distribution<>(0, 1);
	}
	~Random_Dynamic_Int() {
		delete mt;
		delete distr_real;
	}
	// uniform int distribution of [l, r), l < r is required
	int get(int l, int r) const {
		int n = r - l;
		double x = (*distr_real)(*mt);
		return l + int(x * n);
	}
};

class Random_Real {
private:
	std::mt19937 *mt;
	std::uniform_real_distribution<> *distr_real;
public:
	// uniform int distribution of [l, r)
	Random_Real(double l, double r) {
		mt = new std::mt19937((uint64_t)(
			std::chrono::duration_cast<std::chrono::nanoseconds>(
				std::chrono::high_resolution_clock::now().time_since_epoch()
				).count()
			));
		distr_real = new std::uniform_real_distribution<>(l, r);
	}
	double get() {
		return (*distr_real)(*mt);
	}
};

Random_Dynamic_Int *rdi = new Random_Dynamic_Int();
Random_Real *rr = new Random_Real(0, 1);

struct inp_t {
	int d;
	vvll s;
	vll c;
};

struct ans_t {
private:
	vector<set<int>> st;
	vi a; // 0-indexed
	ll score;
	std::mt19937 *mt;
public:
	ans_t(int _size) {
		this->a = vi(_size, -1);
		this->st = vector<set<int>>(26);
		mt = new std::mt19937((uint64_t)(
			std::chrono::duration_cast<std::chrono::nanoseconds>(
				std::chrono::high_resolution_clock::now().time_since_epoch()
				).count()
			));
	}
	void output() {
		for (const int x : a) {
			cout << x + 1 << endl;
		}
	}
	int get_a(int day) {
		return a[day];
	}
	ll get_score() {
		return score;
	}
	// calculation_cost = 1e4
	void recalc_score(const vi &a, const inp_t &inp) {
		this->a = a;
		ll sum = 0;
		vll last(26);
		Loop(j, 26) {
			this->st[j].insert(-1);
			this->st[j].insert(inp.d);
		}
		Loop(i, inp.d) {
			sum += inp.s[i][this->a[i]];
			last[this->a[i]] = i + 1;
			this->st[this->a[i]].insert(i);
			Loop(j, 26) {
				sum -= inp.c[j] * (i + 1 - last[j]);
			}
		}
		this->score = sum;
	}
	void recalc_score(const inp_t &inp) {
		ll sum = 0;
		vll last(26);
		Loop(j, 26) {
			this->st[j].insert(-1);
			this->st[j].insert(inp.d);
		}
		Loop(i, inp.d) {
			sum += inp.s[i][this->a[i]];
			last[this->a[i]] = i + 1;
			this->st[this->a[i]].insert(i);
			Loop(j, 26) {
				sum -= inp.c[j] * (i + 1 - last[j]);
			}
		}
		this->score = sum;
	}
	ll take_diff(int day, int id, const inp_t &inp) {
		ll ret = 0;
		int id_prev = this->a[day];
		int day_bef_prev = *(--(this->st[id_prev].lower_bound(day)));
		int day_aft_prev = *(this->st[id_prev].upper_bound(day));
		ll x0_prev = day - day_bef_prev;
		ll y0_prev = day_aft_prev - 1 - day_bef_prev;
		ll x1_prev = 0;
		ll y1_prev = day_aft_prev - 1 - day;
		int day_bef = *(--(this->st[id].lower_bound(day)));
		int day_aft = *(this->st[id].upper_bound(day));
		ll x0 = day - day_bef;
		ll y0 = day_aft - 1 - day_bef;
		ll x1 = 0;
		ll y1 = day_aft - 1 - day;
		ret -= inp.c[id_prev] * (x0_prev + y0_prev) * (y0_prev - x0_prev + 1) / 2;
		ret += inp.c[id_prev] * (x1_prev + y1_prev) * (y1_prev - x1_prev + 1) / 2;
		ret += inp.c[id] * (x0 + y0) * (y0 - x0 + 1) / 2;
		ret -= inp.c[id] * (x1 + y1) * (y1 - x1 + 1) / 2;
		ret -= inp.s[day][id_prev];
		ret += inp.s[day][id];
		return ret;
	}
	void update(int day, int id, const inp_t &inp, ll diff = LLONG_MAX) {
		if (diff == LLONG_MAX) {
			diff = this->take_diff(day, id, inp);
		}
		int id_prev = this->a[day];
		this->st[id_prev].erase(day);
		this->st[id].insert(day);
		this->a[day] = id;
		score += diff;
		return;
	}
	void shuffle(int day, const inp_t &inp) {
		vi a_buf(26);
		Loop(i, 26) a_buf[i] = this->a[day + i];
		std::shuffle(a_buf.begin(), a_buf.end(), *mt);
		ll diff = 0;
		Loop(i, 26) {
			diff += take_diff(day + i, a_buf[i], inp);
		}
		if (diff > 0) {
			Loop(i, 26) {
				this->update(day + i, a_buf[i], inp, 0);
			}
			score += diff;
		}
	}
};

inp_t get_input() {
	inp_t ret;
	cin >> ret.d;
	ret.c = vll(26);
	Loop(i, 26) cin >> ret.c[i];
	ret.s = vvll(ret.d, vll(26));
	Loop(i, ret.d) {
		Loop(j, 26) {
			cin >> ret.s[i][j];
		}
	}
	return ret;
}

ans_t constructive(const inp_t &inp) {
	ans_t ans(inp.d);
	// for each day, simulate all 26 contests and take the maximum
	struct eval_t {
		int id = -1;
		ll score_diff = 0;
		Comp(eval_t) {
			return score_diff < another.score_diff;
		}
	};
	vll last(26);
	vi a(inp.d);
	Loop(i, inp.d) {
		eval_t eval_best;
		Loop(j, 26) {
			eval_t eval_buf;
			eval_buf.id = j;
			eval_buf.score_diff += inp.s[i][j];
			eval_buf.score_diff += inp.c[j] * (i + 1 - last[j]);
			eval_best = max(eval_best, eval_buf);
		}
		a[i] = eval_best.id;
		last[eval_best.id] = i + 1;
	}
	ans.recalc_score(a, inp);
	return ans;
}

void hill_climbing(ans_t &ans, const inp_t &inp) {
	int day = rdi->get(0, inp.d);
	int id_prev = ans.get_a(day);
	int id = id_prev;
	while (id == id_prev) id = rdi->get(0, 26);
	ll diff = ans.take_diff(day, id, inp);
	if (diff > 0) {
		ans.update(day, id, inp, diff);
	}
}

void simulated_annealing(ans_t &ans, const inp_t &inp, int TRIAL_CNT = 5000) {
	ans_t ans_bckup = ans;
	Loop(_, TRIAL_CNT) {
		// The temperature function T = f(x) for x \in [0, 1].
		double(*tempfunc)(double x);
		tempfunc = [](double x) { return std::pow(0.1, x); };
		int day = rdi->get(0, inp.d);
		int id_prev = ans.get_a(day);
		int id = id_prev;
		while (id == id_prev) id = rdi->get(0, 26);
		ll diff = ans.take_diff(day, id, inp);
		const double temperature = tempfunc(double(_) / TRIAL_CNT);
		const double probability = (diff > 0 ? 1.0 : std::exp(diff / (2500 * temperature)));
		if (rr->get() < probability) {
			ans.update(day, id, inp, diff);
		}
	}
	if (ans.get_score() < ans_bckup.get_score()) {
		ans = ans_bckup;
	}
	return;
}

int main() {
	quickio();
	inp_t inp = get_input();
	ans_t ans = constructive(inp);
	Loop(_, 1300) {
		simulated_annealing(ans, inp);
	}
	Loop(_, 40000) {
		int day = rdi->get(0, inp.d - 26);
		ans.shuffle(day, inp);
	}
	ans.output();
}

Measured memory_bytes: 4452