import std.algorithm;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
import std.format;

auto dp (int n, int c, string s) {
  auto d = new int[n+1];
  d[n] = 0;
  foreach_reverse (i; 0 .. n) {
    debug stderr.writeln ("i = ", i);
    d[i] = d[i+1];
    if (s[i] == 'o') {
      int j = i + 1 + c;
      int v = (j <= n) ? d[j] : 0;
      d[i] = max (d[i], 1 + v); 
    }
  }
  return d;
}

bool[] go (string s, int n, int k, int c, in int[] d1, in int[] d2) {
  auto can = new bool[n];
  int last = -1;
  foreach (i; 0 .. n) {
    if (s[i] == 'x') continue;
    int v1 = 0, j = i + 1;
    if (last >= 0) {
      v1 = d2[last];
      j = max (j, last + 1 + c);
    }
    int v = v1;
    if (j < n) v += d1[j];
    debug stderr.writefln ("i = %d, j = %d, v1 = %d, v = %d", i, j, v1, v);
    if (v >= k) can[i] = true;
    last = i;
  }
  return can;
}

//Modification on semi-interval, single element access
final class SegmentTreeSliceUpdate(T = int) {
  private:
  T [] t;
  size_t n;
  pure nothrow @nogc
  void push () {
    foreach (i; 1 .. n) {
      immutable k = i << 1;
      t[k] = t[k] + t[i];
      t[k+1] = t[k+1] + t[i];
      t[i] = 0;
    }
  }
  pure nothrow @nogc
  void update (size_t l, size_t r, T v) {
    for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
      if (l & 1) {
        t[l++] += v;
      }
      if (r & 1) {
        t[--r] += v;
      }
    }
  }
  public:
  pure nothrow @nogc
  inout(T) opIndex (size_t index) inout {
     T res;
     for (index += n; index > 0; index >>= 1) {
       res += t[index];
     }
     return res;
  }
  pure nothrow
  const(T[]) force () {
    push ();
    return t[n .. 2 * n].idup;
  }
  pure nothrow
  this (int _n) {
    n = _n;
    t = new T[2 * n];
  }
}

void main() {
  int n, k, c;
  auto s = readln;
  formattedRead (s, " %d %d %d", &n, &k, &c);
  s = readln[0 .. n];
  if (c == 0) {
    auto cnt = s.count('o');
    if (cnt == k) {
      foreach (i; 0 .. n) if (s[i] == 'o') writeln (i+1);
    }
    return;
  }
  auto d1 = dp (n, c, s);
  d1.popBack ();
  auto t = s.dup;
  t.reverse ();
  auto s2 = t.idup;
  auto d2 = dp (n, c, s2);
  d2.reverse ();
  d2 = dropOne (d2);
  auto st = new SegmentTreeSliceUpdate!int (n);
  debug stderr.writeln ("d1 = ", d1);
  debug stderr.writeln ("d2 = ", d2);
  //d1 -> right
  //d2 -> left
  void upd (int u1, int u2) {
    debug stderr.writefln ("[%d, %d)", u1, u2);
    if (u1 < u2) st.update (u1, u2, 1);
  }
  foreach (i; 0 .. n) {
    if (s[i] == 'o') {
      debug stderr.writeln (i);
      int v = d2[i];
      int j = i + (c + 1);
      if (j < n) v += d1[j]; 
      if (v >= k) {
        upd (i + 1, min (j, n));
      }
      v = d1[i];
      j = i - (c + 1);
      if (j >= 0) v += d2[j]; 
      if (v >= k) {
        upd (max (0, j + 1), i);
      }
    }
  }
  foreach (i; 0 .. n) if (!st[i] && s[i] == 'o') writeln (i + 1);
}

