#include <stack>

#include <vector>

#include <string>

using namespace std;

class BracketExpressions {

public:

	string candidates;

    string ifPossible(string expression)

	{

		candidates = "()[]{}";

		vector<int> xPos;

		for (int i = 0; i < expression.length(); i++)

		{

			if (expression[i] == 'X')

			{

				xPos.push_back(i);

			}

		}

		bool possible = ifPossRe(expression, 0, xPos);

		if (possible)

			return "possible";

		else

			return "impossible";

	}

	bool isValid(const string &expression)

	{

		stack<char> stk;

		for (int i = 0; i < expression.length(); i++)

		{

			if (stk.empty())

			{

				stk.push(expression[i]);

			}

			else if (match(stk.top(), expression[i]))

			{

				stk.pop();

			}

			else

			{

				stk.push(expression[i]);

			}

		}

		return stk.empty();

	}

	bool match(char a, char b)

	{

		if (a == '(' && b == ')') return true;

		if (b == '(' && a == ')') return true;

		if (a == '[' && b == ']') return true;

		if (b == '[' && a == ']') return true;

		if (a == '{' && b == '}') return true;

		if (b == '{' && a == '}') return true;

		return false;

	}

	bool ifPossRe(string &expression, int idx, vector<int> &xPos)

	{

		if (idx == xPos.size())

		{

			return isValid(expression);

		}

		int n = xPos[idx];

		for (int i = 0; i < candidates.length(); i++)

		{

			char ch = expression[n];

			expression[n] = candidates[i];

			bool res = ifPossRe(expression, idx+1, xPos);

			expression[n] = ch;

			if (res)

				return true;

		}

		return false;

	}

};

bool correctBracket(string exp)

{

    stack<char> s;

    // an assoicaitive array: opos[ ')' ] returns '(', opos[ ']' ] is '[', ...

    map<char,char> opos = {

        { ')', '(' },

        { ']', '[' },

        { '}', '{' },

    };

    for (char ch: exp) {

        // we push opening brackets to the stack

        if (ch == '(' || ch == '[' || ch == '{' ) {

            s.push(ch);

        } else {

            // If we find a closing bracket, we make sure it matches the

            // opening bracket in the top of the stack

            if (s.size() == 0 || s.top() != opos[ch]) {

                return false;

            } else {

                // then we remove it

                s.pop();

            }

        }

    }

    // stack must be empty.

    return s.empty();

}

string ifPossible(string expression)

{

    vector<int> x;

    int n = expression.size();

    for (int i = 0; i < n; i++) {

        if (expression[i] == 'X') {

            x.push_back(i);

        }

    }

    int t = x.size();

    // to easily convert to base 6 we precalculate the powers of 6:

    int p6[6];

    p6[0] = 1;

    for (int i = 1; i < 6; i++) {

        p6[i] = 6 * p6[i - 1];

    }

    const char* CHARS = "([{)]}";

    for (int m = 0; m < p6[t]; m++) {

        string nexp = expression;

        for (int i = 0; i < t; i++) {

            // (m / p6[i]) % 6 extracts the i-th digit of m in base 6.

            nexp[ x[i] ] = CHARS[ (m / p6[i]) % 6 ];

        }

        if (correctBracket(nexp)) {

            return "possible";

        }

    }

    return "impossible";

}