#[macro_use]
mod input_mcr {
    // ref: tanakh <https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8>
    // diff: using Parser
    #[macro_export(local_inner_macros)]
    macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut parser = Parser::from_str($s);
        input_inner!{parser, $($r)*}
    };
    (parser = $parser:ident, $($r:tt)*) => {
        input_inner!{$parser, $($r)*}
    };
    (new_stdin_parser = $parser:ident, $($r:tt)*) => {
        let stdin = std::io::stdin();
        let reader = std::io::BufReader::new(stdin.lock());
        let mut $parser = Parser::new(reader);
        input_inner!{$parser, $($r)*}
    };
    ($($r:tt)*) => {
        input!{new_stdin_parser = parser, $($r)*}
    };
}

    #[macro_export(local_inner_macros)]
    macro_rules! input_inner {
    ($parser:ident) => {};
    ($parser:ident, ) => {};
    ($parser:ident, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($parser, $t);
        input_inner!{$parser $($r)*}
    };
}

    #[macro_export(local_inner_macros)]
    macro_rules! read_value {
    ($parser:ident, ( $($t:tt),* )) => {
        ( $(read_value!($parser, $t)),* )
    };
    ($parser:ident, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($parser, $t)).collect::<Vec<_>>()
    };
    ($parser:ident, chars) => {
        read_value!($parser, String).chars().collect::<Vec<char>>()
    };
    ($parser:ident, char_) => {
        read_value!($parser, String).chars().collect::<Vec<char>>()[0]
    };
    ($parser:ident, usize1) => {
        read_value!($parser, usize) - 1
    };
    ($parser:ident, line) => {
        $parser.next_line()
    };
    ($parser:ident, line_) => {
        $parser.next_line().chars().collect::<Vec<char>>()
    };
    ($parser:ident, i64_) => {
        $parser.fast_i64()
    };
    ($parser:ident, usize_) => {
        $parser.fast_i64() as usize
    };
    ($parser:ident, usize1_) => {
        ($parser.fast_i64() - 1) as usize
    };
    ($parser:ident, $t:ty) => {
        $parser.next::<$t>().expect("Parse error")
    };
}

    use std::io;
    use std::io::BufRead;
    use std::str;

    // ref: tatsuya6502 <https://qiita.com/tatsuya6502/items/cd448486f7ef7b5b8c7e>
    // ref: wariuni <https://qiita.com/tatsuya6502/items/cd448486f7ef7b5b8c7e#comment-7040a5ae96305e884eb9>
    // diff: using std::io::BufRead::fill_buf()
    pub struct Parser<R> {
        pub reader: R,
        buf: Vec<u8>,
        pos: usize,
    }

    impl Parser<io::Empty> {
        pub fn from_str(s: &str) -> Parser<io::Empty> {
            Parser {
                reader: io::empty(),
                buf: s.as_bytes().to_vec(),
                pos: 0,
            }
        }
    }

    impl<R: BufRead> Parser<R> {
        pub fn new(reader: R) -> Parser<R> {
            Parser {
                reader: reader,
                buf: vec![],
                pos: 0,
            }
        }
        pub fn update_buf(&mut self) {
            self.buf.clear();
            self.pos = 0;
            loop {
                let (len, complete) = {
                    let buf2 = self.reader.fill_buf().unwrap();
                    self.buf.extend_from_slice(buf2);
                    let len = buf2.len();
                    (len, buf2[len - 1] <= 0x20)
                };
                self.reader.consume(len);
                if complete {
                    break;
                }
            }
        }
        pub fn next<T: str::FromStr>(&mut self) -> Result<T, T::Err> {
            loop {
                let mut begin = self.pos;
                while begin < self.buf.len() && (self.buf[begin] <= 0x20) {
                    begin += 1;
                }
                let mut end = begin;
                while end < self.buf.len() && (self.buf[end] > 0x20) {
                    end += 1;
                }
                if begin != self.buf.len() {
                    self.pos = end;
                    return unsafe { str::from_utf8_unchecked(&self.buf[begin..end]) }.parse::<T>();
                } else {
                    self.update_buf();
                }
            }
        }
        pub fn next_line(&mut self) -> String {
            loop {
                let mut begin = self.pos;
                if begin < self.buf.len() && (self.buf[begin] < 0x20) {
                    begin += 1;
                }
                let mut end = begin;
                while end < self.buf.len() && (self.buf[end] >= 0x20) {
                    end += 1;
                }
                if begin != self.buf.len() {
                    self.pos = end;
                    return unsafe { str::from_utf8_unchecked(&self.buf[begin..end]) }.to_string();
                } else {
                    self.update_buf();
                }
            }
        }
        pub fn fast_i64(&mut self) -> i64 {
            loop {
                let mut begin = self.pos;
                while begin < self.buf.len() && (self.buf[begin] <= 0x20) {
                    begin += 1;
                }
                if begin == self.buf.len() {
                    self.update_buf();
                    continue;
                }
                let mut res = 0;
                let (is_positive, mut end) = match self.buf[begin] {
                    b'+' => (true, begin + 1),
                    b'-' => (false, begin + 1),
                    _ => (true, begin),
                };
                while end < self.buf.len() && (self.buf[end] > 0x20) {
                    res = res * 10 + (self.buf[end] as i64 - '0' as i64);
                    end += 1;
                }
                if begin != self.buf.len() {
                    self.pos = end;
                    return if is_positive { res } else { -res };
                } else {
                    self.update_buf();
                }
            }
        }
    }
}

