#include <bits/stdc++.h>
#include <math.h>
#include <time.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const ll mod = 1000000007;
const ll INF = 1001001001;
const ll LINF = 1001001001001001001;

vector<vector<ll>> contlis;
vector<ll> cont_order;

void prvec(vector<bool> vec){
    ll n = vec.size();
    rep(i,n) cout << i << " " << vec.at(i) << "\n";
}

void pr2d(vector<vector<ll>> vvec){
    ll h = vvec.size();
    ll w = vvec.at(0).size();
    rep(i,h){
        rep(j,w){
            cout << vvec.at(i).at(j) << " ";
        }
        cout << "\n";
    }
}

ll cancel_and_add(vector<vector<ll>> &s, vector<ll> &c, ll date, ll add_con){
    ll diff = 0; //変更によってsatisがどれだけ変わるか

    ll cur_cont_d = cont_order.at(date); //現在date日に開催されているコンテストの種類
    diff -= s.at(date).at(cur_cont_d);//cur_cont_dの開催をやめることによる直接の影響
    diff += s.at(date).at(add_con);//add_conコンテストの分のsatisを増やす直接の影響

    //cur_cont_d開催中止による飽きの影響
    auto it = lower_bound(contlis.at(cur_cont_d).begin(),contlis.at(cur_cont_d).end(),date+1);
    ll x = it - contlis.at(cur_cont_d).begin();
    ll a = date+1 - contlis.at(cur_cont_d).at(x-1) - 1;
    ll b = contlis.at(cur_cont_d).at(x+1) - (date+1) - 1;
    ll z = contlis.at(cur_cont_d).at(x+1) - contlis.at(cur_cont_d).at(x-1) - 1;

    diff = diff - c.at(cur_cont_d)*z*(z+1)/2 + c.at(cur_cont_d)*a*(a+1)/2 + c.at(cur_cont_d)*b*(b+1)/2;

    //q追加による飽きへの影響
    auto it2 = lower_bound(contlis.at(add_con).begin(),contlis.at(add_con).end(),date+1);
    x = it2 - contlis.at(add_con).begin();
    a = (date+1) - contlis.at(add_con).at(x-1) - 1;
    b = contlis.at(add_con).at(x) - (date+1) - 1;
    z = contlis.at(add_con).at(x) - contlis.at(add_con).at(x-1) - 1;
    diff += c.at(add_con)*z*(z+1)/2 - c.at(add_con)*a*(a+1)/2 - c.at(add_con)*b*(b+1)/2;
    return diff;
}

