import java.io.BufferedWriter
import java.nio.file.Files
import java.nio.file.Paths
import java.util.*


/**
 * Created by damm1t.
 */
var MAXN: Int = 1005
var t = Array(MAXN) {IntArray(MAXN)}
var inserted = BooleanArray(MAXN) {false}
var mas = mutableListOf<Int>()

fun merge(mas: ArrayList<Int>, l: Int, middle: Int, r: Int) {
    var i = 0
    var j = 0
    var k: Int = l
    val sizeLeft = middle - l + 1
    val sizeRight = r - middle
    val left = ArrayList<Int>()
    val right = ArrayList<Int>()

    while (i < sizeLeft) {
        left.add(mas[l + i])
        i++
    }
    while (j < sizeRight) {
        right.add(mas[middle + 1 + j])
        j++
    }
    i = 0
    j = 0
    while (i < sizeLeft && j < sizeRight) {
        if (t[left[i]][right[j]] == 1) {
            mas[k] = left[i]
            i++
        } else {
            mas[k] = right[j]
            j++
        }
        k++
    }
    while (i < sizeLeft) {
        mas[k] = left[i]
        i++
        k++
    }
    while (j < sizeRight) {
        mas[k] = right[j]
        j++
        k++
    }
}

fun mergeSort(mas: ArrayList<Int>, l: Int, r: Int) {
    if (l < r) {
        val m = l + (r - l) / 2
        mergeSort(mas, l, m)
        mergeSort(mas, m + 1, r)
        merge(mas, l, m, r)
    }
}

fun main(args: Array<String>) {
    val file = "guyaury"

    Files.newBufferedReader(Paths.get("$file.in")).use { fin ->
        var n = fin.readLine().toInt()
        mas.add(0)
        inserted[0] = true
        t[0][0] = 2
        for (i in 0 until n)
        {
            t[i][i] = 2
            val ch = fin.readLine()
            for (j in 0 until i)
            {
                t[i][j] = ch[j].toInt() - 48
                t[j][i] = t[i][j] xor 1
            }
        }
        val vertex = ArrayList<Int>()

        for (i in 0 until n) {
            vertex.add(i)
        }
        mergeSort(vertex, 0, n - 1)
        Files.newBufferedWriter(Paths.get("$file.out")).use { fout ->
            while (t[vertex[n - 1]][vertex[0]] != 1) {
                vertex.shuffle()
                mergeSort(vertex, 0, n - 1)
            }
            for (i in 0 until n) {
                fout.writeSpace(vertex[i] + 1)
            }
        }
    }
}

private fun BufferedWriter.writeLine(s: String) {
    this.write(s)
    this.write("\n")
}

private fun BufferedWriter.writeSpace(s: Int) {
    this.write(s.toString() + ' ')
}

private fun BufferedWriter.writeLine(s: Int) {
    this.writeLine(s.toString())
}