#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);
	}
};

Random_Dynamic_Int *rdi = new Random_Dynamic_Int();

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

struct ans_t {
	vi a; // 0-indexed
	ll score;
	ans_t(int _size) {
		this->a = vi(_size, -1);
	}
	void output() {
		for (const int x : a) {
			cout << x + 1 << endl;
		}
	}
	// calculation_cost = 1e4
	ll calc_score(const inp_t &inp) {
		ll sum = 0;
		vll last(26);
		Loop(i, inp.d) {
			sum += inp.s[i][this->a[i]];
			last[this->a[i]] = i + 1;
			Loop(j, 26) {
				sum -= inp.c[j] * (i + 1 - last[j]);
			}
		}
		ll ret = max(1000000 + sum, 0LL);
		return ret;
	}
};

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);
	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);
		}
		ans.a[i] = eval_best.id;
		last[eval_best.id] = i + 1;
	}
	ans.score = ans.calc_score(inp);
	return ans;
}

void hill_climbing(const inp_t &inp, ans_t &ans) {
	int day = rdi->get(0, inp.d);
	int id_prev = ans.a[day];
	int id = id_prev;
	while (id == id_prev) id = rdi->get(0, 26);
	ans.a[day] = id;
	ans.calc_score(inp);
	ll score_buf = ans.calc_score(inp);
	if (ans.score < score_buf) {
		ans.score = score_buf;
		return;
	}
	else {
		ans.a[day] = id_prev;
		return;
	}
}

int main() {
	quickio();
	inp_t inp = get_input();
	ans_t ans = constructive(inp);
	Loop(_, 10000) {
		hill_climbing(inp, ans);
	}
	ans.output();
}

Measured memory_bytes: 3780