ll swapcon(vector<vector<ll>> &s, vector<ll> &c, ll a, ll b, ll &cur_cont_a, ll &cur_cont_b){
    ll diff = 0;

    //cur_cont_aのリストから日程aを消す
    diff -= s.at(a).at(cur_cont_a); //コンテスト消去そのものの得点への影響

    auto it = lower_bound(contlis.at(cur_cont_a).begin(),contlis.at(cur_cont_a).end(),a+1);
    ll x = it - contlis.at(cur_cont_a).begin(); //day-aの位置情報 
    ll aa = a - contlis.at(cur_cont_a).at(x-1); //day-aの1つ前に同じコンテストが開催される日とday-aの間にある日数
    ll bb = contlis.at(cur_cont_a).at(x+1) - (a+1) - 1; //day-aの1つ後に同じコンテストが開催される日とday-aの間にある日数
    ll z = aa + bb + 1;
    diff = diff - c.at(cur_cont_a)*z*(z+1)/2 + c.at(cur_cont_a)*aa*(aa+1)/2 + c.at(cur_cont_a)*bb*(bb+1)/2; //飽きの影響(引き算)

    contlis.at(cur_cont_a).erase(it);    //実際にday-aのcur_cont_aを消す

    
    //cur_cont_bのリストから日程bを消す   
    diff -= s.at(b).at(cur_cont_b); //コンテスト消去そのものの得点への影響

    auto it2 = lower_bound(contlis.at(cur_cont_b).begin(),contlis.at(cur_cont_b).end(),b+1);
    x = it2 - contlis.at(cur_cont_b).begin(); //day-bの位置情報 
    aa = b - contlis.at(cur_cont_b).at(x-1); //day-bの1つ前に同じコンテストが開催される日とday-bの間にある日数
    bb = contlis.at(cur_cont_b).at(x+1) - (a+1) - 1; //day-bの1つ後に同じコンテストが開催される日とday-bの間にある日数
    z = aa + bb + 1;
    diff = diff - c.at(cur_cont_b)*z*(z+1)/2 + c.at(cur_cont_b)*aa*(aa+1)/2 + c.at(cur_cont_b)*bb*(bb+1)/2; //飽きの影響(引き算)

    contlis.at(cur_cont_b).erase(it2);    //実際にday-bのcur_cont_bを消す

    //cur_cont_aのリストに日程bを追加する
    diff += s.at(b).at(cur_cont_a); //コンテスト追加そのものの影響

    auto it3 = lower_bound(contlis.at(cur_cont_a).begin(),contlis.at(cur_cont_a).end(),b+1); //この時点では追加する場所の右側を指している
    x = it3 - contlis.at(cur_cont_a).begin(); //xが示しているのはday-bの次にcur_cont_aを実施する日にちのindex
    //cout << x << endl;
    aa = b + 1 - contlis.at(cur_cont_a).at(x-1) - 1;
    //cout << aa << endl;
    bb = contlis.at(cur_cont_a).at(x) - (b+1) - 1;
    //cout << bb << endl;
    z = aa + bb + 1;
    //cout << z << endl;
    diff = diff + c.at(cur_cont_a)*z*(z+1)/2 - c.at(cur_cont_a)*aa*(aa+1)/2 - c.at(cur_cont_a)*bb*(bb+1)/2;

    contlis.at(cur_cont_a).insert(it3,b+1);
    //sort(contlis.at(cur_cont_a).begin(),contlis.at(cur_cont_a).end());

    
    //cur_cont_bのリストに日程aを追加する
    diff += s.at(a).at(cur_cont_b); //コンテスト追加そのものの影響

    auto it4 = lower_bound(contlis.at(cur_cont_b).begin(),contlis.at(cur_cont_b).end(),a+1); //この時点では追加する場所の右側を指している
    x = it4 - contlis.at(cur_cont_b).begin(); //xが示しているのはday-aの次にcur_cont_bを実施する日にちのindex
    aa = a + 1 - contlis.at(cur_cont_b).at(x-1) - 1;
    bb = contlis.at(cur_cont_b).at(x) - (a+1) - 1;
    z = aa + bb + 1;
    diff = diff + c.at(cur_cont_b)*z*(z+1)/2 - c.at(cur_cont_b)*aa*(aa+1)/2 - c.at(cur_cont_b)*bb*(bb+1)/2;

    contlis.at(cur_cont_b).insert(it4,a+1);
    //sort(contlis.at(cur_cont_b).begin(),contlis.at(cur_cont_b).end());

    return diff;
}

