import std.stdio, std.range, std.algorithm, std.process, std.conv;
import std.stdio, std.typecons, std.conv, std.range, std.algorithm;

/**
int with mod, mod must be prime
 */
struct ModInt(uint MD) if (MD < int.max) {
    import std.conv : to;
    uint v;
    this(int v) {this(long(v));}
    this(long v) {this.v = (v%MD+MD)%MD;}
    static auto normS(uint x) {return (x<MD)?x:x-MD;}
    static auto make(uint x) {ModInt m; m.v = x; return m;}
    /// We can handle it as same as int(but divide is slow)
    auto opBinary(string op:"+")(ModInt r) const {return make(normS(v+r.v));}
    /// ditto
    auto opBinary(string op:"-")(ModInt r) const {return make(normS(v+MD-r.v));}
    /// ditto
    auto opBinary(string op:"*")(ModInt r) const {return make((ulong(v)*r.v%MD).to!uint);}
    /// ditto
    auto opBinary(string op:"/")(ModInt r) const {return this*inv(r);}
    auto opOpAssign(string op)(ModInt r) {return mixin ("this=this"~op~"r");}
    string toString() const {return v.to!string;}
}


public alias Mint = ModInt!(998244353);

struct E {
    int from, to;
    int fromID, toID; // for nice tree decomp
    Mint p;
    this(int from, int to, Mint p) {
        this.from = from;
        this.to = to;
        this.p = p;
    }
}

struct TreeDecomp {
    int[][] bags;
    int[][] tr;
}

enum NodeType {
    Leaf,
    Add,
    Erase,
    Merge,
}

struct NiceTreeDecomp {
    struct Node {
        NodeType type;
        int cngVertex;
        int cngID;
        int[] bag;
        int[] ch;
        E[] elist;        
    }
    static Node LeafNode() {
        return Node(NodeType.Leaf, -1, -1, [], [], []);
    }
    static Node AddNode(in int[] ch, int v) {
        return Node(NodeType.Add, v, -1, [], ch.dup, []);
    }
    static Node EraseNode(in int[] ch, int v) {
        return Node(NodeType.Erase, v, -1, [], ch.dup, []);
    }
    static Node MergeNode(in int[] ch) {
        return Node(NodeType.Merge, -1, -1, [], ch.dup, []);
    }
    int gn;
    Node[] node;
    this(int gn) {
        this.gn = gn;
    }
}

