Problem: Dr. Tsuruga of the University of Aizu is famous for his enthusiastic research. There are several students in his lab, but he works late into the night every day, so he always comes home last. His lab has multiple rooms connected by doors, and the last person to leave the lab is supposed to turn off the lights in all the rooms and go home.

Recently, the university is focusing on energy saving, so it is strictly checked whether all the lights are off. The trouble is that he is an undisputed extreme coward who can never enter a darkened room. Therefore, he modified the lighting equipment in the laboratory so that the lighting in one room could be turned on and off from another room.

However, due to budget constraints, the number of rooms that can be controlled from one room is limited. In addition, the lighting conditions in each room when returning home vary from day to day, so it takes a considerable amount of time every day to turn off all the lights and reach the exit. So, as a researcher, you decided to create a program to help the doctor.

Create a program that inputs the room information of the laboratory, the lighting information of each room, and the lighting switch information of each room, and outputs whether the doctor can turn off all the lights and go home. However, the number of rooms n is an integer from 1 to 15 and the number of doors m is an integer from 1 to 30. It is assumed that numbers are assigned by integers greater than or equal to n or less. The exit is in room number n and the doctor always starts in room 1.

The output is divided into the following three types according to the action to be taken by the doctor.

Case 1. When all lights except the exit are turned off to reach the exit (you may pass through the exit in the process of the route).


You can go home in X steps.


Is output. Here, X is the shortest number of steps to reach the exit from the doctor's room when moving the room and turning the switch on / off as one step each. In addition, the route from the doctor's room to the exit (the action that the doctor should take) is output in X lines according to the following character string.

* When moving to room R

Move to room R.


* When turning off the lights in Room R

Switch off room R.


* When turning on the lights in Room R

Switch on room R.





Where R represents the room number. Immediately after moving to a room with a doctor, if you operate multiple switches to move to the next room, output from the one with the smallest room number to operate. As long as this condition is met, if there are multiple solutions, any one can be output. With this information, the doctor can return home safely.

Case 2. If you can reach the exit but cannot turn off all the lights except the room with the exit.


You can not switch off all lights.


Is output. In this case, the doctor will be punished by the university for failing to save energy.

Case 3. If you can't reach the exit no matter what.


Help me!


Is output. In this case, the doctor asks the guards for emergency help.

Here is a simple example. In this example, the lab consists of four rooms, with rooms 1 and 2, 2 and 3, and 2 and 4, respectively. You can also control the lights in rooms 2 and 3 from rooms 1 and 4, and you can control the lights in rooms 1, 2 and 4 from room 3. Initially, the doctor is in room 1 with the lights in rooms 2, 3 and 4 turned off.

<image>



In this situation, the actions the doctor should take are:


Turn on the lights in rooms 2 and 3.
Move to room 2.
Move to room 3.
Turn off the lights in room 1 and turn on the lights in room 4.
Move to room 2.
Move to room 4.
Turn off the lights in rooms 2 and 3.


The doctor can now turn off the lights outside Room 4 and go home.



Input

A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:


n m
s1 t1
s2 t2
::
sm tm
l1 l2 ... ln
k1 r1 r2 ... rk1
k2 r1 r2 ... rk2
::
kn r1 r2 ... rkn


The number of rooms n (1 ≤ n ≤ 15) and the number of doors m (1 ≤ m ≤ 30) are given on the first line, separated by blanks. The next m line gives information about the i-th door. si ti means that room si and room ti are connected by a door.

On the next line, the lighting information li (0 or 1) for room i is given, separated by blanks.

The next n lines give the switch information for room i. ki (0 ≤ ki ≤ 12) is the number of switches in room i, and r1 ... rki is the number of rooms where the lights can be manipulated.

The number of datasets does not exceed 100.

Output

For each data set, output in the following format according to the above three results.

For case 1

Line 1: You can go home in X steps.
Line 2: Actions the first doctor should take
Line 3: Actions the second doctor should take
::
Line X + 1: Actions to be taken by the Xth doctor


In case 2

Line 1: You can not switch off all lights.


