// Original C++ solution (slower):
#include <iostream>

#include <vector>

using namespace std;



int main()

{

	string str;

	cin >> str;

	vector<int> boundRL; //RとLの境界(の一つ右)

	vector<bool> isBoundRL(200000,false); //そこが境界かどうか

	vector<int> boundLR; //RとLの境界(の一つ右)

	vector<bool> isBoundLR(200000, false); //そこが境界かどうか

	vector<int> ans(200000, 0);

	boundRL.push_back(-1);

	boundLR.push_back(0);

	for (int i = 1; i < str.length(); i++)

	{

		if (str[i - 1] == 'R' and str[i] == 'L')

		{

			boundRL.push_back(i); //後ろにiを追加

	//		cout << i << endl;

			isBoundRL[i] = true;

		}

		if (str[i - 1] == 'L' and str[i] == 'R')

		{

			boundLR.push_back(i); //後ろにiを追加

	//		cout << i << endl;

			isBoundLR[i] = true;

		}

	}

	if(boundRL.back() != (str.length()-1))

		boundRL.push_back(str.length() - 1);



	if (boundLR.back() != (str.length()))

		boundLR.push_back(str.length());

	for (int i = 0; i < boundRL.size(); i++)

	{

//		cout << boundRL[i] << endl;

	}

	for (int i = 0; i < str.length(); i++)

	{

		if (!(isBoundRL[i] or isBoundRL[i+1] or isBoundLR[i] or isBoundLR[i + 1]))

		{

			ans[i] = 0;

		}

		else

		{

			if (isBoundRL[i])

			{

				int j = 1;

				while (i != boundRL[j])

				{

					j++;

				}

				int Rlength = boundRL[j] - boundLR[j - 1];

				int Llength = boundLR[j] - boundRL[j];

	//			cout << "L(L) : "<<Llength << endl;

	//			cout << "R(L) : " << Rlength << endl;

	//			ans[i] = (Rlength + Llength) / 2;

				ans[i] = (Rlength) / 2 + (Llength + 1) / 2;

	//			cout << "ans[" << i << "] = " << ans[i] << endl;

	//			ans[i] = -1;

			}

			else if (isBoundRL[i + 1])

			{

				int j = 1;

				while (i + 1 != boundRL[j])

				{

					j++;

				}

				int Rlength = boundRL[j] - boundLR[j-1];

				int Llength = boundLR[j] - boundRL[j];

	//			cout<<"L(R) : "<<Llength << endl;

	//			cout << "R(R) : " << Rlength << endl;

	//				ans[i] = (Rlength + Llength + 1) / 2;



				ans[i] = (Rlength + 1) / 2 + (Llength / 2);

	//			cout << "ans[" << i << "] = " << ans[i] << endl;

	//			ans[i] = -1;

			}

		}

	}

	cout << ans[0] << " ";

	for (int i = 1; i < str.length()-1; i++)

	{

		cout << ans[i] << " ";

	}

	cout << ans[str.length() - 1];

	

}




// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;

#define rep(i, n) for (int i = 0; i < (n); i++)

#define rep2(i, x, n) for (int i = x; i < (n); i++)

#define all(n) begin(n), end(n)

struct cww

{

    cww()

    {

        ios::sync_with_stdio(false);

        cin.tie(0);

    }

} star;

const long long INF = numeric_limits<long long>::max();

typedef long long ll;

typedef vector<int> vint;

typedef vector<char> vchar;

typedef vector<vector<int>> vvint;

typedef vector<ll> vll;

typedef vector<vector<ll>> vvll;

typedef unsigned long long ull;

template <class T>

bool chmax(T &a, const T &b)

{

    if (a < b)

    {

        a = b;

        return 1;

    }

    return 0;

}

template <class T>

bool chmin(T &a, const T &b)

{

    if (b < a)

    {

        a = b;

        return 1;

    }

    return 0;

}

template <typename T>

vector<T> make_v(size_t a) { return vector<T>(a); }



template <typename T, typename... Ts>

auto make_v(size_t a, Ts... ts)

{

    return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));

}

template <typename T, typename V>

typename enable_if<is_class<T>::value == 0>::type

fill_v(T &t, const V &v) { t = v; }



template <typename T, typename V>

typename enable_if<is_class<T>::value != 0>::type

fill_v(T &t, const V &v)

{

    for (auto &e : t)

        fill_v(e, v);

}

int main()

{

    string S;

    cin >> S;

    int N = S.size();

    vector<pair<char, int>> run;

    int cnt = 1;

    rep(i, N - 1)

    {

        if (S[i] == S[i + 1])

        {

            cnt++;

        }

        else

        {

            run.push_back({S[i], cnt});

            cnt = 1;

        }

    }

    run.push_back({S.back(), cnt});

    int j = 0;

    rep(i, N)

    {

        if (!(S[i] == 'R' and S[i + 1] == 'L'))

        {

            cout << 0 << " ";

        }

        else

        {

            cout << (run[j].second + 1) / 2 + (run[j + 1].second) / 2 << " " << run[j].second / 2 + (run[j + 1].second + 1) / 2 << " ";

            i++;

            j += 2;

        }

    }

    return 0;

}

// Fastest known solution for this problem: