Squirrel Liss lived in a forest peacefully, but unexpected trouble happens. Stones fall from a mountain. Initially Squirrel Liss occupies an interval [0, 1]. Next, n stones will fall and Liss will escape from the stones. The stones are numbered from 1 to n in order.

The stones always fall to the center of Liss's interval. When Liss occupies the interval [k - d, k + d] and a stone falls to k, she will escape to the left or to the right. If she escapes to the left, her new interval will be [k - d, k]. If she escapes to the right, her new interval will be [k, k + d].

You are given a string s of length n. If the i-th character of s is "l" or "r", when the i-th stone falls Liss will escape to the left or to the right, respectively. Find the sequence of stones' numbers from left to right after all the n stones falls.

Input

The input consists of only one line. The only line contains the string s (1 ≤ |s| ≤ 106). Each character in s will be either "l" or "r".

Output

Output n lines — on the i-th line you should print the i-th stone's number from the left.

Examples

Input

llrlr


Output

3
5
4
2
1


Input

rrlll


Output

1
2
5
4
3


Input

lrlrr


Output

2
4
5
3
1

Note

In the first example, the positions of stones 1, 2, 3, 4, 5 will be <image>, respectively. So you should print the sequence: 3, 5, 4, 2, 1.
import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {
	
	Scanner in;
	static PrintWriter out;
	
	
	static class Scanner {
		StreamTokenizer in;
		
		Scanner(InputStream is) {
			in = new StreamTokenizer(new BufferedReader(new InputStreamReader(is)));
			in.resetSyntax();
			in.whitespaceChars(0, 32);
			in.wordChars(33, 255);
		}
		
		String readLine() {
			try {
				in.nextToken();
				asserT(in.ttype == StreamTokenizer.TT_WORD);
				return in.sval;
			} catch (IOException e) {
				throw new Error();
			}
		}
		
		int nextInt() {
			return Integer.parseInt(readLine());			
		}
	}
	
	
	static class Pair implements Comparable <Pair> {
		int x;
		double pos;
		
		Pair(int x, double pos) {
			this.x = x;
			this.pos = pos;
		}
		
		@Override
		public int compareTo(Pair second) {
			if (this.pos < second.pos) {
				return -1;
			} else if (this.pos == second.pos) {
				return 0;
			}
			return 1;
		}
	}
	
	static class Node {
		Node left;
		Node right;
		int value;
		
		Node(int value) {
			this.value = value;
			left = null;
			right = null;
		}
	}
	
	void solve() {
		String s = in.readLine();
		Node first = new Node(1);
		Node prev = first;
		
		for (int i = 0; i < s.length() - 1; i++) {
			Node newNode = new Node(i + 2);
			if (s.charAt(i) == 'r') {
				
				if (prev.right == null) {
					prev.right = newNode;
					newNode.left = prev;
				} else {
					Node temp = prev.right;
					
					prev.right = newNode;
					newNode.left = prev;
					
					newNode.right = temp;
					temp.left = newNode;
				}
				
			} else {
				
				if (prev.left == null) {
					prev.left = newNode;
					newNode.right = prev;
				} else {
					Node temp = prev.left;
					
					prev.left = newNode;
					newNode.right = prev;
					
					newNode.left = temp;
					temp.right = newNode;
				}
				
			}
			
			prev = newNode;
		}
		
		Node start = first;
		while (start.left != null) {
			start = start.left;
		}
		
		while (start.right != null) {
			out.println(start.value);
			start = start.right;
		}
		out.println(start.value);
		
	}
	
	static void asserT(boolean e) {
		if (!e) {
			throw new Error();
		}
	}
	
	
	public void run() {
		in = new Scanner(System.in);
		out = new PrintWriter(System.out);
		
		try {
			solve();
		} finally {
			out.close();
		}
	}
	
	public static void main(String[] args) {
		new Main().run();
	}

} 