In case 3

Line 1: Help me!

Example

Input

4 3
1 2
2 3
2 4
1 0 0 0
2 2 3
0
3 1 2 4
2 2 3
4 3
1 2
2 3
2 4
1 0 0 0
2 2 3
0
3 1 2 4
1 3
4 3
1 2
2 3
2 4
1 0 0 0
2 2 3
0
2 1 2
2 2 3
0 0


Output

You can go home in 10 steps.
Switch on room 2.
Switch on room 3.
Move to room 2.
Move to room 3.
Switch off room 1.
Switch on room 4.
Move to room 2.
Move to room 4.
Switch off room 2.
Switch off room 3.
You can not switch off all lights.
Help me!

Solution (in CPP):

Solution:

#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <memory>
#include <string>

#include <algorithm>
#include <complex>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <bitset>

using namespace std;

#ifdef _MSC_VER
#define __typeof__ decltype
#define strtok_r strtok_s
#endif

#define ITER(c)             __typeof__((c).begin())
#define FOREACH(it, c)      for (ITER(c) it=(c).begin(); it != (c).end(); ++it)
#define RITER(c)            __typeof__((c).rbegin())
#define RFOREACH(it, c)     for (RITER(c) it=(c).rbegin(); it != (c).rend(); ++it)
#define REP(i, n)           REPEAT(i, 0, n)
#define RREP(i, n)          RREPEAT(i, 0, n)
#define REPEAT(i, k, n)     for(int i = (k); i < ((k)+(n)); ++i)
#define RREPEAT(i, k, n)    for(int i = (k)+(n)-1; i >= (k); --i)
#define FROMTO(i,f,t)       for(int i = f; i < t; i++)
#define ALL(c)              (c).begin(), (c).end()
#define LLPOW(p1,p2)        ((ll)pow((double)(p1), (int)p2))
#define ESIZEOF(A)          (sizeof(A)/sizeof((A)[0]))
#define CIN_NO_SYNC         do { cin.tie(0); ios_base::sync_with_stdio(false); } while(0)
#define GETSTR(p)           fgets((p), sizeof(p), stdin)
#define CHOMP(p)            do{ char *_q = (p) + strlen(p)-1; if(*_q == '\n' || *_q == '\r') *_q = 0; } while(0)
#define FILL(m,v)           memset(m, v, sizeof(m))
#define mp                  make_pair
#define pb                  push_back
template<class _T> _T MAX(_T p1,_T p2){return (p1>p2)?p1:p2;} 
template<class _T> _T MIN(_T p1,_T p2){return (p1<p2)?p1:p2;} 
template <class _Tv> inline string join(const _Tv &v,string sep=" "){
    ostringstream s;FOREACH(it,v){if(it!=v.begin())s<<sep;s<<*it;};return s.str();
}

typedef long long ll;
typedef unsigned long long ull;
typedef double D;
typedef complex<D> P;
typedef vector<int> VI;
typedef vector<VI> VVI;
#define X real()
#define Y imag()
#define EPS (1e-9)
#define DEQ(p1,p2) (abs((p1)-(p2)) < EPS)

#ifdef _DEBUG
template<class _Tv> inline void _prfe(const char *_n,const _Tv _c,bool _p=false){
    ITER(_c) _it=_c.begin();
    if(_p){cout<<_n<<" = ["<<endl;for(;_it!=_c.end();++_it)cout<<"    "<<*_it<<endl;cout<<"]"<<endl; }
    else{cout<<_n<<" = [ ";if(_c.size()){cout<<*_it++;for(;_it!=_c.end();++_it)cout<<", "<<*_it;}cout<<" ]"<<endl; }
}
ostream &operator<<(ostream &os, const pair<int,int> &p){return(os<<"("<<p.first<<","<<p.second<<")");}
#define pf printf
#define pr(n) do{cout<<#n" = "<<(n)<<endl;}while(0)
#define prfe(n) _prfe(#n, n)
#define prfep(n) _prfe(#n, n, true)
#define dbgchk(n) do{if(n)throw;}while(0)
#else
#define pf(...) /* */
#define pr(...) /* */
#define prfe(...) /* */
#define prfep(...) /* */
#define dbgchk(...) /* */
#endif

