#if 1
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <queue>
#include <stack>
#include <array>
#include <deque>
#include <algorithm>
#include <utility>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <numeric>
#include <assert.h>
#include <bitset>
#include <list>
#include <cmath>


template<typename T, typename U>
std::enable_if_t<std::rank<T>::value == 0> fill_all(T& arr, const U& v) {
    arr = v;
}
template<typename ARR, typename U>
std::enable_if_t<std::rank<ARR>::value != 0> fill_all(ARR& arr, const U& v) {
    for (auto& i : arr) {
        fill_all(i, v);
    }
}

auto& in = std::cin;
auto& out = std::cout;
#define all_range(C) std::begin(C), std::end(C)
const double PI = 3.141592653589793238462643383279502884197169399375105820974944;

int32_t D;
int32_t C[30];
int32_t S[400][30];

int32_t res[400];
void greedy1()
{
    int32_t last[40] = {};
    fill_all(last, -1);
    for (int32_t d = 0; d < D; d++)
    {
        int32_t max = S[d][0];
        int32_t max_index = 0;
        for (int32_t i = 0; i < 26; i++)
        {
            auto ss = S[d][i] + C[i]*(d - last[i]);
            if (max < ss) {
                max = ss;
                max_index = i;
            }
        }
        res[d] = max_index;
        last[max_index] = d;
    }
}

int numofbits5(uint32_t bits)
{
    bits = (bits & 0x55555555) + (bits >> 1 & 0x55555555);
    bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333);
    bits = (bits & 0x0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f);
    bits = (bits & 0x00ff00ff) + (bits >> 8 & 0x00ff00ff);
    return (bits & 0x0000ffff) + (bits >> 16 & 0x0000ffff);
}

int32_t bittoindex[1 << 26];
void greedy2_init()
{
    for (size_t i = 0; i < 26; i++)
    {
        bittoindex[1 << i] = i;
    }
}
inline int bittoindexf(int32_t bit) {
    switch (bit)
    {
#define bittoindexf_MACRO(i)\
    case (1<<i): return i;

        bittoindexf_MACRO(0);
        bittoindexf_MACRO(1);
        bittoindexf_MACRO(2);
        bittoindexf_MACRO(3);
        bittoindexf_MACRO(4);
        bittoindexf_MACRO(5);
        bittoindexf_MACRO(6);
        bittoindexf_MACRO(7);
        bittoindexf_MACRO(8);
        bittoindexf_MACRO(9);
        bittoindexf_MACRO(10);
        bittoindexf_MACRO(11);
        bittoindexf_MACRO(12);
        bittoindexf_MACRO(13);
        bittoindexf_MACRO(14);
        bittoindexf_MACRO(15);
        bittoindexf_MACRO(16);
        bittoindexf_MACRO(17);
        bittoindexf_MACRO(18);
        bittoindexf_MACRO(19);
        bittoindexf_MACRO(20);
        bittoindexf_MACRO(21);
        bittoindexf_MACRO(22);
        bittoindexf_MACRO(23);
        bittoindexf_MACRO(24);
        bittoindexf_MACRO(25);
#undef bittoindexf_MACRO
    default:
        return 0;
    }
}
int32_t dp[1<<27];
void greedy2(int start, int base)
{
    constexpr int MAX_BIT = 26;
    constexpr int DIFFBASE = 0;
    auto CC = C + start;
    auto SS = S + start;

    fill_all(dp, 0);
    for (int32_t mask = 0; mask < (1<< MAX_BIT); mask++)
    {
        auto d = numofbits5(mask);
        auto tmp = ~mask;
        auto bit = tmp & -tmp;
        tmp ^= bit;
        while (bit < (1 << MAX_BIT))
        {
            auto index = bittoindexf(bit);
            auto next = mask | bit;
            auto add = SS[d][index] + CC[index] * (DIFFBASE + d) * (DIFFBASE + d)/2 + (26+ DIFFBASE - d)* (26 + DIFFBASE - d)/2;
            dp[next] = std::max(dp[next], dp[mask]+ add);

            bit = tmp & -tmp;
            tmp ^= bit;
        }
    }

    auto R = res + start;
    int32_t now = (1 << MAX_BIT) - 1;
    while(now > 0)
    {
        auto d = numofbits5(now)-1;
        auto tmp = now;
        auto bit = tmp & -tmp;
        tmp ^= bit;
        while (bit < (1 << MAX_BIT))
        {
            auto index = bittoindexf(bit);
            auto next = now ^ bit;
            auto add = SS[d][index] + CC[index] * (DIFFBASE + d) * (DIFFBASE + d) / 2 + (26 + DIFFBASE - d) * (26 + DIFFBASE - d) / 2;
            if (dp[now] == dp[next] + add) {
                R[d] = base+index;
                break;
            }

            bit = tmp & -tmp;
            tmp ^= bit;
        }

        now ^= bit;
    }
}

void greedy3()
{
    for (int32_t i = 0; i < D; i++)
        for (int32_t j = std::max(0,i-26); j < D && j < i+26; j++)
    {
        if (i == j) { continue; }
        if (res[i] == res[j] && i<j) { break; }
        if (res[i] == res[j]) { continue; }
        int lefti = i-1;
        while (lefti>=0 && res[lefti]!=res[i]) {
            --lefti;
        }
        int righti = i + 1;
        while (righti < D && res[righti] != res[i]) {
            ++righti;
        }

        int leftj = j - 1;
        while (leftj >= 0 && res[leftj] != res[j]) {
            --leftj;
        }
        int rightj = j + 1;
        while (rightj < D && res[rightj] != res[j]) {
            ++rightj;
        }

        if(std::max(lefti,leftj) <= std::min(i,j) &&
            std::max(i, j) <= std::min(righti, rightj))
        {
            auto now = S[i][res[i]]
                - C[res[i]] * (i - lefti - 1) * (i - lefti) / 2
                - (righti==D?0: - C[res[i]] * (righti - i - 1) * (righti - i) / 2)
                + S[j][res[j]]
                - C[res[j]] * (j - leftj - 1) * (j - leftj) / 2
                - (rightj == D ? 0 : -C[res[j]] * (rightj - j - 1) * (rightj - j) / 2);
            auto next = S[j][res[i]]
                - C[res[i]] * (j - lefti - 1) * (j - lefti) / 2
                - (righti == D ? 0 : -C[res[i]] * (righti - j - 1) * (righti - j) / 2)
                + S[i][res[j]]
                - C[res[j]] * (i - leftj - 1) * (i - leftj) / 2
                - (rightj == D ? 0 : -C[res[j]] * (rightj - i - 1) * (rightj - i) / 2);

            if (now < next) {
                std::swap(res[i], res[j]);
            }
        }
    }
}

int main()
{
    using std::endl;
    in.sync_with_stdio(false);
    out.sync_with_stdio(false);
    in.tie(nullptr);
    out.tie(nullptr);

    in >> D;
    for (size_t i = 0; i < 26; i++)
    {
        in >> C[i];
    }
    for (size_t d = 0; d < D; d++)
    {
        for (size_t i = 0; i < 26; i++)
        {
            in >> S[d][i];
        }
    }
    greedy1();
    //greedy2_init();
    //for (size_t i = 0; i < D; i+=26)
    //{
    //    greedy2(i,0);
    //    //greedy2(i+13,13);
    //}
    //greedy3();

    for (size_t d = 0; d < D; d++)
    {
        out << res[d]+1 << '\n';
    }
    //for (size_t d = 0; d < D; d++)
    //{
    //    out << (d%26) + 1 << '\n';
    //}

    return 0;
}
#endif


Measured memory_bytes: 3244