Problem: Your friend Kirchhoff is shocked with the current state of electronics design.

"Ohmygosh! Watt is wrong with the field? All these circuits are inefficient! There's so much capacity for improvement. The electrical engineers must not conduct their classes very well. It's absolutely revolting" he said.

The negativity just keeps flowing out of him, but even after complaining so many times he still hasn't lepton the chance to directly change anything.

"These circuits have too much total resistance. Wire they designed this way? It's just causing a massive loss of resistors! Their entire field could conserve so much money if they just maximized the potential of their designs. Why can't they just try alternative ideas?"

The frequency of his protests about the electrical engineering department hertz your soul, so you have decided to take charge and help them yourself. You plan to create a program that will optimize the circuits while keeping the same circuit layout and maintaining the same effective resistance.

A circuit has two endpoints, and is associated with a certain constant, R, called its effective resistance. 

The circuits we'll consider will be formed from individual resistors joined together in series or in parallel, forming more complex circuits. The following image illustrates combining circuits in series or parallel. 

<image>

According to your friend Kirchhoff, the effective resistance can be calculated quite easily when joining circuits this way:

  * When joining k circuits in series with effective resistances R_1, R_2, …, R_k, the effective resistance R of the resulting circuit is the sum $$$R = R_1 + R_2 + … + R_k.$$$

  * When joining k circuits in parallel with effective resistances R_1, R_2, …, R_k, the effective resistance R of the resulting circuit is found by solving for R in $$$1/R = (1)/(R_1) + (1)/(R_2) + … + (1)/(R_k), assuming all R_i > 0; if at least one R_i = 0, then the effective resistance of the whole circuit is simply R = 0$$$. 



Circuits will be represented by strings. Individual resistors are represented by an asterisk, "*". For more complex circuits, suppose s_1, s_2, …, s_k represent k ≥ 2 circuits. Then:

  * "(s_1 S s_2 S … S s_k)" represents their series circuit; 
  * "(s_1 P s_2 P … P s_k)" represents their parallel circuit. 



For example, "(* P (* S *) P *)" represents the following circuit:

<image>

Given a circuit, your task is to assign the resistances of the individual resistors such that they satisfy the following requirements:

  * Each individual resistor has a nonnegative integer resistance value; 
  * The effective resistance of the whole circuit is r; 
  * The sum of the resistances of the individual resistors is minimized. 



If there are n individual resistors, then you need to output the list r_1, r_2, …, r_n (0 ≤ r_i, and r_i is an integer), where r_i is the resistance assigned to the i-th individual resistor that appears in the input (from left to right). If it is impossible to accomplish the task, you must say so as well.

If it is possible, then it is guaranteed that the minimum sum of resistances is at most 10^{18}. 

Input

The first line of input contains a single integer t (1 ≤ t ≤ 32000), denoting the number of test cases. The next lines contain descriptions of the test cases.

Each test case consists of a single line containing the integer r (1 ≤ r ≤ 10^6), space, and then the string representing the circuit. It is guaranteed that the string is valid and follows the description above. The number of individual resistors (symbols "*") is at least 1 and at most 80000.

It is guaranteed that the total number of individual resistors across all test cases is at most 320000.

Output

For each test case, print a single line:

  * If it's possible to achieve an effective resistance of r, print "REVOLTING" (without quotes) and then n integers r_1, r_2, …, r_n — the resistances assigned to the individual resistors. Here, n denotes the number of the individual resistors in the circuit. 

There may be multiple possible such assignments with a minimal sum of resistances of the individual resistors, you can output any of them;

  * If it's impossible, print the string: "LOSS" (without quotes). 

Example

Input


3
5 *
1 (* S *)
1 (* P (* S *))


Output


REVOLTING 5
REVOLTING 1 0
REVOLTING 2 1 1

Note

The following illustrates the third sample case:

<image>

Here, the sum of the resistances of the individual resistors is 2 + 1 + 1 = 4, which can be shown to be the minimum. Note that there may be other assignments that achieve this minimum.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
enum Type {
  SINGLE,
  SERIES,
  PARALLEL,
};
struct Node {
  Type type;
  vector<shared_ptr<Node>> children;
  long long multiplier;
};
shared_ptr<Node> parse() {
  auto ptr = make_shared<Node>();
  char c;
  cin >> c;
  if (c == '*') {
    ptr->type = SINGLE;
    return ptr;
  }
  assert(c == '(');
  ptr->children.push_back(parse());
  cin >> c;
  if (c == 'S') {
    ptr->type = SERIES;
  } else {
    assert(c == 'P');
    ptr->type = PARALLEL;
  }
  while (c != ')') {
    ptr->children.push_back(parse());
    cin >> c;
  }
  return ptr;
}
void compute_multiplier(shared_ptr<Node> p) {
  if (p->type == SINGLE) {
    p->multiplier = 1;
    assert(p->children.empty());
    return;
  }
  assert(p->children.size() >= 2);
  for (auto& child : p->children) {
    compute_multiplier(child);
  }
  if (p->type == SERIES) {
    p->multiplier = p->children.front()->multiplier;
    for (auto& child : p->children) {
      p->multiplier = min(p->multiplier, child->multiplier);
    }
    return;
  }
  assert(p->type == PARALLEL);
  p->multiplier = 0;
  for (auto& child : p->children) {
    p->multiplier += child->multiplier;
  }
}
long long gcd(long long x, long long y) {
  if (y == 0) {
    return x;
  }
  return gcd(y, x % y);
}
void reduce(pair<long long, long long>& x) {
  assert(x.second != 0);
  long long g = gcd(x.first, x.second);
  x.first /= g;
  x.second /= g;
}
pair<long long, long long> multiply(pair<long long, long long> x,
                                    pair<long long, long long> y) {
  reduce(x);
  reduce(y);
  pair<long long, long long> res(x.first * y.first, x.second * y.second);
  reduce(res);
  return res;
}
void solve(shared_ptr<Node> p, pair<long long, long long> ohms) {
  if (p->type == SINGLE) {
    assert(ohms.second == 1);
    cout << " " << ohms.first;
    return;
  }
  int n = p->children.size();
  if (p->type == SERIES) {
    int index = -1;
    for (int i = 0; i < n; ++i) {
      if (p->children[i]->multiplier == p->multiplier) {
        index = i;
        break;
      }
    }
    for (int i = 0; i < n; ++i) {
      if (i == index) {
        solve(p->children[i], ohms);
      } else {
        solve(p->children[i], make_pair(0, 1));
      }
    }
    return;
  }
  assert(p->type == PARALLEL);
  for (int i = 0; i < n; ++i) {
    auto target =
        multiply(ohms, make_pair(p->multiplier, p->children[i]->multiplier));
    solve(p->children[i], target);
  }
}
int main() {
  int tcas;
  cin >> tcas;
  for (int cas = 0; cas < tcas; ++cas) {
    int n;
    cin >> n;
    auto p = parse();
    compute_multiplier(p);
    cout << "REVOLTING";
    solve(p, make_pair(n, 1));
    cout << endl;
  }
}