int n,m;
vector<int> vst[15];
int l;
vector<int> vk[15];

struct OP {
    int oldlight;
    int newlight;
    int move;
    OP(){};
    void set(int ol, int nl, int mt){ oldlight=ol,newlight=nl,move=mt; }
};
struct QUE {
    int pos;
    int light;
    QUE(){}
    QUE(int p, int l){ set(p,l); }
    void set(int p, int l){ pos=p,light=l; }
};

const int INF = 1<<29;
QUE memo[15][1<<15];
int st[15][1<<15];

void result(int pos, int light){
    deque<QUE> q;
    while(1){
        if(q.empty() || q.front().pos != pos)
            q.push_front(QUE(pos,light));
        QUE &m = memo[pos][light];
        pos = m.pos, light = m.light;
        if(pos == 0 && light == l) break;
    }

    pos = 0, light = l;
    FOREACH(it, q){
        int &np = it->pos, &nl = it->light;
        pf("pos = %d, light = %d\n", np, nl);
        if(pos != np){
            printf("Move to room %d.\n", np+1);
        }
        int sw = light ^ nl;
        REP(i,n){
            if(!(sw & (1<<i))) continue;
            if(light & (1<<i)){
                printf("Switch off room %d.\n", i+1);
            } else {
                printf("Switch on room %d.\n", i+1);
            }
        }
        pos = np, light = nl;
    }
}

void solve(){
    pr(n); if(n<2||n>15) throw;
    pr(m); if(m<1||m>30) throw;
    pr(l);
    REP(i,n) prfe(vk[i]);
    REP(i,n) REP(j,1<<n) st[i][j] = INF;
    if((l&1) == 0) throw;
    int glpos = n-1, gllight = 1<<(n-1);

    bool exitflag = false;
    st[0][l] = 0;
    deque<QUE> q;
    q.pb(QUE(0,l));
    while(!q.empty()){
        QUE &qd = q.front();
        int pos = qd.pos, light = qd.light;
        q.pop_front();

        if(pos == glpos){
            exitflag = true;
            if(light == gllight) break;
        }
        int step = st[pos][light];
        FOREACH(it, vk[pos]){
            int &k = *it;
            if(k == pos) continue;
            int nl = light^(1<<k);
            if(st[pos][nl] > step + 1){
                memo[pos][nl].set(pos, light);
                st[pos][nl] = step + 1;
                q.pb(QUE(pos, nl));
                pf("update: %d:%d -> %d:%d, %d\n", pos+1, light, pos+1, nl, step+1);
            }
        }
        FOREACH(it, vst[pos]){
            int &newpos = *it;
            if(!((light >> newpos)&1)) continue;
            if(st[newpos][light] > step + 1){
                memo[newpos][light].set(pos,light);
                st[newpos][light] = step + 1;
                q.pb(QUE(newpos, light));
                pf("update: %d:%d -> %d:%d, %d\n", pos+1, light, newpos+1, light, step+1);
            }
        }

    }
    if(!exitflag){
        printf("Help me!\n");
        return;
    }
    if(st[glpos][gllight] == INF){
        printf("You can not switch off all lights.\n");
        return;
    }

    printf("You can go home in %d steps.\n", st[glpos][gllight]);
    result(glpos,gllight);
    return;
}

int main(){
    while(cin >> n >> m){
        if(n == 0 && m == 0) break;
        REP(i,n) vst[i].clear();
        REP(i,m){
            int s, t;
            cin >> s >> t;
            vst[s-1].pb(t-1);
            vst[t-1].pb(s-1);
        }
        l = 0;
        REP(i,n){
            int t;
            cin >> t;
            if(t) l |= (1<<i);
        }
        REP(i,n){
            int k, kn;
            cin >> k;
            vk[i].clear();
            REP(j,k){
                cin >> kn;
                vk[i].pb(kn-1);
            }
        }
        solve();
    }

    return 0;
}