#include <cassert>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <cstring>
#include <vector>

using namespace std;
typedef long long ll;

double TIME_LIMIT = 2.0;
ll startCycle;
const ll CYCLE_PER_SEC = 2900000000;

unsigned long long xor128() {
  static unsigned long long rx = 123456789, ry = 362436069, rz = 521288629, rw = 88675123;
  unsigned long long rt = (rx ^ (rx << 11));
  rx = ry;
  ry = rz;
  rz = rw;
  return (rw = (rw ^ (rw >> 19)) ^ (rt ^ (rt >> 8)));
}

unsigned long long int getCycle() {
  unsigned int low, high;
  __asm__ volatile ("rdtsc" : "=a" (low), "=d" (high));
  return ((unsigned long long int) low) | ((unsigned long long int) high << 32);
}

double getTime(unsigned long long int begin_cycle) {
  return (double) (getCycle() - begin_cycle) / CYCLE_PER_SEC;
}

const int MAX_D = 365;
const int MAX_CONTEST_NUM = 26;

int D;
int C[MAX_CONTEST_NUM];
int S[MAX_D][MAX_CONTEST_NUM];
// int schedule[MAX_D];
vector<int> L[MAX_D];
vector<int> schedule(MAX_D);

class ACS {
public:
  void init() {
    fprintf(stderr, "init =>\n");
    startCycle = getCycle();

    // memset(schedule, -1, sizeof(schedule));

    for (int d = 0; d < D; ++d) {
      schedule[d] = d % MAX_CONTEST_NUM;
    }

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

      for (int t = 0; t < MAX_CONTEST_NUM; ++t) {
        for (int s = 0; s < max(1, S[d][t] / 20); ++s) {
          row.push_back(t);
        }
      }

      L[d] = row;
    }
  }

  void run() {
    init();
    searchBestContestSchedule();

    int score = calcScoreRaw();
    fprintf(stderr, "calcScore: %d\n", score);
  }

  void searchBestContestSchedule() {
    // int bestSchedule[MAX_D];
    vector<int> bestSchedule = schedule;
    // memcpy(bestSchedule, schedule, sizeof(schedule));
    int bestScore = calcScore();
    int currentScore = bestScore;

    int R = 500000;
    double k = 1.0;
    int tryCount = 0;

    double currentTime = getTime(startCycle);
    int i, j, nc, nc2;

    while (currentTime < TIME_LIMIT) {
      currentTime = getTime(startCycle);
      double remainTime = (TIME_LIMIT - currentTime) / TIME_LIMIT;

      int type = xor128() % 4;

      do {
        i = xor128() % D;
        j = xor128() % D;
      } while (i == j);

      int bc = schedule[i];
      int bc2 = schedule[j];
      int nc = xor128() % MAX_CONTEST_NUM;
      int nc2 = xor128() % MAX_CONTEST_NUM;
      // int nc = L[i][xor128() % L[i].size()];

      switch (type) {
        case 0:
          swapSchedule(i, j);
          break;
        case 1:
          changeContest(i, nc);
          break;
        case 2:
          changeContest(i, nc);
          changeContest(j, nc2);
          break;
        case 3:
          insertContest(i, j);
          break;
      }

      int score = calcScore();
      int diffScore = score - currentScore;

      if (diffScore > 0 || (xor128() % R < R * exp(diffScore / (k * sqrt(remainTime))))) {
        currentScore = score;

        if (bestScore < score) {
          bestScore = score;
          bestSchedule = schedule;
          // memcpy(bestSchedule, schedule, sizeof(schedule));
        }
      } else {
        switch (type) {
          case 0:
            swapSchedule(i, j);
            break;
          case 1:
            changeContest(i, bc);
            break;
          case 2:
            changeContest(i, bc);
            changeContest(j, bc2);
            break;
          case 3:
            insertContest(j, i);
            break;
        }
      }

      ++tryCount;
    }

    fprintf(stderr, "tryCount: %d, bestScore: %d\n", tryCount, bestScore);

    schedule = bestSchedule;
    // memcpy(schedule, bestSchedule, sizeof(bestSchedule));
  }

  void swapSchedule(int i, int j) {
    swap(schedule[i], schedule[j]);
  }

  void changeContest(int i, int c) {
    schedule[i] = c;
  }

  void insertContest(int i, int j) {
    int t = schedule[i];
    schedule.erase(schedule.begin() + i);
    schedule.insert(schedule.begin() + j, t);
  }

  int calcScore() {
    int satisfaction = 0;
    int unsatisfaction = 0;
    int lastDay[MAX_CONTEST_NUM];
    memset(lastDay, 0, sizeof(lastDay));

    int unsum = 0;
    int up = 0;
    for (int c = 0; c < MAX_CONTEST_NUM; ++c) {
      unsum += C[c];
    }
    up = unsum;

    for (int d = 0; d < D; ++d) {
      int t = schedule[d];
      satisfaction += S[d][t];
      unsum += up;
      unsum -= C[t] * (d + 1 - lastDay[t]);
      lastDay[t] = (d + 1);
      unsatisfaction += unsum;

      /*
      for (int c = 0; c < MAX_CONTEST_NUM; ++c) {
        unsatisfaction += C[c] * (d + 1 - lastDay[c]);
      }
       */
    }

    return 2 * satisfaction - unsatisfaction;
  }

  int calcScoreRaw() {
    int satisfaction = 0;
    int unsatisfaction = 0;
    int lastDay[MAX_CONTEST_NUM];
    memset(lastDay, 0, sizeof(lastDay));

    for (int d = 0; d < D; ++d) {
      int t = schedule[d];
      assert(0 <= t && t < MAX_CONTEST_NUM);
      satisfaction += S[d][t];
      lastDay[t] = (d + 1);

      for (int c = 0; c < MAX_CONTEST_NUM; ++c) {
        unsatisfaction += C[c] * (d + 1 - lastDay[c]);
      }
    }

    int baseScore = 1000000;
    return max(baseScore + satisfaction - unsatisfaction, 0);
  }
};

int main() {
  cin >> D;

  int c;
  for (int i = 0; i < MAX_CONTEST_NUM; ++i) {
    cin >> c;
    C[i] = c;
  }

  for (int d = 0; d < D; ++d) {
    int s;
    for (int j = 0; j < MAX_CONTEST_NUM; ++j) {
      cin >> s;
      S[d][j] = s;
    }
  }

  ACS acs;
  acs.run();

  for (int i = 0; i < D; ++i) {
    cout << schedule[i] + 1 << endl;
  }

  return 0;
}


Measured memory_bytes: 22560