#[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
        }
    }
}

mod timer {
    pub struct Timer {
        begin_tsc: u64,
        frequency: u64,
        inv_frequency: f64,
    }

    impl Timer {
        pub fn get_frequency() -> u64 {
            let tsc = unsafe { core::arch::x86_64::_rdtsc() };
            std::thread::sleep(std::time::Duration::from_millis(500));
            let freq = 2 * (unsafe { core::arch::x86_64::_rdtsc() } - tsc);
            freq
        }
        pub fn new(frequency: u64) -> Timer {
            Timer {
                begin_tsc: unsafe { core::arch::x86_64::_rdtsc() },
                frequency,
                inv_frequency: 1.0 / frequency as f64,
            }
        }
        pub fn now(&self) -> f64 {
            let t = unsafe { core::arch::x86_64::_rdtsc() };
            (t - self.begin_tsc) as f64 * self.inv_frequency
        }
    }
}

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

use crate::beam::*;
use crate::timer::*;

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,
}

struct BeamWidthController {
    timer: Timer,
    prev_t: Option<f64>,
    default_width: usize,
    prev_width: Option<usize>,
    remain_steps: usize,
    total_time: f64,
    limit_width: usize,
}

impl BeamWidthController {
    pub fn new(
        frequency: u64,
        default_width: usize,
        limit_width: usize,
        total_time: f64,
        remain_steps: usize,
    ) -> BeamWidthController {
        BeamWidthController {
            timer: Timer::new(frequency),
            prev_t: None,
            default_width,
            prev_width: None,
            total_time,
            remain_steps,
            limit_width,
        }
    }
    pub fn get(&mut self) -> usize {
        let res = if let Some(prev_t) = self.prev_t {
            let now = self.timer.now();
            let dt = now - prev_t;
            let time_per_once = dt / self.prev_width.unwrap() as f64;
            let res = ((self.total_time - now) / self.remain_steps as f64 / time_per_once) as usize;
            min(self.limit_width, res)
        } else {
            self.default_width
        };
        self.prev_t = Some(self.timer.now());
        self.prev_width = Some(res);
        self.remain_steps -= 1;
        res
    }
}

fn main() {
    input! {
        d: usize,
        cs: [i64; 26],
        ss: [[i64; 26]; d],
    }
    let cs_sum = cs.iter().sum::<i64>();
    let mut states: Vec<State> = vec![];
    let mut new_states: Vec<State> = vec![];
    states.push(State::new(Value(cs_sum)));
    let mut beam_width_controller = BeamWidthController::new(3_000_000_000, 1000, 50000, 1.9, d);
    // prev_i, choice
    let mut table: Vec<Vec<(usize, usize)>> = vec![vec![]; d + 1];
    for i in 1..d + 1 {
        let beam_width = beam_width_controller.get();
        //let beam_width = 40000;
        // // eprintln!("beam_width = {}", beam_width);
        new_states.clear();
        let mut beam: Beam<DiffState, Value> = Beam::new_with_width(beam_width);
        for (prev_i, prev) in states.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));
                let diff_state = DiffState {
                    prev_i: prev_i,
                    choice: choice,
                    score: score,
                };
                beam.push(diff_state, score);
                //// eprintln!("score: {:?}", score);
            }
        }
        for (k, diff_state) in beam.iter().enumerate() {
            //// eprintln!("pop: {:?}", diff_state.score);
            let mut state = states[diff_state.prev_i].clone();
            state.record(i, diff_state.choice, diff_state.score, &cs);
            new_states.push(state);
            table[i].push((diff_state.prev_i, diff_state.choice));
        }
        std::mem::swap(&mut states, &mut new_states);
    }
    let mut best_i = 0;
    for i in 0..states.len() {
        if states[i].score > states[best_i].score {
            best_i = i;
        }
    }
    let mut xs = vec![];
    let mut t = best_i;
    for i in (1..d + 1).rev() {
        xs.push(table[i][t].1);
        t = table[i][t].0;
    }
    xs.reverse();
    for &x in &xs {
        println!("{}", x);
    }
    /*
    states.sort_by(|x,y| y.score.cmp(&x.score));
    for i in 0..d {
        println!("{}", states[0].xs[i]);
    }
    */
    // eprintln!("score?: {:?}", states[best_i].score);
}



Measured memory_bytes: 112004