FEB

#include <bits/stdc++.h>
using namespace std;
 
int main() {
	int n;
	cin >> n;
	string s;
	cin >> s;
 
	int mn = 0, mx = 0;
 
	int cur_idx = 0;
	while (cur_idx < n) {
		if (s[cur_idx] == 'F') {
			cur_idx++;
			continue;
		}
 
		int next_idx = cur_idx + 1;
		while (next_idx < n && s[next_idx] == 'F') { next_idx++; }
		if (next_idx == n) { break; }
 
		int num_F = next_idx - cur_idx - 1;
 
		if (s[next_idx] == s[cur_idx]) {
			// Caso 1: Resolver algo como BFFFFFB
			int length = num_F + 2;
 
			// Primero, resolver mn
			if (length % 2 == 0) {
				// En el mejor caso podemos tener algo como BEBEBB
				mn += 1;
			} else {
				// Podemos alternar BEBEB
				mn += 0;
			}
 
			// Luego, resolver mx
			mx += length - 1;
		} else {
			// Caso 2: Resolver algo como BFFFFFE
			int length = num_F + 2;
 
			// Primero, resolver mn
			if (length % 2 == 0) {
				// Podemos alternar BEBEBE
				mn += 0;
			} else {
				// En el mejor caso tenemos BEBEE
				mn += 1;
			}
 
			// Luego, resolver mx
			mx += length - 2;
		}
 
		cur_idx = next_idx;
	}
 
	// Caso especial: F's al inicio / al final
	int num_beginning_F = 0;
	while (num_beginning_F < n && s[num_beginning_F] == 'F') num_beginning_F++;
	int num_ending_F = 0;
	while (num_ending_F < n && s[n - 1 - num_ending_F] == 'F') num_ending_F++;
 
	if (num_beginning_F == n) {
		// ¡todo es F! caso especial
		mn = 0;
		mx = n - 1;
	} else {
		// mn no cambia, ya que siempre podemos alternar el inicio /
		// el final de forma correcta
		mx += num_beginning_F;
		mx += num_ending_F;
	}
 
	vector<int> possible_levels;
	if (num_beginning_F == 0 && num_ending_F == 0) {
		// Caso especial: solo podemos cambiar en incrementos de dos
		assert((mx - mn) % 2 == 0);
		for (int i = mn; i <= mx; i += 2) possible_levels.push_back(i);
	} else {
		for (int i = mn; i <= mx; i++) possible_levels.push_back(i);
	}
 
	cout << possible_levels.size() << endl;
	for (int i : possible_levels) { cout << i << endl; }
}

import java.io.*;
import java.util.*;
 
public class FEB {
	public static void main(String[] args) {
		Kattio io = new Kattio();
 
		int n = io.nextInt();
		String s = io.next();
 
		int mn = 0, mx = 0;
 
		int curIdx = 0;
		while (curIdx < n) {
			if (s.charAt(curIdx) == 'F') {
				curIdx++;
				continue;
			}
 
			int nextIdx = curIdx + 1;
			while (nextIdx < n && s.charAt(nextIdx) == 'F') { nextIdx++; }
			if (nextIdx == n) { break; }
 
			int numF = nextIdx - curIdx - 1;
			if (s.charAt(nextIdx) == s.charAt(curIdx)) {
				// Caso 1: Resolver algo como BFFFFFB
				int length = numF + 2;
 
				// Primero, resolver mn
				if (length % 2 == 0) {
					// En el mejor caso podemos tener algo como BEBEBB
					mn += 1;
				} else {
					// Podemos alternar BEBEB
					mn += 0;
				}
 
				// Luego, resolver mx
				mx += length - 1;
			} else {
				// Caso 2: Resolver algo como BFFFFFE
				int length = numF + 2;
 
				// Primero, resolver mn
				if (length % 2 == 0) {
					// Podemos alternar BEBEBE
					mn += 0;
				} else {
					// En el mejor caso tenemos BEBEE
					mn += 1;
				}
 
				// Luego, resolver mx
				mx += length - 2;
			}
			curIdx = nextIdx;
		}
 
		// Caso especial: F's al inicio / al final
		int numBeginningF = 0;
		while (numBeginningF < n && s.charAt(numBeginningF) == 'F') { numBeginningF++; }
 
		int numEndingF = 0;
		while (numEndingF < n && s.charAt(n - 1 - numEndingF) == 'F') { numEndingF++; }
 
		if (numBeginningF == n) {
			// ¡todo es F! caso especial
			mn = 0;
			mx = n - 1;
		} else {
			// mn no cambia, ya que siempre podemos alternar el inicio /
			// el final de forma correcta
			mx += numBeginningF;
			mx += numEndingF;
		}
 
		List<Integer> possibleLevels = new ArrayList<>();
		if (numBeginningF == 0 && numEndingF == 0) {
			// Caso especial: solo podemos cambiar en incrementos de dos
			assert (mx - mn) % 2 == 0;
			for (int i = mn; i <= mx; i += 2) { possibleLevels.add(i); }
		} else {
			for (int i = mn; i <= mx; i++) { possibleLevels.add(i); }
		}
 
		io.println(possibleLevels.size());
		for (int i : possibleLevels) { io.println(i); }
		io.close();
	}
 
