//#include <cstdio>
#include <iostream>

#include <cstring>

#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
//#include <queue>
//#include <stack>
#include <cassert>

using namespace std;

#define SZ(a) int((a).size())
#define REP(i,n) for(int i=0,_n=(n);i<_n;++i)
#define FOR(i,a,b) for(int i=(a),_b=(b);i<=_b;++i)

#define DEBUG(x) cerr << #x << ": " << x << endl

typedef long long llong;
typedef vector<int> VI;
typedef vector<VI> VVI;

const int INF = 100000000;

#define MAXN 200004
int N, K, C;
char S[MAXN];

namespace DP_ON1 {

VI DPL, DPR;
int goL(int idx) {
   return idx > 0 ? DPL[idx] : 0;
}
int goR(int idx) {
   return idx <= N ? DPR[idx] : 0;
}

vector<int> solve() {
   DPL = VI(N+2);
   for (int idx = 1; idx <= N; ++idx) {
      DPL[idx] = DPL[idx-1];
      if (S[idx] == 'o') {
         if (idx-(C+1) <= 0)
            DPL[idx] = 1;
         else
            DPL[idx] = max(DPL[idx], DPL[idx-(C+1)] + 1);
      }
   }

   DPR = VI(N+2);
   for (int idx = N; idx >= 1; --idx) {
      DPR[idx] = DPR[idx+1];
      if (S[idx] == 'o') {
         if (idx+(C+1) > N)
            DPR[idx] = 1;
         else
            DPR[idx] = max(DPR[idx], DPR[idx+(C+1)] + 1);
      }
   }

   VI earliest(N+2);
   earliest[0] = 0;
   for (int idx = 1; idx <= N; ++idx) {
      if (DPL[idx] == DPL[idx-1])
         earliest[idx] = earliest[idx-1];
      else
         earliest[idx] = idx;
   }
   
   VI latest(N+2);
   latest[N+1] = N+1;
   for (int idx = N; idx >= 1; --idx) {
      if (DPR[idx] == DPR[idx+1])
         latest[idx] = latest[idx+1];
      else
         latest[idx] = idx;
   }

   vector<int> res;
   FOR(idx, 1, N) {
      if (S[idx] == 'x') continue;

      int pre = earliest[idx-1];
      int post = latest[idx+1];

      int max_cnt;
      if (post-pre >= C+1) {
         max_cnt = goL(pre) + goR(post);
      }
      else {
         int cnt1 = goL(pre) +
                    goR(max(pre + (C+1), post));
         int cnt2 = goL(min(post - (C+1), pre)) +
                    goR(post);
         max_cnt = max(cnt1, cnt2); 
      }
      if (max_cnt < K) {
         res.push_back(idx);
      }
   }

   return res;
}

}


namespace DP_ON2 {

int memo[MAXN];
int go(int idx) {
   if (idx > N)
      return 0;
   int& res = memo[idx];
   if (res < 0) {
      res = go(idx+1);
      if (S[idx] == 'o')
         res = max(res, go(idx + (C+1))+1);
   }
   return res;
}

vector<int> solve() {
   memset(memo, -1, sizeof(memo[0])*(N+2));
   assert( go(1) >= K );

   vector<int> res;
   FOR(idx, 1, N) {
      if (S[idx] == 'x') continue;
      S[idx] = 'x';

      memset(memo, -1, sizeof(memo[0])*(N+2));
      if (go(1) < K)
         res.push_back(idx);

      S[idx] = 'o';
   }
   return res;
}

}


int main(int argc, char* argv[]) {
   ios_base::sync_with_stdio(false); 
   cin.tie(nullptr);

   cin >> N >> K >> C;
   assert(N < MAXN);
   
   cin >> (S+1);

   VI res1 = DP_ON1::solve();
   for (int x : res1)
      cout << x << '\n';

/*
   srand(123);
   for (int tc = 0; tc < 100000; ) {
      N = 1 + rand() % 20;
      K = 1 + rand() % N;
      C = rand() % (N+1);
      int R = 2 + rand() % 8;
      FOR(idx, 1, N)
         S[idx] = (rand() % R) == 0 ? 'o' : 'x';
      S[N+1] = 0;

      memset(DP_ON2::memo, -1, sizeof(DP_ON2::memo[0])*(N+2));
      if (DP_ON2::go(1) >= K) {
         ++tc;
      // cerr << "Test #" << tc << endl;
         VI res1 = DP_ON1::solve();
         VI res2 = DP_ON2::solve();
         if (res1 != res2) {
            cerr << "Failed test #" << tc << endl;
            cerr << N << ' ' << K << ' ' << C << endl;
            cerr << (S+1) << endl;
            for (int x : res1)
               cerr << x << ' ';
            cerr << endl;
            for (int x : res2)
               cerr << x << ' ';
            cerr << endl;
            break;
         }
      }
   }
*/

   return 0;
}


Measured memory_bytes: 4728