mod beam {

    pub trait ValueOrd {
        fn is_better_than(&self, rhs: &Self) -> bool;
        fn is_worse_than(&self, rhs: &Self) -> bool {
            !self.is_better_than(rhs)
        }
    }

    #[derive(Debug, Clone)]
    struct HeapEntry<V> {
        pub v: V,
        pub i: usize,
    }

    impl<V> HeapEntry<V> {
        fn new(v: V, i: usize) -> HeapEntry<V> {
            HeapEntry::<V> { v, i }
        }
    }

    #[derive(Debug, Clone)]
    pub struct Beam<T, V> {
        heap: Vec<HeapEntry<V>>,
        xs: Vec<T>,
        w: usize,
    }

    impl<T: std::fmt::Debug, V: ValueOrd + std::fmt::Debug> Beam<T, V> {
        pub fn new() -> Beam<T, V> {
            Beam::<T, V> {
                heap: vec![],
                xs: vec![],
                w: 0,
            }
        }
        pub fn new_with_width(w: usize) -> Beam<T, V> {
            Beam::<T, V> {
                heap: vec![],
                xs: vec![],
                w,
            }
        }
        pub fn expand_width(&mut self, w: usize) {
            self.w = w;
        }
        fn update(&mut self) {
            let mut i = 0;
            loop {
                let l = 2 * i + 1;
                let r = 2 * i + 2;
                if l >= self.heap.len() {
                    break;
                }
                if r >= self.heap.len() {
                    if self.heap[l].v.is_worse_than(&self.heap[i].v) {
                        self.heap.swap(i, l);
                        i = l;
                    } else {
                        break;
                    }
                } else {
                    if self.heap[l].v.is_worse_than(&self.heap[i].v)
                        && self.heap[l].v.is_worse_than(&self.heap[r].v)
                    {
                        self.heap.swap(i, l);
                        i = l;
                    } else if self.heap[r].v.is_worse_than(&self.heap[i].v) {
                        self.heap.swap(i, r);
                        i = r;
                    } else {
                        break;
                    }
                }
            }
        }
        fn update_i(&mut self, i: usize) {
            let mut i = i;
            while i != 0 {
                let p = (i - 1) / 2;
                if self.heap[i].v.is_worse_than(&self.heap[p].v) {
                    self.heap.swap(i, p);
                    i = p;
                } else {
                    break;
                }
            }
        }
        pub fn push(&mut self, t: T, v: V) {
            if self.heap.len() < self.w {
                let i = self.heap.len();
                self.heap.push(HeapEntry::new(v, i));
                self.xs.push(t);
                self.update_i(i);
            } else if v.is_better_than(&self.heap[0].v) {
                self.xs[self.heap[0].i] = t;
                self.heap[0].v = v;
                self.update();
            }
        }
        pub fn iter(&self) -> std::slice::Iter<T> {
            self.xs.iter()
        }
        pub fn as_ref_vec(&self) -> &Vec<T> {
            &self.xs
        }
    }
}

