// Arup Guha
// 11/12/2022
// Solution to 2021 WF Problem H: Prehistoric Programs

import java.util.*;
import java.io.*;

public class h {

	public static void main(String[] args) throws Exception {
	
		BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(stdin.readLine());
		ArrayList<item> pos = new ArrayList<item>();
		ArrayList<item2> neg = new ArrayList<item2>();
		
		// Read each item.
		for (int i=0; i<n; i++) {
			char[] tmp = stdin.readLine().toCharArray();
			
			int cnt = 0, min = 0;
			for (int j=0; j<tmp.length; j++) {
				if (tmp[j] == '(') cnt++;
				else cnt--;
				min = Math.min(min, cnt);
			}
			
			// Store its id, its overall open count and the lowest it goes.
			if (cnt >= 0)
				pos.add(new item(i+1, cnt, min));
			else
				neg.add(new item2(i+1, cnt, min));
		}
		
		// Sort it.
		boolean flag = true;
		Collections.sort(pos);
		Collections.sort(neg);
	
		ArrayList<Integer> res = new ArrayList<Integer>();
		int myCnt = 0;
		
		// Positives go first.
		for (int i=0; i<pos.size(); i++) {
			
			// See if we fall below 0...
			int thisM = myCnt + pos.get(i).min;
			if (thisM < 0) { flag = false; break; }
			
			// Safe to get here...
			myCnt += pos.get(i).net;
			res.add(pos.get(i).id);
		}
		
		// Then negatives.
		for (int i=0; i<neg.size(); i++) {
			
			// See if we fall below 0...
			int thisM = myCnt + neg.get(i).min;
			if (thisM < 0) { flag = false; break; }
			
			// Safe to get here...
			myCnt += neg.get(i).net;
			res.add(neg.get(i).id);
		}
		
		// Last check.
		if (myCnt != 0) flag=false;
		
		// Can't work...
		if (!flag)
			System.out.println("impossible");
		
		// This is valid, print it.
		else {
			StringBuffer sb = new StringBuffer();
			for (int i=0; i<n; i++) sb.append(res.get(i)+"\n");
			System.out.print(sb);
		}
	}
}

class item implements Comparable<item> {

	public int id;
	public int net;
	public int min;
	
	public item(int myid, int netSum, int minCnt) {
		id = myid;
		net = netSum;
		min = minCnt;
	}
	
	// This one's easy, sort by minimum...these will build up open brackets.
	// If you can't build up open brackets to "handle" mins, then it can't be done.
	public int compareTo(item other) {
		if (this.min != other.min) return other.min - this.min;
		return other.net - this.net;
	}
}

class item2 implements Comparable<item2> {

	public int id;
	public int net;
	public int min;
	public int diff;
	
	public item2(int myid, int netSum, int minCnt) {
		id = myid;
		net = netSum;
		min = minCnt;
		diff = min - net;
	}
	
	// This one's trickier. We want the last items to be all closes in some sense,
	// so if I look for difference between min and the net count, and put the ones
	// last with these two values the same (all closes), we'll be safe.
	public int compareTo(item2 other) {
		if (this.diff != other.diff) return this.diff - other.diff;
		return other.net - this.net;		
	}

}