string decomp_info = "
s td 415 9 426
b 1 27 29
b 2 27 30
b 3 26 27
b 4 36 37
b 5 28 36
b 6 49 50
b 7 49 60
b 8 55 56
b 9 51 56
b 10 51 52
b 11 45 52
b 12 45 46
b 13 46 82
b 14 57 60
b 15 41 57
b 16 40 41
b 17 40 59
b 18 58 59
b 19 58 77
b 20 72 77
b 21 71 72
b 22 78 79
b 23 75 78
b 24 62 75
b 25 61 62
b 26 61 64
b 27 63 64
b 28 54 63
b 29 81 82
b 30 71 81
b 31 70 71
b 32 33 70
b 33 101 103
b 34 101 102
b 35 102 109
b 36 106 109
b 37 104 106
b 38 104 105
b 39 105 108
b 40 24 108
b 41 114 126 148
b 42 118 129 132
b 43 140 143
b 44 139 140
b 45 147 151
b 46 135 147
b 47 134 135
b 48 134 144
b 49 138 144
b 50 137 138
b 51 131 137
b 52 173 175
b 53 172 173
b 54 170 172
b 55 169 170
b 56 169 178
b 57 171 176
b 58 156 171
b 59 155 156
b 60 155 186
b 61 166 178
b 62 165 166
b 63 165 177
b 64 161 177
b 65 160 161
b 66 179 180
b 67 179 182
b 68 182 183
b 69 164 183
b 70 162 164
b 71 168 186
b 72 167 168
b 73 181 188
b 74 34 162 189
b 75 33 191
b 76 209 211 409
b 77 209 212
b 78 193 220
b 79 193 194
b 80 194 203
b 81 203 204
b 82 219 221
b 83 218 219
b 84 196 218
b 85 195 196
b 86 195 217
b 87 216 217
b 88 215 216
b 89 210 215
b 90 208 210
b 91 199 222
b 92 167 199
b 93 227 241
b 94 227 228
b 95 228 235
b 96 235 236
b 97 242 243
b 98 242 244
b 99 242 245
b 100 245 257
b 101 246 247
b 102 246 256
b 103 253 254
b 104 253 255
b 105 255 263
b 106 256 257
b 107 256 260
b 108 260 261
b 109 258 261
b 110 251 258
b 111 250 251
b 112 249 263
b 113 248 249
b 114 274 275
b 115 274 283
b 116 273 283
b 117 272 273
b 118 272 292
b 119 286 288
b 120 276 289 290
b 121 270 292
b 122 269 270
b 123 269 277
b 124 276 277
b 125 299 300
b 126 284 300
b 127 284 285
b 128 285 303
b 129 296 301
b 130 295 296
b 131 267 303
b 132 267 268
b 133 268 280
b 134 280 281
b 135 281 282
b 136 304 305
b 137 304 306
b 138 291 306
b 139 287 291
b 140 286 287
b 141 266 286
b 142 265 266
b 143 265 297
b 144 278 297
b 145 276 278
b 146 276 289
b 147 26 310
b 148 320 321
b 149 320 342
b 150 360 361
b 151 360 388
b 152 309 372
b 153 308 309
b 154 308 374
b 155 348 374
b 156 328 384
b 157 348 385
b 158 347 348
b 159 315 347
b 160 314 315
b 161 314 371
b 162 328 371
b 163 386 387
b 164 381 386
b 165 343 381
b 166 342 343
b 167 342 380
b 168 319 380
b 169 318 319
b 170 318 378
b 171 382 388
b 172 390 391
b 173 322 390
b 174 322 323
b 175 323 332
b 176 332 359
b 177 10 359
b 178 10 11
b 179 11 14
b 180 14 20
b 181 20 21
b 182 21 25
b 183 8 25
b 184 8 9
b 185 403 404
b 186 404 418
b 187 395 418
b 188 395 396
b 189 396 401
b 190 401 422
b 191 415 422
b 192 407 415
b 193 282 426
b 194 1 2 22
b 195 5 6 24
b 196 1 6 24
b 197 1 24 94
b 198 9 12 13
b 199 13 15 16
b 200 13 16 19
b 201 7 17 18
b 202 13 19 24
b 203 31 32 33
b 204 38 39 47
b 205 43 44 68
b 206 38 47 48
b 207 53 54 80
b 208 54 74 80
b 209 66 67 76
b 210 43 68 69
b 211 43 69 76
b 212 74 80 83
b 213 67 80 83
b 214 35 84 85
b 215 1 86 96
b 216 87 88 98
b 217 24 76 89
b 218 90 91 93
b 219 4 91 93
b 220 92 93 107
b 221 4 93 107
b 222 1 96 97
b 223 4 85 107
b 224 110 111 113
b 225 95 112 113
b 226 35 85 116 149
b 227 26 117 133
b 228 118 119 129
b 229 120 121 128
b 230 26 121 128
b 231 34 124 125
b 232 127 128 136
b 233 26 128 136
b 234 26 133 145
b 235 26 34 145
b 236 26 136 142
b 237 139 148 352
b 238 119 141 146
b 239 119 146 148
b 240 119 129 148
b 241 26 142 150
b 242 26 28 150
b 243 26 28 344
b 244 34 152 190
b 245 33 34 190
b 246 153 154 174
b 247 154 157 158
b 248 154 158 162
b 249 122 159 174
b 250 162 163 167
b 251 160 162 167
b 252 160 162 226
b 253 122 154 174
b 254 154 160 184
b 255 32 154 185
b 256 33 122 187
b 257 24 83 192
b 258 197 198 204
b 259 198 204 205
b 260 83 200 206
b 261 201 202 214
b 262 33 202 214
b 263 204 205 344
b 264 205 213 344
b 265 83 206 207
b 266 83 207 208
b 267 83 208 209
b 268 83 209 409
b 269 213 214 344
b 270 33 214 344
b 271 26 33 344
b 272 223 224 237
b 273 229 230 238
b 274 230 233 238
b 275 231 232 240
b 276 1 231 240
b 277 233 234 238
b 278 234 236 238
b 279 7 237 239
b 280 248 252 419
b 281 250 252 259
b 282 252 259 419
b 283 259 262 419
b 284 236 262 419
b 285 97 264 298
b 286 18 237 271
b 287 7 18 237 295
b 288 282 302 425
b 289 65 293 294
b 290 88 97 298
b 291 295 302 425
b 292 9 307 352
b 293 42 311 326
b 294 312 313 368
b 295 234 316 317
b 296 234 317 365
b 297 324 325 327
b 298 42 326 354
b 299 325 327 350
b 300 224 328 375
b 301 329 330 339
b 302 329 331 340
b 303 333 334 341
b 304 334 341 364
b 305 335 336 354
b 306 336 354 382
b 307 337 338 351
b 308 338 351 358
b 309 329 339 357
b 310 329 340 353
b 311 341 364 373
b 312 234 345 346
b 313 234 346 349
b 314 325 349 350
b 315 349 351 358
b 316 9 148 352
b 317 329 353 356
b 318 354 355 376
b 319 33 329 356
b 320 329 357 362
b 321 312 349 358
b 322 149 329 362
b 323 131 363 364
b 324 131 364 373
b 325 9 234 365
b 326 13 366 367
b 327 13 289 367
b 328 312 368 369
b 329 312 369 370
b 330 312 370 389
b 331 131 373 375
b 332 131 224 375
b 333 354 376 383
b 334 224 377 379
b 335 181 224 379
b 336 312 354 382
b 337 354 378 383
b 338 26 312 389
b 339 114 392 417
b 340 393 394 416
b 341 394 416 421
b 342 397 398 407
b 343 398 402 407
b 344 399 400 417
b 345 400 412 417
b 346 97 402 407
b 347 48 279 405
b 348 115 406 416
b 349 225 408 413
b 350 83 409 411
b 351 410 411 412
b 352 83 411 412
b 353 83 412 417
b 354 111 225 413
b 355 48 97 414
b 356 115 416 421
b 357 83 114 417
b 358 236 419 420
b 359 236 420 421
b 360 115 236 421
b 361 312 378 423
b 362 113 424 425
b 363 113 295 425
b 364 3 4 23 279
b 365 26 33 34 312
b 366 4 35 85 149
b 367 99 100 111 129
b 368 1 13 22 65 97 111 224 225 234
b 369 4 22 38 65 97 111 224 225 234
b 370 4 38 111 113 224 225
b 371 4 7 38 113 224 225
b 372 4 7 95 113 225
b 373 7 38 113 224 237
b 374 4 22 38 48 65 97 225
b 375 4 22 48 65 225 279
b 376 4 22 23 225 279
b 377 4 35 38 65 97 224 234
b 378 4 35 38 97 149 224 234
b 379 33 35 38 42 97 149 224 234
b 380 33 34 38 42 97 149 224 234
b 381 33 34 38 42 149 154 224
b 382 32 33 34 38 149 154 224
b 383 32 38 149 181 224
b 384 33 34 42 122 149 154
b 385 33 34 42 73 122 149
b 386 73 122 123 149
b 387 34 73 122 124
b 388 34 149 154 160 224
b 389 33 34 42 97 149 234 349
b 390 33 34 42 97 149 349 407
b 391 33 34 42 312 349 407
b 392 42 312 378 407
b 393 33 97 149 325 349 407
b 394 35 38 65 97 98
b 395 35 38 88 97 98
b 396 1 13 22 43 65 111 224 225 234
b 397 1 13 24 43 111 115 224 234
b 398 9 13 24 43 111 115 224 234
b 399 9 24 43 76 111 115 224
b 400 9 24 76 111 115 129 224
b 401 9 24 67 76 115 129 224
b 402 9 24 67 115 129 148
b 403 24 67 83 115 148
b 404 67 129 131 224
b 405 76 100 111 129
b 406 1 115 234 236
b 407 1 231 234 236
b 408 13 22 65 97 289
b 409 83 114 115 148
b 410 67 129 130 131
b 411 34 154 160 162
b 412 22 65 289 294
b 413 7 113 237 295
b 414 33 149 325 329
b 415 42 312 354 378
1 3
2 3
3 365
4 5
5 243
6 7
7 14
8 9
9 10
10 11
11 12
12 13
13 29
14 15
15 16
16 17
17 18
18 19
19 20
20 21
21 31
22 23
23 24
24 25
25 26
26 27
27 28
28 208
29 30
30 31
31 32
32 379
33 34
34 35
35 36
36 37
37 38
38 39
39 40
40 397
41 409
42 228
43 44
44 237
45 46
46 47
47 48
48 49
49 50
50 51
51 404
52 53
53 54
54 55
55 56
56 61
57 58
58 59
59 60
60 71
61 62
62 63
63 64
64 65
65 388
66 67
67 68
68 69
69 70
70 411
71 72
72 251
73 383
74 411
75 379
76 268
77 268
78 79
79 80
80 81
81 263
82 83
83 84
84 85
85 86
86 87
87 88
88 89
89 90
90 267
91 92
92 251
93 94
94 95
95 96
96 406
97 99
98 99
99 100
100 106
101 102
102 107
103 104
104 105
105 112
106 107
107 108
108 109
109 110
110 111
111 281
112 113
113 280
114 115
115 116
116 117
117 118
118 121
119 141
120 146
121 122
122 123
123 124
124 146
125 126
126 127
127 128
128 131
129 130
130 413
131 132
132 133
133 134
134 135
135 288
136 137
137 138
138 139
139 140
140 141
141 142
142 143
143 144
144 145
145 146
146 408
147 365
148 149
149 167
150 151
151 171
152 153
153 154
154 155
155 158
156 300
157 158
158 159
159 160
160 161
161 162
162 300
163 164
164 165
165 166
166 167
167 168
168 169
169 170
170 392
171 336
172 173
173 174
174 175
175 176
176 177
177 178
178 179
179 180
180 181
181 182
182 183
183 184
184 398
185 186
186 187
187 188
188 189
189 190
190 191
191 192
192 390
193 288
194 368
195 196
196 397
197 397
198 398
199 200
200 202
201 287
202 397
203 382
204 206
205 210
206 374
207 208
208 212
209 401
210 211
211 399
212 213
213 403
214 366
215 222
216 395
217 399
218 219
219 221
220 221
221 223
222 368
223 366
224 370
225 372
226 366
227 234
228 240
229 230
230 233
231 387
232 233
233 236
234 235
235 365
236 241
237 316
238 239
239 240
240 402
241 242
242 243
243 271
244 245
245 380
246 253
247 248
248 411
249 253
250 251
251 411
252 411
253 384
254 388
255 382
256 384
257 403
258 259
259 263
260 265
261 262
262 270
263 264
264 269
265 266
266 267
267 268
268 350
269 270
270 271
271 365
272 373
273 274
274 277
275 276
276 407
277 278
278 406
279 373
280 282
281 282
282 283
283 284
284 358
285 290
286 287
287 413
288 291
289 412
290 395
291 363
292 316
293 298
294 328
295 296
296 325
297 299
298 415
299 314
300 332
301 309
302 310
303 304
304 311
305 306
306 336
307 308
308 315
309 320
310 317
311 324
312 313
313 389
314 393
315 321
316 402
317 319
318 333
319 414
320 322
321 391
322 414
323 324
324 331
325 398
326 327
327 408
328 329
329 330
330 338
331 332
332 404
333 337
334 335
335 383
336 415
337 415
338 365
339 357
340 341
341 356
342 343
343 346
344 345
345 353
346 390
347 375
348 356
349 354
350 352
351 352
352 353
353 357
354 368
355 374
356 360
357 409
358 359
359 360
360 406
361 392
362 363
363 413
364 376
365 391
366 378
367 405
368 369
368 396
368 408
369 370
369 374
369 377
370 371
371 372
371 373
373 413
374 375
375 376
377 378
377 394
378 379
379 380
380 381
380 389
381 382
381 384
381 388
382 383
384 385
385 386
385 387
388 411
389 390
390 391
390 393
391 392
392 415
393 414
394 395
396 397
397 398
397 406
398 399
399 400
400 401
400 405
401 402
401 404
402 403
403 409
404 410
406 407
408 412
";

