// Original C++ solution (slower):
#include<iostream>

#include<set>

#include<vector>

#include<array>

#include<algorithm>

#include<chrono>



int const INF = 1e9;



uint64_t xor64(void) {

  static uint64_t x = 88172645463325252ULL;

  x = x ^ (x << 7);

  return x = x ^ (x >> 9);

}



auto b_cl = std::chrono::system_clock::now();

inline double get_time() {

  auto e_cl = std::chrono::system_clock::now();

  double msec = std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl).count();

  return msec;

}



int main() {

  std::cin.tie(0); std::ios::sync_with_stdio(false);

  int D; std::cin >> D;

  int c[26];

  for(auto& ci: c) std::cin >> ci;

  std::vector<std::array<int,26>> s(D);

  for(int d = 0; d < D; ++d) {

    for(auto& si: s[d]) std::cin >> si;

  }

  std::vector<int> t(D), bestT(D);

  int ans = -INF;

  //std::set<int> last[26];

  //for(auto& li: last) li.insert(-1); // sentinel

  int ansa[27];

  for(int k = 0; k <= 26; ++k) {

    ansa[k] = 0;

    int las[26];

    std::fill_n(las, 26, -1);

    for(int d = 0; d < D; ++d) {

      int ma = -INF, tt = -1;

      for(int T = 0; T < 26; ++T) {

        int cur = s[d][T];

        int sv = las[T];

        las[T] = d;

        for(int dd = d; dd <= d+k && dd < D; ++dd) {

          for(int cx = 0; cx < 26; ++cx) {

            cur -= c[cx]*(dd - las[cx]);

          }

        }

        las[T] = sv;

        if(cur > ma) { ma = cur; tt = T; }

      }

      las[tt] = d;

      t[d] = tt;

      ansa[k] += s[d][tt];

      for(int cx = 0; cx < 26; ++cx) {

        ansa[k] -= c[cx]*(d - las[cx]);

      }

    }

    if(ansa[k] > ans) {

      ans = ansa[k];

      std::copy(t.begin(), t.end(), bestT.begin());

    }

  }

  std::copy(bestT.begin(), bestT.end(), t.begin());

  //for(auto& li: last) li.insert(D); // sentinel

#if 0  

  // additional score when t[d] = i compare to t[d] = -1

  auto sum_up = [](int d) { return d*(d-1)/2; };

  auto score = [&](int d, int i)->int {

    int res = s[d][i];

    auto it = last[i].lower_bound(d);

    int nd = *it;

    int pd = *--it;

    int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);

    res -= c[i]*diff;

    return res;

  };

  int lm = 0, renew = 0;

  int sc[26];

  auto one_day = [&](int d) {

    int pi = t[d];

    last[pi].erase(d);

    for(int i = 0; i < 26; ++i) sc[i] = score(d, i);

    int mi = std::max_element(sc, sc+26) - sc;

    if(mi != pi) {

      ans += sc[mi] - sc[pi];

      ++renew;

    }

    last[mi].insert(d);

  };

  

  // hill climbing

  int range = 50;

  for(int rep = 0;; ++rep) {

    if((xor64()>>25)%2) {

      one_day(xor64()%365);

    } else {

      // swap

      int d1 = xor64()%D, d2 = xor64()%D;

      while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {

          d1 = xor64()%D; d2 = xor64()%D;

      }

      int pi1 = t[d1], pi2 = t[d2];

      last[pi1].erase(d1);

      int diff = score(d1, pi2) - score(d1, pi1);

      last[pi2].insert(d1);

      last[pi2].erase(d2);

      diff += score(d2, pi1) - score(d2, pi2);

      if(diff > 0) {

        last[pi1].insert(d2);

        t[d1] = pi2;

        t[d2] = pi1;

        lm = 0;

      } else {

        last[pi2].insert(d2);

        last[pi2].erase(d1);

        last[pi1].insert(d1);

      }

    }

    if(rep%100 == 0) {

      int x = get_time();

      if(x > 1950) break;

    }

  }

#endif

  for(auto ti: t) std::cout << ti+1 << "\n";

  return 0;

}


