Problem: Taro, a junior high school student, is working on his homework. Today's homework is to read Chinese classic texts.

As you know, Japanese language shares the (mostly) same Chinese characters but the order of words is a bit different. Therefore the notation called "returning marks" was invented in order to read Chinese classic texts in the order similar to Japanese language.

There are two major types of returning marks: 'Re' mark and jump marks. Also there are a couple of jump marks such as one-two-three marks, top-middle-bottom marks. The marks are attached to letters to describe the reading order of each letter in the Chinese classic text. Figure 1 is an example of a Chinese classic text annotated with returning marks, which are the small letters at the bottom-left of the big Chinese letters.

<image>

Figure 1: a Chinese classic text

Taro generalized the concept of jump marks, and summarized the rules to read Chinese classic texts with returning marks as below. Your task is to help Taro by writing a program that interprets Chinese classic texts with returning marks following his rules, and outputs the order of reading of each letter.

When two (or more) rules are applicable in each step, the latter in the list below is applied first, then the former.

1. Basically letters are read downwards from top to bottom, i.e. the first letter should be read (or skipped) first, and after the i-th letter is read or skipped, (i + 1)-th letter is read next.
2. Each jump mark has a type (represented with a string consisting of lower-case letters) and a number (represented with a positive integer). A letter with a jump mark whose number is 2 or larger must be skipped.
3. When the i-th letter with a jump mark of type t, number n is read, and when there exists an unread letter L at position less than i that has a jump mark of type t, number n + 1, then L must be read next. If there is no such letter L, the (k + 1)-th letter is read, where k is the index of the most recently read letter with a jump mark of type t, number 1.
4. A letter with a 'Re' mark must be skipped.
5. When the i-th letter is read and (i - 1)-th letter has a 'Re' mark, then (i - 1)-th letter must be read next.
6. No letter may be read twice or more. Once a letter is read, the letter must be skipped in the subsequent steps.
7. If no letter can be read next, finish reading.



Let's see the first case of the sample input. We begin reading with the first letter because of the rule 1. However, since the first letter has a jump mark 'onetwo2', we must follow the rule 2 and skip the letter. Therefore the second letter, which has no returning mark, will be read first.

Then the third letter will be read. The third letter has a jump mark 'onetwo1', so we must follow rule 3 and read a letter with a jump mark `onetwo2' next, if exists. The first letter has the exact jump mark, so it will be read third. Similarly, the fifth letter is read fourth, and then the sixth letter is read.

Although we have two letters which have the same jump mark 'onetwo2', we must not take into account the first letter, which has already been read, and must read the fourth letter. Now we have read all six letters and no letter can be read next, so we finish reading. We have read the second, third, first, fifth, sixth, and fourth letter in this order, so the output is 2 3 1 5 6 4.



Input

The input contains multiple datasets. Each dataset is given in the following format:

N
mark1
...
markN


N, a positive integer (1 ≤ N ≤ 10,000), means the number of letters in a Chinese classic text. marki denotes returning marks attached to the i-th letter.

A 'Re' mark is represented by a single letter, namely, 'v' (quotes for clarity). The description of a jump mark is the simple concatenation of its type, specified by one or more lowercase letter, and a positive integer. Note that each letter has at most one jump mark and at most one 'Re' mark. When the same letter has both types of returning marks, the description of the jump mark comes first, followed by 'v' for the 'Re' mark. You can assume this happens only on the jump marks with the number 1.

If the i-th letter has no returning mark, marki is '-' (quotes for clarity). The length of marki never exceeds 20.

You may assume that input is well-formed, that is, there is exactly one reading order that follows the rules above. And in the ordering, every letter is read exactly once.

You may also assume that the N-th letter does not have 'Re' mark.

The input ends when N = 0. Your program must not output anything for this case.

Output

For each dataset, you should output N lines. The first line should contain the index of the letter which is to be read first, the second line for the letter which is to be read second, and so on. All the indices are 1-based.

Example

Input

6
onetwo2
-
onetwo1
onetwo2
-
onetwo1
7
v
topbottom2
onetwo2
-
onetwo1
topbottom1
-
6
baz2
foo2
baz1v
bar2
foo1
bar1
0


Output

2
3
1
5
6
4
4
5
3
6
2
1
7
5
2
6
4
3
1

Solution (in JAVA):

Solution:
import java.util.*;

class P{
  String s;
  int digit;
  boolean re;

  public P(String s,int digit,boolean re){
    this.s = s;
    this.digit = digit;
    this.re = re;
  }

  public String toString(){
    return String.format("[%s, %d, %b]",s,digit,re);
  }
}

public class Main{
  static int n;
  static HashMap<String,Stack<Integer>> map;
  static P[] p;

  public static void Ichi(int idx){
    int now = 1;
    int popIdx = -1;
    Stack<Integer> st = new Stack<Integer>();

    while(!map.get(p[idx].s).isEmpty()){
      popIdx = map.get(p[idx].s).pop();
      if(now + 1 != p[popIdx].digit){
        map.get(p[idx].s).push(popIdx);
        popIdx = -1;
        break;
      }
      System.out.println(popIdx+1);
      st.push(popIdx);
      now++;
    }

    while(!st.isEmpty()){
      int p = st.pop();
      Re(p);
    }
  }

  public static void Re(int idx){
    for(int j=idx-1;j>=0 && p[j].re;j--){
      System.out.println(j+1);
      if(p[j].digit == 1){
        Ichi(j);
      }
    }
  }

  public static void solve(){
    for(int i=0;i<n;i++){
      if(p[i].s.equals("-")){
        System.out.println(i+1);
        Re(i);
        continue;
      }
      if(p[i].digit >= 2){
        map.get(p[i].s).push(i);
        continue;
      }
      if(p[i].re){
        continue;
      }

      System.out.println(i+1);

      if(p[i].digit == 1){
        Ichi(i);
      }

      Re(i);
    }
  }

  public static void main(String[] args){
    Scanner sc = new Scanner(System.in);

    while(true){
      n = sc.nextInt();
      if(n == 0) break;

      map = new HashMap<String,Stack<Integer>>();
      p = new P[n+2];

      for(int i=0;i<n;i++){
        String s = sc.next();
        p[i] = new P("",-1,false);

        if(s.endsWith("v")){
          p[i].re = true;
          s = s.substring(0,s.length()-1);
        }

        int idx = s.length() - 1;
        for(;idx>=0 && '0' <= s.charAt(idx) && s.charAt(idx) <= '9';idx--);

        if(idx != s.length() - 1){
          p[i].digit = Integer.parseInt(s.substring(idx+1));
          s = s.substring(0,idx+1);
        }

        p[i].s = s;
        if(!p[i].s.equals("")){
          map.put(p[i].s,new Stack<Integer>());
        }
      }

      solve();
    }
  }
}