import java.io.{BufferedOutputStream, BufferedReader, InputStreamReader, PrintWriter}
import java.lang

import scala.annotation.tailrec
import scala.reflect.ClassTag

object Main {
  def get[T: ClassTag](implicit in: BufferedReader, converter: String => T): T = {
    converter(in.readLine)
  }

  def getArray[T: ClassTag](implicit in: BufferedReader, converter: String => T): Array[T] = {
    get[String].split("\\s+").map(converter)
  }

  implicit val intConverter: String => Int = s => Integer.parseInt(s)
  implicit val longConverter: String => Long = s => lang.Long.parseLong(s)

  def get[T1, T2](
                   implicit in: BufferedReader,
                   converter1: String => T1,
                   converter2: String => T2
                 ): (T1, T2) = {
    getArray[String] match {
      case Array(v1, v2) => (converter1(v1), converter2(v2))
    }
  }

  def get[T1, T2, T3](
                       implicit in: BufferedReader,
                       converter1: String => T1,
                       converter2: String => T2,
                       converter3: String => T3
                     ): (T1, T2, T3) = {
    getArray[String] match {
      case Array(v1, v2, v3) => (converter1(v1), converter2(v2), converter3(v3))
    }
  }

  implicit class TimesInt(val n: Int) {
    def times(f: Int => Unit): Unit = {
      for (i <- 0 until n) {
        f(i)
      }
    }
  }

  def main(args: Array[String]): Unit = {
    implicit val in: BufferedReader = new BufferedReader(new InputStreamReader(System.in))
    val out = new PrintWriter(new BufferedOutputStream(System.out))
    val (n, k, c) = get[Int, Int, Int]
    val s = get[String]

    val mins = Array.fill(k)(Int.MaxValue)

    @tailrec
    def updateEager(today: Int, work: Int, off: Int, calendar: List[Char]): Unit = {
      if (work != 0) {
        calendar match {
          case Nil =>
          case 'x' :: rest =>
            updateEager(today + 1, work, Math.max(off - 1, 0), rest)
          case 'o' :: rest =>
            if (off > 0) {
              updateEager(today + 1, work, off - 1, rest)
            } else {
              mins(k - work) = today
              updateEager(today + 1, work - 1, c, rest)
            }
          case x => throw new Error(x.toString())
        }
      }
    }
    updateEager(0, k, 0, s.toList)

    val maxs = Array.fill(k)(Int.MinValue)
    @tailrec
    def updateLazier(today: Int, work: Int, off: Int, calendar: List[Char]): Unit = {
      if (work != 0) {
        calendar match {
          case Nil =>
          case 'x' :: rest =>
            updateLazier(today - 1, work, Math.max(off - 1, 0), rest)
          case 'o' :: rest =>
            if (off > 0) {
              updateLazier(today - 1, work, off - 1, rest)
            } else {
              maxs(work - 1) = today
              updateLazier(today - 1, work - 1, c, rest)
            }
          case x => throw new Error(x.toString())
        }
      }
    }
    updateLazier(n - 1, k, 0, s.toList.reverse)

    mins.zip(maxs).foreach {
      case (min, max) =>
        if (min == max) {
          out.println(min + 1)
        }
    }

    out.flush()
  }
}