// Optimized solution to the same problem (faster):
#include<iostream>

#include<set>

#include<vector>

#include<array>

#include<algorithm>

#include<chrono>



int const INF = 1e9;



uint64_t xor64(void) {

  static uint64_t x = 88172645463325252ULL;

  x = x ^ (x << 7);

  return x = x ^ (x >> 9);

}



auto b_cl = std::chrono::system_clock::now();

inline double get_time() {

  auto e_cl = std::chrono::system_clock::now();

  double msec = std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl).count();

  return msec;

}



int main() {

  std::cin.tie(0); std::ios::sync_with_stdio(false);

  int D; std::cin >> D;

  int c[26];

  for(auto& ci: c) std::cin >> ci;

  std::vector<std::array<int,26>> s(D);

  for(int d = 0; d < D; ++d) {

    for(auto& si: s[d]) std::cin >> si;

  }

  std::vector<int> t(D), bestT(D);

  int ans = -INF;

  //std::set<int> last[26];

  //for(auto& li: last) li.insert(-1); // sentinel

  int ansa[27];

  for(int k = 0; k <= 6; ++k) {

    ansa[k] = 0;

    int las[26];

    std::fill_n(las, 26, -1);

    for(int d = 0; d < D; ++d) {

      int ma = -INF, tt = -1;

      for(int T = 0; T < 26; ++T) {

        int cur = s[d][T];

        int sv = las[T];

        las[T] = d;

        for(int dd = d; dd <= d+k && dd < D; ++dd) {

          for(int cx = 0; cx < 26; ++cx) {

            cur -= c[cx]*(dd - las[cx]);

          }

        }

        las[T] = sv;

        if(cur > ma) { ma = cur; tt = T; }

      }

      las[tt] = d;

      t[d] = tt;

      ansa[k] += s[d][tt];

      for(int cx = 0; cx < 26; ++cx) {

        ansa[k] -= c[cx]*(d - las[cx]);

      }

    }

    if(ansa[k] > ans) {

      ans = ansa[k];

      std::copy(t.begin(), t.end(), bestT.begin());

    }

  }

  std::copy(bestT.begin(), bestT.end(), t.begin());

  //for(auto& li: last) li.insert(D); // sentinel

#if 0  

  // additional score when t[d] = i compare to t[d] = -1

  auto sum_up = [](int d) { return d*(d-1)/2; };

  auto score = [&](int d, int i)->int {

    int res = s[d][i];

    auto it = last[i].lower_bound(d);

    int nd = *it;

    int pd = *--it;

    int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);

    res -= c[i]*diff;

    return res;

  };

  int lm = 0, renew = 0;

  int sc[26];

  auto one_day = [&](int d) {

    int pi = t[d];

    last[pi].erase(d);

    for(int i = 0; i < 26; ++i) sc[i] = score(d, i);

    int mi = std::max_element(sc, sc+26) - sc;

    if(mi != pi) {

      ans += sc[mi] - sc[pi];

      ++renew;

    }

    last[mi].insert(d);

  };

  

  // hill climbing

  int range = 50;

  for(int rep = 0;; ++rep) {

    if((xor64()>>25)%2) {

      one_day(xor64()%365);

    } else {

      // swap

      int d1 = xor64()%D, d2 = xor64()%D;

      while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {

          d1 = xor64()%D; d2 = xor64()%D;

      }

      int pi1 = t[d1], pi2 = t[d2];

      last[pi1].erase(d1);

      int diff = score(d1, pi2) - score(d1, pi1);

      last[pi2].insert(d1);

      last[pi2].erase(d2);

      diff += score(d2, pi1) - score(d2, pi2);

      if(diff > 0) {

        last[pi1].insert(d2);

        t[d1] = pi2;

        t[d2] = pi1;

        lm = 0;

      } else {

        last[pi2].insert(d2);

        last[pi2].erase(d1);

        last[pi1].insert(d1);

      }

    }

    if(rep%100 == 0) {

      int x = get_time();

      if(x > 1950) break;

    }

  }

#endif

  for(auto ti: t) std::cout << ti+1 << "\n";

  return 0;

}


// Fastest known solution for this problem: