Problem:
Score : 200 points

Problem Statement

We have a bingo card with a 3\times3 grid. The square at the i-th row from the top and the j-th column from the left contains the number A_{i, j}.

The MC will choose N numbers, b_1, b_2, \cdots, b_N. If our bingo sheet contains some of those numbers, we will mark them on our sheet.

Determine whether we will have a bingo when the N numbers are chosen, that is, the sheet will contain three marked numbers in a row, column, or diagonal.

Constraints

All values in input are integers.

1 \leq A_{i, j} \leq 100

A_{i_1, j_1} \neq A_{i_2, j_2} ((i_1, j_1) \neq (i_2, j_2))

1 \leq N \leq 10

1 \leq b_i \leq 100

b_i \neq b_j (i \neq j)

Input

Input is given from Standard Input in the following format:

A_{1, 1} A_{1, 2} A_{1, 3}
A_{2, 1} A_{2, 2} A_{2, 3}
A_{3, 1} A_{3, 2} A_{3, 3}
N
b_1
\vdots
b_N

Output

If we will have a bingo, print Yes; otherwise, print No.

Sample Input 1

84 97 66
79 89 11
61 59 7
7
89
7
87
79
24
84
30

Sample Output 1

Yes

We will mark A_{1, 1}, A_{2, 1}, A_{2, 2}, A_{3, 3}, and complete the diagonal from the top-left to the bottom-right.

Sample Input 2

41 7 46
26 89 2
78 92 8
5
6
45
16
57
17

Sample Output 2

No

We will mark nothing.

Sample Input 3

60 88 34
92 41 43
65 73 48
10
60
43
88
11
48
73
65
41
92
34

Sample Output 3

Yes

We will mark all the squares.

Solution in Rust (1.15.1) (judge verdict: Accepted)

use std::io::{BufRead, BufReader};

fn main(){
    // init
    let lines = read::<String>();

    let amat: Vec<Vec<i32>> =
        lines.iter().take(3)
        .map(|l| 
             l.split(' ')
             .map(|k| k.parse::<i32>().unwrap()).collect())
        .collect();

    let _n: i32 = lines[3].parse().unwrap();

    let bb: Vec<i32> = lines.iter().skip(4).map(|k| k.parse().unwrap()).collect();

    // bingo
    let mut result_mat = vec![[false,false,false]; 3];
    for (i, line) in amat.iter().enumerate() {
        for (j, val) in line.iter().enumerate(){
            if bb.iter().any(|b| b == val) {
                result_mat[i][j] = true;
            };
        }
    }

    // before check
    let mut result = false;
    let mut flat_results: Vec<bool> = Vec::new();
    for (_i, line) in result_mat.iter().enumerate() {
        for (_j, val) in line.iter().enumerate() {
            flat_results.push(*val);
        }
    }
    
    // yoko
    if result_mat.iter().map(|line| line.iter().all(|r| r == &true)).any(|r| r ) {
        result = true;
    }

    // tate
    if flat_results[0] && flat_results[3] && flat_results[6] {
        result = true;
    }

    if flat_results[1] && flat_results[4] && flat_results[7] {
        result = true;
    }

    if flat_results[2] && flat_results[5] && flat_results[8] {
        result = true;
    }

    // naname
    if flat_results[0] && flat_results[4] && flat_results[8] {
        result = true;
    }
    
    if flat_results[2] && flat_results[4] && flat_results[6] {
        result = true;
    }

    if result {
        println!("Yes");
    } else {
        println!("No");
    }
}

fn read<T>() -> Vec<T>
where
  T: std::str::FromStr,
  T::Err: std::fmt::Debug,
{
    let lines: Vec<T> =
        BufReader::new(std::io::stdin())
        .lines()
        .map(|l| l.unwrap().parse::<T>().unwrap())
        .collect();
    lines
}