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

public class uniformsubtree_topraj_sortedints {
	
	final static int DEBUG = 0;
	final static int MAX = 1000000;
	
	Scanner sc;
	PrintWriter pw;
	HashMap<Integer,Integer> id_to_nextid[] = new HashMap[5500];
	
	Rep reps[] = new Rep[MAX];
	int total = 1;

	int id_count[] = new int[MAX];
	int ids[] = new int[MAX];
	int ids_total = 0;
	
	class Rep {
		int curr_num;
		Rep next;
		
		public Rep(int _curr_num, Rep _next) {
			curr_num = _curr_num;
			next = _next;
		}
	}
	
	char tree_rep_cs[];
	int ID = 0;
	
	class Node {
		ArrayList<Node> children;
		ArrayList<Integer> uniform_subtrees;
		
		public Node() {
			children = new ArrayList<Node>();
			uniform_subtrees = new ArrayList<Integer>();
		}
	}
	
	Node parseTree(int si, int ei) {
		Node node = new Node();
		
		if(si+1==ei) return node;//leaf
		
		si++;
		ei--;
		
		int starti = si;
		int counter = 0;
		for(int i=si;i<=ei;i++) {
			if(tree_rep_cs[i]=='(') counter++;
			if(tree_rep_cs[i]==')') counter--;
			if(counter==0) {
				node.children.add(parseTree(starti, i));
				starti = i+1;
			}
		}
		
		return node;
	}
	
	String getTreeRep(Node node) {
		String rStr = "(";
		for(int i=0;i<node.children.size();i++) {
			rStr += getTreeRep(node.children.get(i));
		}
		rStr += ")";
		return rStr;
	}
	
	int getAddID(int k, int id) {
		
		if(!id_to_nextid[k].containsKey(id)) {
			id_to_nextid[k].put(id, total);
			reps[total] = new Rep(k, reps[id]);
			total++;
		}
		
		return id_to_nextid[k].get(id);
	}
	
	void combineChildren(Node node) {
		node.uniform_subtrees.add(1);//add "0"
		
		ids_total = 0;
		for(int i=0;i<node.children.size();i++) {
			Node child = node.children.get(i);
			for(int k=0;k<child.uniform_subtrees.size();k++) {
				int id = child.uniform_subtrees.get(k);
				
				if(id_count[id]==0) {
					ids[ids_total] = id;
					ids_total++;
				}
				id_count[id]++;
			}
		}
		
		//add all the ids!
		for(int i=0;i<ids_total;i++) {
			int id = ids[i];
			int cnt = id_count[id];
			for(int k=1;k<=cnt;k++) {
				int nid = getAddID(k, id);
				node.uniform_subtrees.add(nid);
			}
		}
		
		//clear the used ids
		for(int i=0;i<ids_total;i++) {
			int id = ids[i];
			id_count[id] = 0;
		}
		
	}
	
	void computeChildren(Node node) {
		for(int i=0;i<node.children.size();i++) {
			computeChildren(node.children.get(i));
		}
		
		combineChildren(node);
	}
	
	void solveIt(Node node) {
		computeChildren(node);
	}
	
	String getRepString(int id) {
		StringBuffer sb = new StringBuffer();
		Rep rep = reps[id];
		boolean first = true;
		do {
			if(!first) {
				sb.append(' ');
			}
			else {
				first = false;
			}
			sb.append(rep.curr_num);
			
			rep = rep.next;
		} while(rep!=null);
		
		return sb.toString();
	}
	
	ArrayList<Integer> getRepList(int id) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		Rep rep = reps[id];
		do {
			list.add(rep.curr_num);
			
			rep = rep.next;
		} while(rep!=null);
		
		return list;
	}
	
	void sortIt(Node node) {
		Collections.sort(node.uniform_subtrees);
	}
	
	public void doIt() throws Exception {
	
		sc = new Scanner(new File("uniformsubtree.in"));
		pw = new PrintWriter(new FileOutputStream("uniformsubtree_topraj.out"));
		
		for(int i=0;i<id_to_nextid.length;i++) {
			id_to_nextid[i] = new HashMap<Integer,Integer>();
		}
		
		reps[0] = null;//the empty string
		id_to_nextid[0].put(0, 1);
		reps[1] = new Rep(0, null);
		total++;
		
		for(int test_num=0;;test_num++) {
			String tree_rep = sc.next();
			if(tree_rep.equals("0")) break;
			
			tree_rep_cs = tree_rep.toCharArray();
			Node root = parseTree(0, tree_rep_cs.length-1);
			
			if(DEBUG>0) {
				String rep = getTreeRep(root);
				if(!rep.equals(tree_rep)) {
					System.out.printf("Tree is parsed incorrectly\n");
					System.exit(-1);
				}
			}
			
			solveIt(root);
//			System.out.printf("done with test: %d\n", test_num);
//			System.out.printf("total entries = %d\n", root.uniform_subtrees.size());
			
//			String strs[] = new String[root.uniform_subtrees.size()];
//			for(int i=0;i<root.uniform_subtrees.size();i++) {
//				int id = root.uniform_subtrees.get(i);
//				String str = getRepString(id);
//				strs[i] = str;
//			}
			
			ArrayList<Integer> answers[] = new ArrayList[root.uniform_subtrees.size()];
			for(int i=0;i<root.uniform_subtrees.size();i++) {
				int id = root.uniform_subtrees.get(i);
				answers[i] = getRepList(id);
			}
			
//			Arrays.sort(strs);
			Arrays.sort(answers, new IntListSorter());
//			for(int i=0;i<strs.length;i++) {
//				pw.printf("%s\n", strs[i]);
//			}
			for(int i=0;i<answers.length;i++) {
				StringBuffer sb = new StringBuffer();
				ArrayList<Integer> list = answers[i];
				for(int k=0;k<list.size();k++) {
					sb.append(list.get(k));
					sb.append(' ');
				}
				pw.printf("%s", sb.toString());
				pw.println();
			}
			pw.flush();
		}
	}
	
	class IntListSorter implements Comparator<ArrayList<Integer>> {
		public int compare(ArrayList<Integer> a, ArrayList<Integer> b) {
			for(int i=0;i<a.size() && i<b.size();i++) {
				if(a.get(i)!=b.get(i)) return a.get(i) - b.get(i);
			}
			
			return a.size() - b.size();
		}
	}
	
	public static void main(String args[]) throws Exception {
		(new uniformsubtree_topraj_sortedints()).doIt();
	}
	
}