Problem: Jack has become a soldier now. Unfortunately, he has trouble with the drill. Instead of marching beginning with the left foot and then changing legs with each step, as ordered, he keeps repeating a sequence of steps, in which he sometimes makes the wrong steps or — horror of horrors! — stops for a while. For example, if Jack uses the sequence 'right, left, break', when the sergeant yells: 'Left! Right! Left! Right! Left! Right!', Jack first makes a step with the right foot, then one with the left foot, then he is confused and stops for a moment, then again - this time according to the order - starts with the right foot, then uses the left foot, then - to the sergeant's irritation - he stops to catch his breath, to incorrectly start with the right foot again... Marching this way, Jack will make the step that he is supposed to in the given moment in only one third of cases.

When the officers convinced him he should do something about it, Jack decided to modify the basic sequence of steps that he repeats. However, in order not to get too tired, he has decided that the only thing he'll do is adding any number of breaks in any positions of the original sequence (a break corresponds to stopping for the duration of one step). Of course, Jack can't make a step on the same foot twice in a row, if there is no pause between these steps. It is, however, not impossible that the sequence of steps he used so far is incorrect (it would explain a lot, actually).

Help Private Jack! Given the sequence of steps he keeps repeating, calculate the maximal percentage of time that he can spend marching correctly after adding some breaks to his scheme.

Input

The first line of input contains a sequence consisting only of characters 'L', 'R' and 'X', where 'L' corresponds to a step with the left foot, 'R' — with the right foot, and 'X' — to a break. The length of the sequence will not exceed 106.

Output

Output the maximum percentage of time that Jack can spend marching correctly, rounded down to exactly six digits after the decimal point.

Examples

Input

X


Output

0.000000


Input

LXRR


Output

50.000000

Note

In the second example, if we add two breaks to receive LXXRXR, Jack will march: LXXRXRLXXRXRL... instead of LRLRLRLRLRLRL... and will make the correct step in half the cases. If we didn't add any breaks, the sequence would be incorrect — Jack can't step on his right foot twice in a row.

Solution (in JAVA):

Solution:
/**
 * Codeforces Beta Round #11
 * 
 * @author ProjectYoung
 * @keyword greedy
 * @time O(n)
 */

import java.util.Scanner;

public class CF11E {
  // The sequence can be divided into several subsequences, correct ones and incorrect ones, each of
  // them has only correct (incorrect resp.) steps and breaks. For example, XLRLRLXRXLR can be
  // divided into X + LRLRLX + RX + LR. The main idea is to insert breaks between two different
  // subsequence to make the sequence correct. Noticing that the subsequence with only one step
  // doesn't always need to be corrected, because maybe it isn't worth correcting one step by add
  // two breaks (one before it and one after).
  private static long calc(char[] seq) {
    // The number of correct steps.
    int correct = 0;
    // The total number of steps.
    int total = 0;
    // The number of steps in the current subsequence.
    int step = 0;
    // The number of subsequence which has only one step besides the breaks.
    int single = 0;
    // If the previous subsequence with only one step is worth correcting.
    boolean worth = true;
    // If the current index is odd.
    boolean odd = true;
    // The first subsequence doesn't need correcting.
    int i = 0;
    while (i < seq.length && (seq[i] == 'X' || (seq[i] == 'L' && odd) || (seq[i] == 'R' && !odd))) {
      if (seq[i] != 'X') {
        correct++;
      }
      total++;
      i++;
      odd = !odd;
    }
    while (i < seq.length) {
      // Add a break to correct the following incorrect subsequence.
      total++;
      odd = !odd;
      // A subsequence consisted of correct steps and breaks.
      step = 0;
      while (i < seq.length && (seq[i] == 'X' || (seq[i] == 'L' && odd) || (seq[i] == 'R' && !odd))) {
        if (seq[i] != 'X') {
          step++;
        }
        total++;
        i++;
        odd = !odd;
      }
      // Count the number of subsequences with one step that are not worth correcting.
      if (step == 1) {
        // If the previous one is worth correcting, the current subsequence may be not worth
        // correcting because correcting one step would cost two breaks. But the last subsequence is
        // worth correcting when the total sequence has even number of length because it cost only
        // one break to correct.
        if (worth && (i < seq.length || (i == seq.length && (total & 1) == 1))) {
          single++;
        }
        worth = !worth;
      } else {
        worth = true;
      }
      correct += step;
    }
    // It can be proved that after all the correction above, it's better to add a break if this
    // sequence has odd number of steps.
    total += total & 1;
    // Correct these incorrect subsequences with only one step if the current proportion is lesser
    // than 1/2.
    if (correct << 1 > total) {
      correct -= single;
      total -= single << 1;
    }
    return (long) correct * 100000000 / total;
  }

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    char[] seq = sc.nextLine().toCharArray();
    StringBuilder sb = new StringBuilder();
    char last = 0;
    for (int i = 0; i < seq.length; i++) {
      // If two same steps are in a row, and a break to separate them.
      if (last == seq[i] && last != 'X') {
        sb.append('X');
      }
      sb.append(last = seq[i]);
    }
    long ans;
    if (sb.charAt(0) == sb.charAt(sb.length() - 1) && sb.charAt(0) != 'X') {
      // If the first and the last step of the sequence are same, add a break before or after the
      // sequence to make it valid.
      ans =
          Math.max(calc((sb.toString() + 'X').toCharArray()),
              calc(('X' + sb.toString()).toCharArray()));
    } else {
      ans = calc(sb.toString().toCharArray());
    }
    System.out.printf("%d.%06d\n", ans / 1000000, ans % 1000000);
    sc.close();
  }
}