1 /*
  2 题解：2-SAT
  3 一开始每一个round都有两种状态可选，并且选了每种状态有后面的限制其中一种选后另一状态的状态也被固定，
  4 十分符合2-SAT的用法；
  5 */
  6 #include <cstdio>
  7 #include <cstring>
  8 #include <iostream>
  9 #include <vector>
 10 #include <queue>
 11 
 12 #define clr(a,b) (memset(a,b,sizeof(a)))
 13 #define cpy(a,b) (memcpy(a,b,sizeof(b)))
 14 
 15 using namespace std;
 16 
 17 const int NV = 20005; // 点数要注意，后面是有两个点集
 18 const int NE = 200005; // 边也要注意加边的数量不只是限制条件的数目，因为一个限制条件可能要加几条边
 19 const int W = 0;
 20 const int R = 1;
 21 const int B = 2;
 22 
 23 int opp[NV];
 24 int in[NV];
 25 bool ans[NV];
 26 int col[NV];
 27 int n, nn, m;
 28 inline int Min(int a, int b) {return a < b ? a : b;}
 29 struct SCC {
 30     int deep,scc, top, SZ, n;
 31     struct edge {int v, next;} E[NE];
 32     int pre[NV], dep[NV], low[NV], id[NV], st[NV];
 33     bool in[NV];
 34     inline void init(int _n) {
 35         n = _n;
 36         clr(pre, -1);
 37         clr(dep, -1);
 38         clr(in,false);
 39         deep = scc = SZ = top = 0;
 40     }
 41     void tarjan(int u) {
 42         int v, i;
 43         dep[u] = low[u] = ++ deep;
 44         st[top++] = u;
 45 
 46         in[u] = true;
 47         for (i = pre[u]; i != -1; i = E[i].next) {
 48             v = E[i].v;
 49             if (dep[v] == -1) {
 50                 tarjan(v);
 51                 low[u] = Min(low[u], low[v]);
 52             }
 53             else if (in[v]) {
 54                 low[u] = Min(low[u], dep[v]);
 55             }
 56         }
 57         if (low[u] == dep[u]) {
 58             do {
 59                 v = st[--top];
 60                 in[v] = false;
 61                 id[v] = scc;
 62             } while (u != v);
 63             scc ++;
 64         }
 65     }
 66     inline void insert(int u, int v) {
 67         E[SZ].v = v;
 68         E[SZ].next = pre[u];
 69         pre[u] = SZ ++;
 70     }
 71     inline void solve() {
 72         for (int i = 0; i < n; i++) {
 73             if (dep[i] == -1) {
 74                 tarjan(i);
 75             }
 76         }
 77     }
 78 } G;
 79 int main(void) {
 80     int i, j;
 81     int x, y;
 82     int t;
 83     int alice[20005];
 84     scanf("%d",&t);
 85     for(int cas=1; cas<=t; cas++)
 86     {
 87         int n,m;
 88         scanf("%d%d", &n, &m);
 89         nn = n * 2; // 正反两个点集
 90         for (i = 0; i < nn; i++)
 91             opp[i] = (i ^ 1);
 92 
 93         G.init(nn);
 94         for(int i=0; i<nn; i+=2)
 95         {
 96             int cc;
 97             scanf("%d",&cc);
 98             switch(cc)
 99             {
100             case 1: alice[i] = 1,alice[opp[i]] = 2; break;
101             case 2: alice[i] = 2,alice[opp[i]] = 3; break;
102             case 3: alice[i] = 3,alice[opp[i]] = 1; break;
103             }
104         }
105         for (i = 0; i < m; i++) {
106             int a, b, k;
107             scanf("%d%d%d", &a, &b, &k);
108             a--;
109             a*=2;
110             b--;
111             b*=2;
112             /*
113             此处加边要注意是从0开始，而且偶数为该点集，奇数为对立点集
114             G.insert(x, opp[y]);
115             G.insert(y, opp[x]);
116             */
117             if (k)
118             {
119                 if (alice[a] == alice[b]) // 相等说明a必然要退出opp[b]才能得到正确结果，反过来亦然
120                 {
121                     G.insert(a,opp[b]);
122                     G.insert(b,opp[a]);
123                 }
124                 if (alice[a] == alice[opp[b]])
125                 {
126                     G.insert(a,b);
127                     G.insert(opp[b],opp[a]);
128                 }
129                 if (alice[opp[a]] == alice[b])
130                 {
131                     G.insert(opp[a],opp[b]);
132                     G.insert(b,a);
133                 }
134                 if (alice[opp[a]] == alice[opp[b]])
135                 {
136                     G.insert(opp[a],b);
137                     G.insert(opp[b],a);
138                 }
139             }
140             else
141             {
142                 if (alice[a] != alice[b])
143                 {
144                     G.insert(a,opp[b]);
145                     G.insert(b,opp[a]);
146                 }
147                 if (alice[a] != alice[opp[b]])
148                 {
149                     G.insert(a,b);
150                     G.insert(opp[b],opp[a]);
151                 }
152                 if (alice[opp[a]] != alice[b])
153                 {
154                     G.insert(opp[a],opp[b]);
155                     G.insert(b,a);
156                 }
157                 if (alice[opp[a]] != alice[opp[b]])
158                 {
159                     G.insert(opp[a],b);
160                     G.insert(opp[b],a);
161                 }
162             }
163         }
164         G.solve();
165         for (i = 0; i < nn; i += 2) {
166             if (G.id[i] == G.id[opp[i]]) {
167                 break;
168             }
169         }
170         if (i < nn) { // 不存在
171             printf("Case #%d: no\n",cas);
172         }
173         else
174             printf("Case #%d: yes\n",cas);
175     }
176     return 0;
177 }