TreeDecomp readTD() {
    string[] inp = decomp_info.split("\n").filter!(x => x.length).array();
    inp = inp[1..$];
    int tn, tw, bn;
    tn = 415; tw = 9; bn = 426;

    TreeDecomp td;
    td.bags = new int[][](tn);
    td.tr = new int[][](tn);
    foreach (i; 0..tn) {
        auto s = inp[0].split(" ").array();
        inp = inp[1..$];

        assert(s[0] == "b");
        s = s[1..$];

        int[] arr;
        arr = s.map!(x => x.to!int).array;        
        arr[] -= 1;

        assert(arr[0] == i);
        td.bags[i] = arr[1..$];
    }
    foreach (i; 0..tn-1) {
        auto s = inp[0].split(" ").array();       
        inp = inp[1..$];
        assert(s.length == 2) ;
        int a = s[0].to!int, b = s[1].to!int;
        a--; b--;
        td.tr[a] ~= b; td.tr[b] ~= a;
    }
    return td;
}

NiceTreeDecomp makeNiceTreeDecomp(in TreeDecomp td, in E[][] g) {
    NiceTreeDecomp ntd = NiceTreeDecomp(g.length.to!int);
    void dfs(int p, int b) {
        int base = ntd.node.length.to!int;
        auto ch = td.tr[p].filter!(d => d != b).array;
        if (ch.length == 0) {
            //leaf
            int st = base;
            auto bag = td.bags[p];
            assert(bag.length);
            foreach (i; 0..bag.length) {
                ntd.node ~= NiceTreeDecomp.AddNode([st+1], bag[i]);
                st++;
            }
            ntd.node ~= NiceTreeDecomp.LeafNode();
            return;
        }
        auto bag = td.bags[p].dup;
        int cn = ch.length.to!int;
        foreach (i; 1..cn) {
            ntd.node ~= NiceTreeDecomp.MergeNode([base-1+2*i, base-1+2*i+1]);
        }
        int[] csv;
        foreach (d; ch) {
            int st = ntd.node.length.to!int;
            csv ~= st;
            auto pbags = td.bags[p];
            auto cbags = td.bags[d];
            auto adds = pbags.filter!(pv => cbags.count(pv) == 0).array;
            auto erases = cbags.filter!(cv => pbags.count(cv) == 0).array;
            foreach (av; adds) {
                ntd.node ~= NiceTreeDecomp.AddNode([st+1], av);
                bag = bag.filter!(x => x != av).array;
                st++;
            }
            foreach (ev; erases) {
                ntd.node ~= NiceTreeDecomp.EraseNode([st+1], ev);
                st++;
            }
            dfs(d, p);
        }
        assert(csv.length == cn);        
        foreach (i; 1..cn) {
            if (cn <= 2*i) {
                ntd.node[base+i-1].ch[0] = csv[2*i-cn];
            }
            if (cn <= 2*i+1) {
                ntd.node[base+i-1].ch[1] = csv[2*i+1-cn];
            }
        }
    }
    dfs(0, -1);

    //writeln(ntd);
    // spread bag
    foreach_reverse (i, ref nd; ntd.node) {
        foreach (c; nd.ch) assert(i < c);
        final switch (nd.type) {
        case NodeType.Leaf:
            assert(nd.ch.length == 0);
            break;
        case NodeType.Add:
            assert(nd.ch.length == 1);
            nd.bag = ntd.node[nd.ch[0]].bag.dup;            
            nd.bag ~= nd.cngVertex;
            nd.bag.sort!"a<b";
            nd.cngID = iota(nd.bag.length.to!int)
                .filter!(x => nd.bag[x] == nd.cngVertex).front;
            break;
        case NodeType.Erase:
            assert(nd.ch.length == 1);
            nd.bag = ntd.node[nd.ch[0]].bag.dup;
            nd.cngID = iota(nd.bag.length.to!int)
                .filter!(x => nd.bag[x] == nd.cngVertex).front;
            nd.bag = nd.bag.filter!(x => x != nd.cngVertex).array;
            break;
        case NodeType.Merge:
            assert(nd.ch.length == 2);
            assert(equal(ntd.node[nd.ch[0]].bag, ntd.node[nd.ch[1]].bag));
            nd.bag = ntd.node[nd.ch[0]].bag.dup;
            break;
        }
    }

    // spread edge
    foreach (v; g) {
        foreach (e; v) {
            bool ok = false;
            foreach (ref nd; ntd.node) {
                bool f = nd.bag.count(e.from) > 0 && nd.bag.count(e.to) > 0;
                if (!f) continue;
                ok = true;
                nd.elist ~= e;
                break;
            }
            assert(ok);
        }
    }
    return ntd;
}

