#include<iostream>
#include<cstdio>
#include<cstring>
#include <cstdlib>  
#include <math.h>
#include <cmath>
#include<complex>
#include<cctype>
#include<string>
#include<set>
#include<iomanip>
#include <map>
#include<algorithm>
#include <functional>
#include<vector>
#include<climits>
#include<stack>
#include<queue>
#include<bitset>
#include <deque>
#include <climits>
#include <typeinfo>
#include <utility> 
using namespace std;
using Complex = complex<double>;
using ll = long long;
template<typename T>using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
const ll inf = 1145141919810364364LL;
double PI = acos(-1.0);
#define all(x) (x).begin(),(x).end()
#define puts(x) cout << x << endl
#define rep(i,m,n) for(ll i = m;i < n;++i)
#define pb push_back
#define fore(i,a) for(auto &i:a)
#define rrep(i,m,n) for(ll i = m;i >= n;--i)

int N, K, C;
string S;
ll dp[2][202020][2];
ll dpl[202020], dpr[202020];

struct Segmenttree {
	static const int N = 1 << 20;
	vector<ll>seg;
	vector<ll>idx;
	void st(ll p, ll v) {
		p += N - 1;
		seg[p] = v;
		idx[p] = p - N + 1;
		while (p > 0) {
			p = (p - 1) / 2;
			seg[p] = max(seg[2 * p + 1], seg[2 * p + 2]);
			if (seg[2 * p + 1] < seg[2 * p + 2])idx[p] = idx[2 * p + 2];
			else if (seg[2 * p + 1] > seg[2 * p + 2])idx[p] = idx[2 * p + 1];
			else idx[p] = min(idx[2 * p + 1], idx[2 * p + 2]);
		}
	}
	pair<ll, ll> query(ll l, ll r, ll a, ll b, ll k) {
		if (r <= a || b <= l)return { -inf,inf };
		if (l <= a && b <= r)return { seg[k],idx[k] };
		ll m = (a + b) / 2;
		auto p1 = query(l, r, a, m, 2 * k + 1);
		auto p2 = query(l, r, m, b, 2 * k + 2);
		if (p1.first > p2.first) return p1;
		else if (p1.first < p2.first)return p2;
		else return { p1.first,min(p1.second,p2.second) };
	}

	void init() {
		seg.resize(2 * N);
		idx.resize(2 * N);
		for (int i = 0; i < 2 * N; i++)seg[i] = -inf;
	}
	//[l,r]
	ll get(int l, int r) {
		return query(l, r + 1, 0, N, 0).first;
	}
	ll getidx(int l, int r) {
		return query(l, r + 1, 0, N, 0).second;
	}
	pair<ll, ll>getp(int l, int r) {
		return query(l, r + 1, 0, N, 0);
	}
};

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);


	cin >> N >> K >> C >> S;

	for (int t = 0; t < 2; t++) {
		dp[t][0][0] = 0;
		dp[t][0][1] = (S[0] == 'o') ? 1 : -inf;
		for (int i = 1; i < N; i++) {
			dp[t][i][0] = max(dp[t][i - 1][0], dp[t][i - 1][1]);
			if (S[i] == 'x')dp[t][i][1] = -inf;
			else if (i - C - 1 < 0)dp[t][i][1] = 1;
			else dp[t][i][1] = max(dp[t][i - C - 1][0], dp[t][i - C - 1][1]) + 1;
		}
		reverse(all(S));
	}


	for (int i = 0; i < N; i++) {
		dpl[i] = max((i > 0) ? dpl[i - 1] : -inf, max(dp[0][i][0], dp[0][i][1]));
		dpr[i] = max((i > 0) ? dpr[i - 1] : -inf, max(dp[1][i][0], dp[1][i][1]));
	}

	Segmenttree seg = Segmenttree();
	seg.init();

	for (int l = 0; l < 3 * N; l++) {
		ll temp = 0;
		if (N <= l && l < 2 * N)temp += dpl[l-N];
		if (N <= l + C + 1 && l + C + 1 < 2 * N)temp += dpr[2*N-l-C-2];
		seg.st(l,temp);
	}


	for (int i = 0; i < N; i++) {
		if (S[i] == 'x')continue;
		ll temp = 0;
		temp = seg.get(N+i-C,N+i-1);
		if (C == 0) {
			ll xl = (i > 0) ? dpl[i - 1] : 0;
			ll xr = (i < N) ? dpr[N - i - C - 2] : 0;
			temp = max(temp,xl+xr);
		}
		if (temp < K)puts(i + 1);
	}

	return 0;
}

Measured memory_bytes: 44052