//  [swift]
let startTime = Date()

import Foundation

let MOD = 10 ** 9 + 7
let alphabets = "abcdefghijklmnopqrstuvwxyz"
let ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
let Yes = "Yes"
let No = "No"
prefix operator *
infix operator **: PowerPrecedence
precedencegroup PowerPrecedence {
    higherThan: MultiplicationPrecedence
    lowerThan: BitwiseShiftPrecedence
    associativity: right
}
prefix func * <T> (a: [T]) -> (T, T)             { return (a[0], a[1]) }
prefix func * <T> (a: [T]) -> (T, T, T)          { return (a[0], a[1], a[2]) }
prefix func * <T> (a: [T]) -> (T, T, T, T)       { return (a[0], a[1], a[2], a[3]) }
prefix func * <T> (a: [T]) -> (T, T, T, T, T)    { return (a[0], a[1], a[2], a[3], a[4]) }
prefix func * <T> (a: [T]) -> (T, T, T, T, T, T) { return (a[0], a[1], a[2], a[3], a[4], a[5]) }
func **(lhs: Int, rhs: Int) -> Int {
    return Int(pow(Double(lhs), Double(rhs)))
}
func **(lhs: Int, rhs: Double) -> Double {
    return pow(Double(lhs), rhs)
}
struct Stack<Element>: Collection {
    var items = [Element]()
    var startIndex: Int {
        return items.startIndex
    }
    var endIndex: Int {
        return items.endIndex
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
    func index(after index: Int) -> Int {
        return items.index(after: index)
    }
    mutating func push(_ item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeLast()
    }
}
struct Queue<Element>: Collection {
    var items = [Element]()
    var startIndex: Int {
        return items.startIndex
    }
    var endIndex: Int {
        return items.endIndex
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
    func index(after index: Int) -> Int {
        return items.index(after: index)
    }
    mutating func push(_ item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeFirst()
    }
}
struct Heap<Element: Comparable>: Collection {
    var items = [Element]()
    var startIndex: Int {
        return items.startIndex
    }
    var endIndex: Int {
        return items.endIndex
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
    func index(after index: Int) -> Int {
        return items.index(after: index)
    }
    mutating func push(_ item: Element) {
        var i = items.count
        while i > 0 {
            let p = (i - 1) / 2
            if items[p] <= item {
                break
            }
            if i == items.count {
                items.append(items[p])
            } else {
                items[i] = items[p]
            }
            i = p
        }
        if i == items.count {
            items.append(item)
        } else {
            items[i] = item
        }
    }
    mutating func pop() -> Element {
        let ret = items[0]
        let x = items[items.endIndex]
        var i: Int = 0
        while i * 2 + 1 < items.endIndex {
            var a = i * 2 + 1
            let b = i * 2 + 2
            if b < items.endIndex && items[b] < items[a] {
                a = b
            }
            if items[a] >= x {
                break
            }
            items[i] = items[a]
            i = a
        }
        items[i] = x
        items.removeLast()
        return ret
    }
}
extension Array where Element == Int {
    // condition が "<=" なら lower_bound, ">=" なら upper_bound
    func binarySearch(_ key: Int, _ condition: (Int, Int) -> Bool) -> Int {
        var ng = -1
        var ok = self.count
        if !condition(ng, ok) {
            swap(&ng, &ok)
        }
        while abs(ok - ng) > 1 {
            let mid = (ok + ng) / 2
            if condition(key, self[mid]) {
                ok = mid
            } else {
                ng = mid
            }
        }
        return ok
    }
}
extension Array where Element: Equatable {
    func count(of value: Element) -> Int {
        return self.reduce(0){$0+($1==value ? 1 : 0)}
    }
}
extension Array where Element: Hashable {
    func tally() -> Dictionary<Element, Int> {
        var dic = [Element: Int]()
        self.forEach{dic[$0, default: 0] += 1}
        return dic
    }
}
extension String {
    func count(of value: Character) -> Int {
        return self.reduce(0){$0+($1==value ? 1 : 0)}
    }
    func replaceCharacter(from: Character, to: Character) -> String {
        return String(self.map{$0==from ? to : $0})
    }
    func replaceSubstring(from: String, to: String) -> String {
        return self.replacingOccurrences(of: from, with: to)
    }
//    subscript(i: Int) -> Character {
//        return self.map{$0}[i]
//    }
//    subscript(range: Range<Int>) -> String {
//        return String(self.map{$0}[range])
//    }
}
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringsSplit(by separator: Character = " ") -> [String] {
    return readLine()!.split(separator: separator).map{String($0)}
}
func readIntsSplit(by separator: Character = " ") -> [Int] {
    return readLine()!.split(separator: separator).map{Int($0)!}
}
func gcd(_ x: Int, _ y: Int) -> Int {
    return y>0 ? gcd(y, x%y) : x
}
func lcm(_ x: Int, _ y: Int) -> Int {
    return x * y / gcd(x, y)
}
func primeNumbers(until n: Int) -> [Int] {
    var flags = Array(repeating: true, count: n+1)
    for i in 2...Int(n**0.5+0.5) {
        if flags[i] {
            for j in stride(from: i**2, to: n+1, by: i) {
                flags[j] = false
            }
        }
    }
    return (2...n).filter{flags[$0]}
}
func divisors(of n: Int) -> [Int] {
    var ret = [Int]()
    for i in 1...Int(n**0.5+0.5) {
        if n.isMultiple(of: i) {
            ret.append(i)
            if n/i != i {
                ret.append(n/i)
            }
        }
    }
    return ret.sorted()
}
// 2以下でRTE
func primeFactors(of n: Int) -> [Int] {
    var n = n
    var ret = Array(repeating: 0, count: n+1)
    for i in 2...Int(n**0.5+0.5) {
        while n.isMultiple(of: i) {
        ret[i] += 1
        n /= i
      }
    }
    if n != 1 {
        ret[n] = 1
    }
    return ret
}
func manhattanDist(_ x1: Int, _ y1: Int, _ x2: Int, _ y2: Int) -> Int {
    return abs(x1 - x2) + abs(y1 - y2)
}
func euclideanDist(_ x1: Int, _ y1: Int, _ x2: Int, _ y2: Int) -> Double {
    return sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
}
func elapsedTime() -> Double {
    return Date().timeIntervalSince(startTime)
}

/*************** メインプログラム ***************/

let D = readInt()!
let c = readIntsSplit()
let s = (0..<D).map{_ in readIntsSplit()}

func calcS(_ t: [Int]) -> Int {
    var last_d = Array(repeating: -1, count: 26)
    var S = 0
    for d in 0..<D {
        S += s[d][t[d]-1]
        last_d[t[d]-1] = d
        let c_sum = (0..<26).reduce(0){$0 + c[$1] * (d-last_d[$1])}
        S -= c_sum
    }
    return S
}

var t = (0..<D).map{$0%26+1}
for i in 0..<D {
    var index = 0
    var max = 0
    for j in 0..<26 {
        if s[i][j] > max {
            max = s[i][j]
            index = j
        }
    }
    t[i] = index+1
}
var S = calcS(t)

while elapsedTime() < 1.95 {
    let d = Int.random(in: 0..<D)
    let q = Int.random(in: 1...26)
    let old = t[d]
    t[d] = q
    if calcS(t) < S {
        t[d] = old
    }
}

t.forEach{print($0)}
//print(elapsedTime())