#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

int main() {
    int n;
    std::string in;
    std::vector<std::pair<std::pair<int, int>, int>> opening, closing; // {{lowest, openness}, index}
    std::cin >> n;
    for (int i = 0; i < n; i++) {
        std::cin >> in;
        int lowest = 0, openness = 0;
        for (auto c: in) {
            if (c == '(') openness++;
            if (c == ')') openness--;
            lowest = std::min(lowest, openness);
            // lowest is the... lowest openness of the tablet sequence.
            // This directly determines whether this tablet can fit in the sequence.
            // For example, if the sequence is (, the ))(( won't work, because its lowest is -3, which is less
            // than the current openness, so the parenthesis closes more than it opened. That is illegal.
        }
        // for tablets that increases the "openness", we take the ones with the tallest lowest point first,
        // for the best chance of being in the solution
        // the actual order of these tablets don't really matter, as it will always increase the openness
        // secondarily, we want the tablets that opens the sequence more first, so big total values first
        if (openness > 0)
            opening.emplace_back(std::make_pair(lowest, openness), i + 1);
            // for tablets that decreases, we start from the end and work our way back, exactly like the open ones
            // but in reverse
        else {
            lowest = 0, openness = 0;
            std::reverse(in.begin(), in.end());
            for (auto c: in) {
                if (c == '(') openness--;
                if (c == ')') openness++;
                lowest = std::min(lowest, openness);
            }
            closing.emplace_back(std::make_pair(lowest, openness), i + 1);
        }
    }
    std::sort(opening.begin(), opening.end(), std::greater<>());
    std::sort(closing.begin(), closing.end(), std::greater<>());
    std::vector<int> solutionOpen;
    std::vector<int> solutionClose;
    int openness = 0;
    for (auto& i: opening) {
        if (openness + i.first.first < 0) { // the sequence closes too much
            std::cout << "impossible\n";
            return 0;
        }
        solutionOpen.emplace_back(i.second);
        openness += i.first.second;
    }
    int openingOpenness = openness;
    openness = 0;
    for (auto& i: closing) {
        if (openness + i.first.first < 0) { // the sequence closes too much
            std::cout << "impossible\n";
            return 0;
        }
        solutionClose.emplace_back(i.second);
        openness += i.first.second;
    }
    if (openness == openingOpenness) { // perfecto!
        std::reverse(solutionClose.begin(), solutionClose.end());
        for (auto& t: solutionOpen)
            std::cout << t << "\n";
        for (auto& t: solutionClose)
            std::cout << t << "\n";
    } else // the sequence is broken
        std::cout << "impossible\n";
    return 0;
}