```go
package main

import (
	"bufio"
	"io"
	"os"
	"strconv"
)

type FastScanner struct {
	data []byte
	pos  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) skip() {
	for fs.pos < fs.n && fs.data[fs.pos] <= ' ' {
		fs.pos++
	}
}

func (fs *FastScanner) NextInt() int {
	fs.skip()
	sign := 1
	if fs.data[fs.pos] == '-' {
		sign = -1
		fs.pos++
	}
	val := 0
	for fs.pos < fs.n && fs.data[fs.pos] > ' ' {
		val = val*10 + int(fs.data[fs.pos]-'0')
		fs.pos++
	}
	return val * sign
}

func (fs *FastScanner) NextString() string {
	fs.skip()
	start := fs.pos
	for fs.pos < fs.n && fs.data[fs.pos] > ' ' {
		fs.pos++
	}
	return string(fs.data[start:fs.pos])
}

type Edge struct {
	to  int
	idx int
}

func startState(c byte) int {
	switch c {
	case 'k':
		return 0
	case 'o':
		return 1
	case 't':
		return 2
	case 'l':
		return 3
	case 'i':
		return 4
	default:
		return 5
	}
}

func main() {
	fs := NewFastScanner()
	n := fs.NextInt()

	adj := make([][]Edge, 6)

	for i := 1; i <= n; i++ {
		s := fs.NextString()
		st := startState(s[0])
		to := (st + len(s)) % 6
		adj[st] = append(adj[st], Edge{to: to, idx: i})
	}

	it := make([]int, 6)
	stackV := make([]int, 0, n+1)
	stackE := make([]int, 0, n)
	res := make([]int, 0, n)

	stackV = append(stackV, 0)

	for len(stackV) > 0 {
		v := stackV[len(stackV)-1]
		if it[v] < len(adj[v]) {
			e := adj[v][it[v]]
			it[v]++
			stackV = append(stackV, e.to)
			stackE = append(stackE, e.idx)
		} else {
			stackV = stackV[:len(stackV)-1]
			if len(stackE) > 0 {
				res = append(res, stackE[len(stackE)-1])
				stackE = stackE[:len(stackE)-1]
			}
		}
	}

	for i, j := 0, len(res)-1; i < j; i, j = i+1, j-1 {
		res[i], res[j] = res[j], res[i]
	}

	out := make([]byte, 0, n*7)
	for i, x := range res {
		if i > 0 {
			out = append(out, ' ')
		}
		out = strconv.AppendInt(out, int64(x), 10)
	}
	out = append(out, '\n')

	w := bufio.NewWriter(os.Stdout)
	w.Write(out)
	w.Flush()
}
```