int main(){
    clock_t start = clock();

    ll days; cin >> days;
    vector<ll> c(26);
    rep(i,26) cin >> c.at(i);
    vector<vector<ll>> s(days,vector<ll>(26));
    rep(i,days) rep(j,26) cin >> s.at(i).at(j);
    vector<ll> last(26,0);

    ll sat = 0;

    ll initial_satis=0;
    rep(i,26){
        initial_satis -= c.at(i)*days*(days+1)/2;
    }
    //initial_satis =　何もコンテストを開催していない状態の満足度
    
    ll satis = initial_satis;
    contlis.resize(26,{0,days+1});    
    cont_order.resize(days,-1);

    while(true){    //ある程度ランダムに生成してたまたま得点が良い組み合わせを探す
        clock_t now = clock();
        const double y = static_cast<double>(now - start) / CLOCKS_PER_SEC;
        if(y>0.2) break;


        ll satis_candidate = initial_satis;

        //ランダムに生成して得点の良い解を探す
        vector<ll> rand_init(days);
        rep(i,days) rand_init.at(i) = (rand()%26);

        //与えられたtだけコンテストを開催することを考える
        vector<vector<ll>> contlis_candidate(26,{0,days+1});
        for(int i=1;i<=days;i++){
            ll t = rand_init.at(i-1);
            auto it = lower_bound(contlis_candidate.at(t).begin(),contlis_candidate.at(t).end(),i);
            ll x = it - contlis_candidate.at(t).begin();
            ll a = i - contlis_candidate.at(t).at(x-1) - 1;
            ll b = contlis_candidate.at(t).at(x) - i - 1;
            ll z = contlis_candidate.at(t).at(x) - contlis_candidate.at(t).at(x-1) - 1;
            satis_candidate += c.at(t)*z*(z+1)/2 - c.at(t)*a*(a+1)/2 - c.at(t)*b*(b+1)/2;
            satis_candidate += s.at(i-1).at(t);
            contlis_candidate.at(t).insert(it,i);
        }
        if(satis_candidate > satis){
            satis = satis_candidate;
            cont_order = rand_init;
            contlis = contlis_candidate;
        }
    }

    while(true){
        clock_t now = clock();
        const double time = static_cast<double>(now - start) / CLOCKS_PER_SEC;
        if(time>1.5) break;
        ll type = rand()%2;        

        if(type==0){

            ll d = rand()%days, q = rand()%26; //最適化その1:ランダムにdとqを選び、d日目の開催コンテストをq番目のものにする

            if(cancel_and_add(s,c,d,q)>0){//採用する場合、様々変える
                satis += cancel_and_add(s,c,d,q);
                
                {//d日目の開催コンテストをqに変更する
                ll cur_cont_d = cont_order.at(d);
                cont_order.at(d) = q;
                auto erasecon = lower_bound(contlis.at(cur_cont_d).begin(),contlis.at(cur_cont_d).end(),d+1);
                contlis.at(cur_cont_d).erase(erasecon);
                auto addcon = lower_bound(contlis.at(q).begin(),contlis.at(q).end(),d+1);
                contlis.at(q).insert(addcon,d+1);
                }
            }
        }else{
            //最適化その2:a日目のコンテストとb日目のコンテストを入れ替える
            ll a = rand()%(days-1), b = min(a + 1 + (rand()%16) , days-1); //入れ替える日にちの選択(0-indexed)

            if(a>=b) continue;

            //現状a,b日目に開催されているコンテストは？(0-indexed)
            ll cur_cont_a = cont_order.at(a), cur_cont_b = cont_order.at(b);
            if(cur_cont_a == cur_cont_b) continue;
            
            vector<vector<ll>> prev_contlis = contlis; //過剰にコピーしている

            //試しにswap処理をしてみる
            ll swapdiff = swapcon(s,c,a,b,cur_cont_a,cur_cont_b);

            if(swapdiff>0){
                swap(cont_order.at(a),cont_order.at(b));
                satis += swapdiff;
            }else{
                contlis = prev_contlis;
            }
            /*
            ll sat = 0;
            rep(i,26) last.at(i) = 0;
            for(int i=1;i<=days;i++){
                ll t = cont_order.at(i-1);
                last.at(t) = i;
                sat += s.at(i-1).at(t);
                for(int j=0;j<26;j++){
                    sat -= c.at(j) * (i - last.at(j));
                }
            }
            */
        }
      	
    }

    rep(i,days){
        cout << cont_order.at(i) + 1;
        if(i!=(days-1))cout << "\n"; 
    }
	cout << endl;

    return 0;
}


Measured memory_bytes: 3744