#include <bits/stdc++.h>

using namespace std;

#define sz(x) (int) x.size()
#define all(a) a.begin(), a.end()

const int MAXN = 4 * 105000;

class SegmentTree {
private:
  const long long INF = 1e18;
  struct Node {
    long long mx, mn;
    long long add;
  };
  vector<Node> tree;
  int n;

  void add(int v, int L, int R, int l, int r, long long val) {
    if (l > r) {
      return;
    }
    if (L == l && R == r) {
      tree[v].add += val;
    } else {
      int mid = L + (R - L) / 2;
      add(2 * v + 1, L, mid, l, min(mid, r), val);
      add(2 * v + 2, mid + 1, R, max(mid + 1, l), r, val);
      tree[v].mx = max(tree[2 * v + 1].mx + tree[2 * v + 1].add, tree[2 * v + 2].mx + tree[2 * v + 2].add);
      tree[v].mn = min(tree[2 * v + 1].mn + tree[2 * v + 1].add, tree[2 * v + 2].mn + tree[2 * v + 2].add);
    }
  }

  long long getMin(int v, int L, int R, int l, int r) {
    if (l > r) {
      return INF;
    }
    if (L == l && R == r) {
      return tree[v].mn + tree[v].add;
    }
    int mid = L + (R - L) / 2;
    return tree[v].add + min(getMin(2 * v + 1, L, mid, l, min(mid, r)), getMin(2 * v + 2, mid + 1, R, max(l, mid + 1), r));
  }

  long long getMax(int v, int L, int R, int l, int r) {
    if (l > r) {
      return -INF;
    }
    if (L == l && R == r) {
      return tree[v].mx + tree[v].add;
    }
    int mid = L + (R - L) / 2;
    return tree[v].add + max(getMax(2 * v + 1, L, mid, l, min(mid, r)), getMax(2 * v + 2, mid + 1, R, max(l, mid + 1), r));
  }
public:
  void init(int sz) {
    n = sz;
    tree.assign(4 * n, {0, 0, 0});
  }

  // l, r are in [0, n - 1]
  void add(int l, int r, long long val) {
    add(0, 0, n - 1, l, r, val);
  }

  // l, r are in [0, n - 1]
  long long getMin(int l, int r) {
    return getMin(0, 0, n - 1, l, r);
  }

  // l, r are in [0, n - 1]
  long long getMax(int l, int r) {
    return getMax(0, 0, n - 1, l, r);
  }  
};

int n, need, c;
string s;
int l[MAXN], r[MAXN];
vector<int> bound;

int main() {

    scanf("%d %d %d\n", &n, &need, &c);
    getline(cin, s);

    for (int i = n - 1; i >= 0; i--) {
        r[i] = r[i + 1];
        if (s[i] == 'o') {
            r[i] = max(r[i], 1 + r[i + c + 1]);
        }
    }

    for (int i = 0; i < n; i++) {
        if (i > 0)
            l[i] = l[i - 1];

        if (i - c >= 0 && s[i - c] == 'o') {
            l[i] = max(l[i], 1 + (i - c - 1 >= 0 ? l[i - c - 1] : 0));
        }
    }

    SegmentTree tree;
    tree.init(n);

    for (int i = 0; i < n; i++) {
        int before = 0;
        if (i > 0) before = l[i - 1];
        int after = 0;
        if (i + 1 < n) after = r[i + 1];

        if (before + after >= need) {
            tree.add(i, i, 1);
        }
    }

    for (int i = 0; i < n; i++) {
        int cur = l[i];
        if (i + 1 < n) cur += r[i + 1];

        if (c > 0 && cur >= need) {
            tree.add(max(0, i - c + 1), i, 1);
        }
    }

    for (int i = 0; i < n; i++) {
        int cur = 0;
        if (i > 0) cur = l[i - 1];
        if (i + c + 1 < n) cur += r[i + c + 1];
        if (s[i] == 'o') cur++;

        if (i + 1 < n && c > 0 && cur >= need) {
            tree.add(i + 1, min(n - 1, i + c), 1);
        }
    }

    for (int i = 0; i < n; i++) {
        if (s[i] == 'o' && tree.getMin(i, i) == 0) {
            printf("%d\n", i + 1);
        }
    }

    return 0;
}


Measured memory_bytes: 22148