Mint calcOneSuper(bool[] must, in NiceTreeDecomp ntd) {
    // writeln(must);
    alias B = Tuple!(immutable int[], "g", Mint, "p");
    alias M = Mint[int[]];
    M[] dp = new M[](ntd.node.length);

    foreach_reverse (ph, nd; ntd.node)
    {
        M ndp;
        final switch (nd.type)
        {
        case NodeType.Leaf :
            ndp[[]] = Mint(1);
            break;
        case NodeType.Add :
            int addV = nd.cngVertex;

            auto cdp = dp[nd.ch[0]];
            foreach (f, p; cdp)
            {

                if (!must[addV]) {
                    if (f !in ndp) {
                        ndp[f] = Mint(0);
                    }
                    ndp[f] += p;
                }

                auto nf = f.dup;
                nf ~= addV;
                nf.sort!"a<b";
                ndp[nf.idup] = p;
            }
            break;
        case NodeType.Erase :
            int eraV = nd.cngVertex;

            auto cdp = dp[nd.ch[0]];
            foreach (f, p; cdp)
            {
                auto nf = f.dup;
                nf = nf.filter!(x => x != eraV).array;
                if (nf !in ndp) {
                    ndp[nf.idup] = Mint(0);
                }
                ndp[nf.idup] += p;
            }
            break;
        case NodeType.Merge :
            auto ldp = dp[nd.ch[0]];
            auto rdp = dp[nd.ch[1]];
            foreach (lg, lp; ldp)
            {
                if (lg !in rdp)
                    continue;
                ndp[lg] = lp * rdp[lg];
            }
            break;
        }

        //writeln(ph, nd, ndp.length);

        E[] elist = nd.elist.dup;
        foreach (e; elist)
        {
            M ndp2;
            foreach (f, p; ndp)
            {
                if (f.count(e.from) != 0 && f.count(e.to) != 0)
                {
                    continue;
                }
                ndp2[f.idup] = p;
            }
            ndp = ndp2;
        }
        dp[ph] = ndp;
    }
    Mint sm = 0;
    foreach (g, p; dp[0])    
    {
        sm += p;
    }
    return sm;
}

import std.stdio;
import std.conv;
import std.string;
import std.format;
import std.algorithm;

void main() {
    E[][] g = new E[][](426);
    bool[] must = new bool[](426);
    {
        int m = readln().strip().to!int;

        assert(m == 505);
        int[string] to_id;

        foreach (i; 0..m) {
            auto sp = readln.split(" ").array;
            string s = sp[0].strip(), t = sp[1].strip();

            if (s !in to_id) {
                to_id[s] = to_id.length.to!int;
            }
            int si = to_id[s];

            if (t !in to_id) {
                to_id[t] = to_id.length.to!int;
            }
            int ti = to_id[t];

            g[si] ~= E(si, ti, Mint(1));
            g[ti] ~= E(ti, si, Mint(1));
        }
        int k = readln.strip.to!int;
                
        foreach (i; 0..k) {
            string s = readln.strip;
            int si = to_id[s];
            // writeln(si);
            must[si] = true;
        }
    };

    auto td = readTD();
    auto ntd = makeNiceTreeDecomp(td, g);

    auto ans = calcOneSuper(must, ntd);
    writeln(ans.v);
}