#include <bits/stdc++.h>
using namespace std;


#define FOR(i, start, end) for(uint64_t i=start; i<end; i++)
#define REP(i, n) FOR(i, 0, n)

// 最大公約数gcd
// 最小公倍数lcm=m*n/gcd
uint64_t gcd(uint64_t m, uint64_t n) {
  uint64_t temp;
  while (m % n != 0){
    temp = n;
    n = m % n;
    m = temp;
  }
  return n;
}

uint64_t lcm(uint64_t m, uint64_t n) {
  return (m*n)/gcd(m,n);
}

// vector<vector<uint64_t> > v(n+1, vector<uint64_t>(n+1, 0))
// v[n][k]に組み合わせ数が入る。
void comb(vector<vector <uint64_t> > &v){
  for(uint64_t i = 0;i <v.size(); i++){
    v[i][0]=1;
    v[i][i]=1;
  }
  for(uint64_t k = 1;k <v.size();k++){
    for(uint64_t j = 1;j<k;j++){
      v[k][j]=(v[k-1][j-1]+v[k-1][j]);
    }
  }
}

// 掛け算オーバーフロー判定
bool is_product_overflow(uint64_t a, uint64_t b) {

	uint64_t prod = a * b;
	
	return (prod / b != a);
}

//素因数分解
void primeFactorization(uint64_t a, list<uint64_t> &factors){ //素因数分解を出力するプログラム
  long i,sq;
  if(a%2==0){ //偶数の場合
    factors.push_back(2);
    primeFactorization(a/2,factors); //2で割った値で再帰
    return;
  }
  sq = sqrt(a);
  for(i=3;i<=sq;i+=2){ //3以上√a以下の奇数の場合
	if(a%i==0){
	  factors.push_back(i);
      primeFactorization(a/i,factors); //割れた値で再帰
      return;
	}
  }
  //偶数でも3以上√a以下の奇数の場合でも割り切れない場合
  if(a!=1){ //aが1でないなら、a自身は素数
    factors.push_back(a);
  }
}

// フェルマーの小定理
// mod. m での a の逆元 a^{-1} を計算する
int64_t modinv(int64_t a, int64_t m) {
    int64_t b = m, u = 1, v = 0;
    while (b) {
        int64_t t = a / b;
        a -= t * b; swap(a, b);
        u -= t * v; swap(u, v);
    }
    u %= m;
    if (u < 0) u += m;
    return u;
}

// 円周率
// M_PI

// #include <iomanip> // setprecisionを使用するのに必要
// cout << std::fixed << std::setprecision(15) << y << endl;

// 昇順
// priority_queue<int, vector<int>, greater<int> > queue;
signed main() {
  int64_t d;
  cin >> d;
  int64_t c[26];
  vector<vector<int64_t>> s(d);
  for(int i=0;i<26;i++){
    cin >> c[i];
  }
  
  for(int i=0;i<d;i++){
    for(int j=0;j<26;j++){
      int x;
      cin >> x;
      s[i].push_back(x);
    }
  }
  
  int64_t satis[26] = {0};
  int lastD[26] = {0};

  int t[d];

  int64_t totalSatis = 0;
  for(int i=0;i<d;i++){
    int maxId = 0;
    int64_t maxTotal = -100000000;
    for(int j=0;j<26;j++){
      int64_t tmpTotal = totalSatis;
      tmpTotal += s[i][j];
      for(int k=0;k<26;k++){
        if(k==j)continue;
        tmpTotal -= c[k]*(i+1-lastD[k]);
      }
      if(tmpTotal>maxTotal){
        maxTotal = tmpTotal;
        maxId = j;
      }
    }
    lastD[maxId]=i+1;
    totalSatis = maxTotal;
    t[i] = maxId;
  }

  std::random_device rnd;     // 非決定的な乱数生成器を生成
  std::mt19937 mt(rnd());     //  メルセンヌ・ツイスタの32ビット版、引数は初期シード値
  std::uniform_int_distribution<> rand26(0, 26);        // [0, 99] 範囲の一様乱数
  std::uniform_int_distribution<> randD(0, d-1);        // [0, 99] 範囲の一様乱数
  
  for(int tr=0;tr<10000;tr++){
    int day = randD(mt);
    int id = rand26(mt);
    
    int64_t newTotal = totalSatis;
    
    newTotal -= s[day][t[day]];
    newTotal += s[day][id];

    bool isFoundNewD = false;
    bool isFoundOrgD = false;
    int newPD = 0;
    int orgPD = 0;
    for(int i=day-1;i>=0;i--){
      if(!isFoundOrgD&&(t[i]==t[day])){
        orgPD = i;
        isFoundOrgD=true;
      }
      if(!isFoundNewD&&(t[i]==t[id])){
        newPD = i;
        isFoundNewD=true;
      }

    }
    
    isFoundNewD = false;
    isFoundOrgD = false;

    for(int i=day;i<=d;i++){
      if(!isFoundOrgD&& ( (i==d)||(t[i]==t[day]) ) ){
        newTotal -= (i-day)*(day-orgPD)*c[t[day]];

        isFoundOrgD=true;
      }
      if(!isFoundNewD&&( (i==d)|| (t[i]==t[id]) )){
        newTotal += (i-day)*(day-newPD)*c[id];
        isFoundNewD=true;
      }
    }
    
    if(newTotal>totalSatis){
      totalSatis = newTotal;
      t[day] = id;
    }
  }
  //cout << totalSatis << endl;
  for(int i=0;i<d;i++){
    cout << t[i]+1 << endl;
  }


  return 0;
}




Measured memory_bytes: 3796