It's not a Bug, it's a Feature!

It is a curious fact that consumers buying a new software product generally do not expect the software to be bug-free. Can you imagine buying a car whose steering wheel only turns to the right? Or a CD player that plays only CDs with country music on them? Probably not. But for software systems it seems to be acceptable if they do not perform as they should. In fact, many software companies have adopted the habit of sending out patches to fix bugs every few weeks after a new product is released (and even charging money for the patches).

Tinyware Inc. is one of those companies. After releasing a new word processing software this summer, they have been producing patches ever since. Only this weekend did they realize a big problem with the patches they released. While every patch fixes some bugs, it often relies on other bugs being present in order to be installed. This happens because, to fix one bug, a patch exploits the special behavior of the program caused by another bug.

More formally, the situation looks like this. There are $n$ bugs $B = \{b_1, b_2, \ldots, b_n\}$ in the software, and $m$ patches $p_1, p_2, \ldots, p_m$. To apply patch $p_i$, all bugs in $B_i^+ \subseteq B$ must be present and all bugs in $B_i^- \subseteq B$ must be absent (of course $B_i^+ \cap B_i^- = \varnothing$). Applying the patch then removes the bugs in $F_i^- \subseteq B$ (those that were present) and introduces the new bugs in $F_i^+ \subseteq B$ (again with $F_i^- \cap F_i^+ = \varnothing$).

Starting from the original version, which contains every bug in $B$, is it possible to apply a sequence of patches that results in a bug-free version of the software? If so, and assuming each patch takes a given time to apply, how long does the fastest sequence take?

The input contains several product descriptions. Each description starts with a line containing two integers $n$ and $m$, the number of bugs and the number of patches, respectively, with $1 \le n \le 20$ and $1 \le m \le 100$. This is followed by $m$ lines describing the patches in order. Each line contains an integer, the time in seconds it takes to apply the patch, followed by two strings of $n$ characters each.

The first string describes which bugs must be present or absent before the patch can be applied. Its $i$-th character is + if bug $b_i$ must be present, - if bug $b_i$ must be absent, and 0 if it does not matter whether the bug is present.

The second string describes which bugs are fixed and introduced by the patch. Its $i$-th character is + if bug $b_i$ is introduced by the patch, - if bug $b_i$ is removed by the patch (when it was present), and 0 if bug $b_i$ is not affected (if it was present before, it still is; if it wasn't, it still isn't).

The input is terminated by a description whose first line is 0 0; this description must not be processed.

For each product description, first print a line Product X, where X is the product's number (starting from 1). Then, if there is a sequence of patches (a patch may be used several times) that removes all $n$ bugs from a product that starts with all $n$ bugs present, print Fastest sequence takes S seconds., where $S$ is the minimum total time. Otherwise, print Bugs cannot be fixed..

Separate the output of consecutive products with a blank line.