#include <bits/stdc++.h>
using namespace std;
const int N = 100500;
const int LL = 0;
const int RR = 1;
const int LR = 2;
const int RL = 3;
int n;
char s[N];
vector<int> seq[4];
list<int> lst[N];
int lst_size;
int get_ending(vector<int> ending[], int type) {
  if (ending[type].empty()) {
    ending[type].push_back(lst_size);
    lst_size++;
  }
  int ind = ending[type].back();
  ending[type].pop_back();
  return ind;
}
int get_type(int ind) {
  char a = s[*lst[ind].begin()];
  char b = s[*lst[ind].rbegin()];
  if (a == 'L' && b == 'L') return LL;
  if (a == 'R' && b == 'R') return RR;
  if (a == 'L' && b == 'R') return LR;
  return RL;
}
void split() {
  vector<int> ending[2];
  for (int i = 0; i < n; i++) {
    int ind = get_ending(ending, s[i] == 'L' ? RR : LL);
    lst[ind].insert(lst[ind].end(), i);
    ending[s[i] == 'L' ? LL : RR].push_back(ind);
  }
  for (int i = 0; i < lst_size; i++) seq[get_type(i)].push_back(i);
}
int get_seq_size() {
  int sum = 0;
  for (int i = 0; i < 4; i++) sum += (int)seq[i].size();
  return sum;
}
template <typename T>
T pop(vector<T> &v) {
  T x = v.back();
  v.pop_back();
  return x;
}
bool can_unite(int ta, int tb) {
  if ((ta == LL || ta == RL) && (tb == RL || tb == RR)) return true;
  if ((ta == LR || ta == RR) && (tb == LL || tb == LR)) return true;
  return false;
}
int unite(int a, int b) {
  if (a == -1) return b;
  if (b == -1) return a;
  if (!can_unite(get_type(a), get_type(b))) swap(a, b);
  assert(can_unite(get_type(a), get_type(b)));
  lst[a].splice(lst[a].end(), lst[b]);
  return a;
}
void check(list<int> &l, int ans) {
  int backward = 0;
  int prv = -1;
  for (int e : l) {
    assert(prv == -1 || s[e] != s[prv]);
    if (e < prv) backward++;
    prv = e;
  }
  assert(backward == ans);
}
void combine() {
  int ans = get_seq_size() - 1;
  int type = (int)seq[LL].size() >= (int)seq[RR].size() ? LL : RR;
  int united = -1;
  while (true) {
    if (seq[type].empty()) break;
    united = unite(united, pop(seq[type]));
    type = LL ? RR : LL;
  }
  if (united != -1) seq[get_type(united)].push_back(united);
  united = -1;
  for (int ind : seq[LR]) united = unite(united, ind);
  seq[LR].clear();
  if (united != -1) seq[get_type(united)].push_back(united);
  united = -1;
  for (int ind : seq[RL]) united = unite(united, ind);
  seq[RL].clear();
  if (united != -1) seq[get_type(united)].push_back(united);
  if (!seq[LR].empty() && !seq[RL].empty()) {
    int a = pop(seq[LR]);
    int b = pop(seq[RL]);
    if (*lst[a].rbegin() > *lst[b].rbegin()) swap(a, b);
    int tail = *lst[b].rbegin();
    lst[b].erase(prev(lst[b].end()));
    lst[a].insert(lst[a].end(), tail);
    united = unite(a, b);
    seq[get_type(united)].push_back(united);
  }
  united = -1;
  if (!seq[LL].empty())
    united = pop(seq[LL]);
  else if (!seq[RR].empty())
    united = pop(seq[RR]);
  if (!seq[LR].empty())
    united = unite(united, pop(seq[LR]));
  else if (!seq[RL].empty())
    united = unite(united, pop(seq[RL]));
  assert(get_seq_size() == 0);
  assert(united != -1);
  check(lst[united], ans);
  printf("%d\n", ans);
  for (int e : lst[united]) printf("%d ", e + 1);
  printf("\n");
}
void solve() {
  scanf("%s", s);
  n = strlen(s);
  split();
  combine();
}
int main() {
  solve();
  0;
  return 0;
}
