private data class Range(val l: Int, val r: Int, val c: Int)

fun main(args: Array<String>) {
    var inputs = readLine()!!

    // 文字列内の RL 区間をそれぞれ求める
    // RL の境目に吸い込まれる筈間違いない
    // 境目と範囲を求める

    var ranges = mutableListOf<Range>()
    var preIsR = true
    var preIsL = false

    var start = 0
    var end = 0
    var center = 0
    inputs = "${inputs}R"

    for (i in 1 until inputs.length) {

        val c = inputs[i]

        if (c == 'R' && preIsR) {
            // R が続いている時
            continue
        }

        if (c == 'R' && preIsL) {
            // L R となった時
            preIsR = true
            preIsL = false
            end = i - 1
            ranges.add(Range(start, end, center))

            start = i
            continue
        }

        if (c == 'L' && preIsR) {
            // R L となった時
            // 収束する場所
            preIsR = false
            preIsL = true
            center = i
            continue
        }

        if (c == 'L' && preIsL) {
            // L が続いている時
            continue
        }
    }

    // 求めた区間での収束位置を判定する
    var ans = LongArray(inputs.length-1) { 0L }.toMutableList()

    val res = powMod(10, 100, 2)
    for (range in ranges) {
        for (j in (range.l)..(range.r)) {
            val dist = Math.abs(range.c - j)

            if (minusMod(res, dist.toLong(), 2) == 0L) {
                ans[range.c] += 1L
            } else {
                ans[range.c - 1] += 1L
            }
        }
    }

    var ansString = ans.joinToString(" ")
    println(ansString)

}

fun plusMod(a: Long, b: Long, modVal: Long): Long {
    return (a + b) % modVal
}

fun minusMod(a: Long, b: Long, modVal: Long): Long {
    return (a - b + modVal) % modVal
}

fun timesMod(inputs: List<Long>, modVal: Long): Long {
    return inputs.reduce { acc, i -> (acc % modVal) * (i % modVal) % modVal }
}

/**
 * a^n mod modVal を計算する
 * 二分累乗法で累乗計算を O(logN) で行いつつ，OverFlow を避けるため適宜 mod 計算を行う
 */
fun powMod(a: Long, n: Long, modVal: Long, ans: Long = 1): Long {

    if (n == 0L) {
        return ans
    }

    // ビット演算の結果 2^0 の桁が 0 の場合は ans に掛けずに次の桁へ
    if (n.and(1L) == 0L) {
        return powMod(a * a % modVal, n.shr(1), modVal, ans)
    }

    // ビット演算の結果 2^9 の桁が 1 の場合は ans を更新
    return powMod(a * a % modVal, n.shr(1), modVal, ans * a % modVal)
}


/**
 * 二分累乗法の実装 a^N を O(logN) で計算
 * 指数部分を２進数で考える -> 指数が2^n になっていなくても問題ない
 */
private fun pow(a: Long, n: Long, ans: Long = 1): Long {

    if (n == 0L) {
        return ans
    }

    // ビット演算の結果 2^0 の桁が 0 の場合は ans に掛けずに次の桁へ
    if (n.and(1L) == 0L) {
        return pow(a * a, n.shr(1), ans)
    }

    // ビット演算の結果 2^0 の桁が 1 の場合は ans を更新
    return pow(a * a, n.shr(1), ans * a)
}