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.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.Stack;
import java.util.TreeSet;
		public class Main implements Runnable
		{
			static final long MOD = 1000000007L;
			static final long MOD2 = 1000000009L;
			static class InputReader
			{
				private InputStream stream;
				private byte[] buf = new byte[1024];
				private int curChar;
				private int numChars;
				private SpaceCharFilter filter;
				private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		 
				public InputReader(InputStream stream)
				{
					this.stream = stream;
				}
				
				public int read()
				{
					if (numChars==-1) 
						throw new InputMismatchException();
					
					if (curChar >= numChars)
					{
						curChar = 0;
						try 
						{
							numChars = stream.read(buf);
						}
						catch (IOException e)
						{
							throw new InputMismatchException();
						}
						
						if(numChars <= 0)				
							return -1;
					}
					return buf[curChar++];
				}
			 
				public String nextLine()
				{
					String str = "";
		            try
		            {
		                str = br.readLine();
		            }
		            catch (IOException e)
		            {
		                e.printStackTrace();
		            }
		            return str;
				}
				public int nextInt()
				{
					int c = read();
					
					while(isSpaceChar(c)) 
						c = read();
					
					int sgn = 1;
					
					if (c == '-') 
					{
						sgn = -1;
						c = read();
					}
					
					int res = 0;
					do 
					{
						if(c<'0'||c>'9') 
							throw new InputMismatchException();
						res *= 10;
						res += c - '0';
						c = read();
					}
					while (!isSpaceChar(c)); 
					
					return res * sgn;
				}
				
				public long nextLong() 
				{
					int c = read();
					while (isSpaceChar(c))
						c = read();
					int sgn = 1;
					if (c == '-') 
					{
						sgn = -1;
						c = read();
					}
					long res = 0;
					
					do 
					{
						if (c < '0' || c > '9')
							throw new InputMismatchException();
						res *= 10;
						res += c - '0';
						c = read();
					}
					while (!isSpaceChar(c));
						return res * sgn;
				}
				
				public double nextDouble() 
				{
					int c = read();
					while (isSpaceChar(c))
						c = read();
					int sgn = 1;
					if (c == '-') 
					{
						sgn = -1;
						c = read();
					}
					double res = 0;
					while (!isSpaceChar(c) && c != '.') 
					{
						if (c == 'e' || c == 'E')
							return res * Math.pow(10, nextInt());
						if (c < '0' || c > '9')
							throw new InputMismatchException();
						res *= 10;
						res += c - '0';
						c = read();
					}
					if (c == '.') 
					{
						c = read();
						double m = 1;
						while (!isSpaceChar(c)) 
						{
							if (c == 'e' || c == 'E')
								return res * Math.pow(10, nextInt());
							if (c < '0' || c > '9')
								throw new InputMismatchException();
							m /= 10;
							res += (c - '0') * m;
							c = read();
						}
					}
					return res * sgn;
				}
				
				public String readString() 
				{
					int c = read();
					while (isSpaceChar(c))
						c = read();
					StringBuilder res = new StringBuilder();
					do 
					{
						res.appendCodePoint(c);
						c = read();
					} 
					while (!isSpaceChar(c));
					
					return res.toString();
				}
			 
				public boolean isSpaceChar(int c) 
				{
					if (filter != null)
						return filter.isSpaceChar(c);
					return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
				}
			 
				public String next() 
				{
					return readString();
				}
				
				public interface SpaceCharFilter 
				{
					public boolean isSpaceChar(int ch);
				}
			}
		 	
			public static void main(String args[]) throws Exception
			{
				new Thread(null, new Main(),"Main",1<<26).start();
			}
			int MAXN = 1000001;
			public void run() 
			{
				InputReader sc= new InputReader(System.in);
				PrintWriter w= new PrintWriter(System.out);
				String s = sc.next();
				int[] ans = new int[s.length()+1];
				int l = 1;
				int r = s.length();
				for(int i = 0;i < s.length();i++) {
					if(s.charAt(i) == 'l') {
						r = r - 1;
						ans[r+1] = i+1;
					}else {
						l = l + 1;
						ans[l-1] = i+1;
					}
					
				}
				for(int i = 1;i < ans.length;i++) {
					w.println(ans[i]);
				}
				w.close();
			}
			
			static boolean isPrime(long n)
		    {
		        // Corner cases
		        if (n <= 1) return false;
		        if (n <= 3) return true;
		     
		        // This is checked so that we can skip 
		        // middle five numbers in below loop
		        if (n % 2 == 0 || n % 3 == 0) return false;
		     
		        for (int i = 5; i * i <= n; i = i + 6)
		            if (n % i == 0 || n % (i + 2) == 0)
		            return false;
		     
		        return true;
		    }
		 
			long count = 0;
			long[][] dist;
			void flydwarShall(int k,int size) {
				for(int i = 0;i < size;i++) {
					for(int j = 0;j < size;j++) {
						if(dist[i][j] > dist[i][k] + dist[k][j]) {
							dist[i][j] = dist[i][k] + dist[k][j];
						}
					}
				}
			}
			Pair[] segTree;
			int[] arr;
			void build(int l,int r,int pos) {
				if(l == r) {
					segTree[pos] = new Pair(1,1,1,arr[l],arr[l],true);
					return;
				}
				int mid = (l + r) >> 1;
				build(l,mid,2*pos+1);
				build(mid+1, r, 2*pos+2);
				segTree[pos] = merge(segTree[2*pos+1], segTree[2*pos+2]);
			}
			Pair merge(Pair p1,Pair p2) {
				if(p1.val1 == 0) {
					return p2;
				}else if(p2.val1 == 0) {
					return p1;
				}
				Pair navi = new Pair();
				navi.val1 = p1.val1;
				navi.val2 = p2.val2;
				if(p1.val2 == p2.val1) {
					navi.max = Math.max(p1.max,p2.max);
					navi.first = p1.first;
					navi.second = p2.second;
					navi.whole = false;
				}else {
					navi.max = Math.max(p1.max,Math.max(p2.max,p1.second + p2.first));
					if(p1.whole && p2.whole) {
						navi.first = p1.first + p2.first;
						navi.second = p1.first + p2.first;
						navi.whole = true;
					}else if(p1.whole) {
						navi.first = p1.first + p2.first;
						navi.second = p2.second;
						navi.whole = false;
					}else if(p2.whole) {
						navi.first = p1.first;
						navi.second = p1.second + p2.first;
						navi.whole = false;
					}else {
						navi.first = p1.first;
						navi.second = p2.second;
						navi.whole = false;
					}
				}
				return navi;
			}
			Pair query(int pos, int l, int r, int start, int end)
			{
			    if(end < l || r < start)
			    {
			        return new Pair(0,0,0,0,0,false);
			    }
			    if(start <= l && r <= end)
			    {
			        // range represented by a node is completely inside the given range
			        return segTree[pos];
			    }
			    // range represented by a node is partially inside and partially outside the given range
			    int mid = (l + r) / 2;
			    Pair p1 = query(2*pos + 1, l, mid, start, end);
			    Pair p2 = query(2*pos+2, mid+1, r, start, end);
			    return merge(p1, p2);
			}
			int bsearch(Integer[] arr,int l,int r,int val) {
				int ind = -1;
				while(l <= r) {
					int mid = (l + r)/2;
					if(arr[mid] <= val) {
						l = mid + 1;
						ind = mid;
					}else {
						r = mid - 1;
					}
				}
				return ind;
			}
			Stack<Integer> st = new Stack();
			int bridges = 0;
			
			
			long modExpo(long a,long pow,long mod) {
				long res = 1;
				while(pow > 0) {
					if(pow % 2 == 1) {
						res = (res * a) % mod;
					}
					pow = pow/2;
					a = (a * a) % mod;
				}
				return res;
			}
			  static long modInverse(long a, long m)
			    {
			        
			       
			            // If a and m are relatively prime, then modulo inverse
			            // is a^(m-2) mode m
			         
			                        return        power(a, m - 2, m);
			        
			    }
			     
			    // To compute x^y under modulo m
			// Iterative Java program to 
			// compute modular power
			
			    static long power(long x, long y,long p)
			    {
			        // Initialize result
			        long res = 1;     
			        
			        // Update x if it is more  
			        // than or equal to p
			        x = x % p; 
			     
			        while (y > 0)
			        {
			            // If y is odd, multiply x
			            // with result
			            if((y & 1)==1)
			                res = (res * x) % p;
			     
			            // y must be even now
			            // y = y / 2
			            y = y >> 1; 
			            x = (x * x) % p; 
			        }
			        return res;
			    }
			static class Temp implements Comparable<Temp>{
				double a;
				int b;
				Temp(double a,int b){
					this.a = a;
					this.b = b;
				}
				@Override
				public int compareTo(Temp t){
					return Double.compare(this.a,t.a);
				}
			}
			static class Pair implements Comparable<Pair>{
				int first;
				int max;
				int second;
				int val1;
				int val2;
				boolean whole;
				
				Pair (int a,int b,int c,int val1,int val2,boolean whole){
					this.first = a;
					this.max = b;
					this.second = c;
					this.val1= val1;
					this.val2 = val2;
					this.whole = whole;
				}
				Pair(){
					
				}
				public boolean equals(Object o)
				{
					Pair p = (Pair)o;
					return (p.first==first && p.max==max) || (p.first == max && p.first == max);
				}
				public int hashCode()
				{
					return new Long(first).hashCode()*31 + new Long(max).hashCode();
				}
				public int compareTo(Pair p){
					return Long.compare(p.first,this.first);
				}
			}
		
		}