use crate::input_mcr::*;
use std::cmp::*;

use crate::beam::*;

use std::ops::*;

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
struct Value(i64);

impl Add for Value {
    type Output = Value;
    fn add(self, other: Self) -> Self {
        Self(self.0 + other.0)
    }
}

impl Sub for Value {
    type Output = Value;
    fn sub(self, other: Self) -> Self {
        Self(self.0 - other.0)
    }
}

impl Mul for Value {
    type Output = Value;
    fn mul(self, other: Self) -> Self {
        Self(self.0 * other.0)
    }
}

impl ValueOrd for Value {
    fn is_better_than(&self, rhs: &Self) -> bool {
        self > rhs
    }
}

#[derive(Clone)]
struct State {
    xs: [usize; 365],
    last: [usize; 27],
    score: Value,
    next_full_reduction: Value,
    cs_sum: Value,
}

impl State {
    pub fn new(cs_sum: Value) -> State {
        State {
            xs: [0; 365],
            last: [0; 27],
            score: Value(0),
            next_full_reduction: cs_sum,
            cs_sum,
        }
    }
    pub fn record(&mut self, d: usize, choice: usize, score: Value, cs: &Vec<i64>) {
        self.next_full_reduction = self.next_full_reduction + self.cs_sum;
        self.next_full_reduction = self.next_full_reduction
            - Value(cs[choice - 1] as i64) * (Value(d as i64) - Value(self.last[choice] as i64));
        self.xs[d - 1] = choice;
        self.last[choice] = d;
        self.score = score;
    }
}

#[derive(Debug, Clone, Copy)]
struct DiffState {
    prev_i: usize,
    choice: usize,
    score: Value,
}

fn main() {
    input! {
        d: usize,
        cs: [i64; 26],
        ss: [[i64; 26]; d],
    }
    let cs_sum = cs.iter().sum::<i64>();
    let mut states: Vec<Vec<State>> = vec![vec![]; d + 1];
    states[0].push(State::new(Value(cs_sum)));
    for i in 1..d + 1 {
        // 10 -> 30ms
        // 100 -> 142ms
        // 500 -> ?
        let mut beam: Beam<DiffState, Value> = Beam::new_with_width(500);
        for (prev_i, prev) in states[i - 1].iter().enumerate() {
            for choice in 1..=26 {
                let mut score = prev.score;
                score = score + Value(ss[i - 1][choice - 1]);
                score = score - prev.next_full_reduction;
                score = score
                    + Value(cs[choice - 1]) * (Value(i as i64) - Value(prev.last[choice] as i64));
                /*
                for k in 1..=26 {
                    if choice != k {
                        score = score - Value(cs[k-1] as i64) * (Value(i as i64) - Value(prev.last[k] as i64));
                    }
                }
                */
                let diff_state = DiffState {
                    prev_i: prev_i,
                    choice: choice,
                    score: score,
                };
                beam.push(diff_state, score);
                //// eprintln!("score: {:?}", score);
            }
        }
        for diff_state in beam.iter() {
            //// eprintln!("pop: {:?}", diff_state.score);
            let mut state = states[i - 1][diff_state.prev_i].clone();
            state.record(i, diff_state.choice, diff_state.score, &cs);
            states[i].push(state);
        }
    }
    states[d].sort_by(|x, y| y.score.cmp(&x.score));
    for i in 0..d {
        println!("{}", states[d][0].xs[i]);
    }
    // eprintln!("score: {:?}", states[d][0].score);
}



Measured memory_bytes: 564860