	// CodeSnip{Kattio}
}

n = int(input())
s = input()
 
mn = 0
mx = 0
 
cur_idx = 0
while cur_idx < n:
	if s[cur_idx] == "F":
		cur_idx += 1
		continue
 
	next_idx = cur_idx + 1
	while next_idx < n and s[next_idx] == "F":
		next_idx += 1
 
	if next_idx == n:
		break
 
	num_F = next_idx - cur_idx - 1
	if s[next_idx] == s[cur_idx]:
		# Caso 1: Resolver algo como BFFFFFB
		length = num_F + 2
 
		# Primero, resolver mn
		if length % 2 == 0:
			# En el mejor caso podemos tener algo como BEBEBB
			mn += 1
		else:
			# Podemos alternar BEBEB
			mn += 0
 
		# Luego, resolver mx
		mx += length - 1
	else:
		# Caso 2: Resolver algo como BFFFFFE
		length = num_F + 2
 
		# Primero, resolver mn
		if length % 2 == 0:
			# Podemos alternar BEBEBE
			mn += 0
		else:
			# En el mejor caso tenemos BEBEE
			mn += 1
 
		# Luego, resolver mx
		mx += length - 2
 
	cur_idx = next_idx
 
 
# Caso especial: F's al inicio / al final
num_beginning_F = 0
while num_beginning_F < n and s[num_beginning_F] == "F":
	num_beginning_F += 1
 
 
num_ending_F = 0
while num_ending_F < n and s[n - 1 - num_ending_F] == "F":
	num_ending_F += 1
 
 
if num_beginning_F == n:
	# ¡todo es F! caso especial
	mn = 0
	mx = n - 1
else:
	# mn no cambia, ya que siempre podemos alternar el inicio /
	# el final de forma correcta
	mx += num_beginning_F
	mx += num_ending_F
 
 
possible_levels = []
if num_beginning_F == 0 and num_ending_F == 0:
	# Caso especial: solo podemos cambiar en incrementos de dos
	assert (mx - mn) % 2 == 0
	for i in range(mn, mx + 1, 2):
		possible_levels.append(i)
 
else:
	for i in range(mn, mx + 1):
		possible_levels.append(i)
 
print(len(possible_levels))
for i in possible_levels:
	print(i)

#include <algorithm>
#include <iostream>
#include <vector>
 
using std::endl;
using std::vector;
 
int main() {
	int n;
	std::string s;
	std::cin >> n >> s;
 
	if (std::count(s.begin(), s.end(), 'F') == n) { s[0] = 'E'; }
 
	vector<int> positions;
	for (int i = 0; i < n; i++) {
		if (s[i] != 'F') { positions.push_back(i); }
	}
 
	int ones = positions[0] + n - 1 - positions.back();
 
	int mn = 0;
	int mx = 0;
 
	for (int i = 0; i < positions.size() - 1; i++) {
		int a = positions[i];
		int b = positions[i + 1];
		mn += ((b - a) & 1) ^ (s[a] != s[b]);
		mx += b - a - (s[a] != s[b]);
	}
 
	vector<int> ans;
	for (int i = mn; i <= ones + mx; i += (ones == 0 ? 2 : 1)) { ans.push_back(i); }
 
	std::cout << ans.size() << endl;
	for (int i : ans) { std::cout << i << endl; }
}

import java.io.*;
import java.util.*;
 
public class FEB {
	public static void main(String[] args) {
		Kattio io = new Kattio();
 
		int n = io.nextInt();
		String s = io.next();
 
		if (s.chars().filter(c -> c == 'F').count() == n) { s = "E" + s.substring(1); }
 
		List<Integer> positions = new ArrayList<>();
		for (int i = 0; i < n; i++) {
			if (s.charAt(i) != 'F') { positions.add(i); }
		}
 
		int ones = positions.get(0) + n - 1 - positions.get(positions.size() - 1);
 
		int mn = 0;
		int mx = 0;
 
		for (int i = 0; i < positions.size() - 1; i++) {
			int a = positions.get(i);
			int b = positions.get(i + 1);
			mn += ((b - a) & 1) ^ (s.charAt(a) != s.charAt(b) ? 1 : 0);
			mx += b - a - (s.charAt(a) != s.charAt(b) ? 1 : 0);
		}
 
		List<Integer> ans = new ArrayList<>();
		for (int i = mn; i <= ones + mx; i += (ones == 0 ? 2 : 1)) { ans.add(i); }
 
		io.println(ans.size());
		for (int i : ans) { io.println(i); }
 
		io.close();
	}
 
	// CodeSnip{Kattio}
}

N = int(input())
S = list(input())
if S.count("F") == N:
	S[0] = "E"
positions = [i for i in range(N) if S[i] != "F"]
ones = positions[0] + N - 1 - positions[-1]
mn, mx = 0, 0
for a, b in zip(positions, positions[1:]):
	mn += ((b - a) & 1) ^ (S[a] != S[b])
	mx += b - a - (S[a] != S[b])
ans = range(mn, ones + mx + 1, 1 + (ones == 0))
print(len(ans))
for level in ans:
	print(level)