Problem:
Score: 300 points

Problem Statement

We have a 3 \times 3 grid. A number c_{i, j} is written in the square (i, j), where (i, j) denotes the square at the i-th row from the top and the j-th column from the left.

According to Takahashi, there are six integers a_1, a_2, a_3, b_1, b_2, b_3 whose values are fixed, and the number written in the square (i, j) is equal to a_i + b_j.

Determine if he is correct.

Constraints

c_{i, j} \ (1 \leq i \leq 3, 1 \leq j \leq 3) is an integer between 0 and 100 (inclusive).

Input

Input is given from Standard Input in the following format:

c_{1,1} c_{1,2} c_{1,3}
c_{2,1} c_{2,2} c_{2,3}
c_{3,1} c_{3,2} c_{3,3}

Output

If Takahashi's statement is correct, print Yes; otherwise, print No.

Sample Input 1

1 0 1
2 1 2
1 0 1

Sample Output 1

Yes

Takahashi is correct, since there are possible sets of integers such as: a_1=0,a_2=1,a_3=0,b_1=1,b_2=0,b_3=1.

Sample Input 2

2 2 2
2 1 2
2 2 2

Sample Output 2

No

Takahashi is incorrect in this case.

Sample Input 3

0 8 8
0 8 8
0 8 8

Sample Output 3

Yes

Sample Input 4

1 8 6
2 9 7
0 7 7

Sample Output 4

No

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().split_whitespace()
        .map(|e| e.parse().ok().unwrap()).collect()
}

fn read_vec_raw<>() -> Vec<String> {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().split_whitespace().map(|e| e.to_string()).collect::<Vec<String>>().clone()
}

fn read_vec2<T: std::str::FromStr>(n: usize) -> Vec<Vec<T>> {
    let mut v2 = Vec::new();
    for _ in 0..n {
        let mut s = String::new();
        std::io::stdin().read_line(&mut s).ok();
        let v = s.trim().split_whitespace()
            .map(|e| e.parse().ok().unwrap()).collect();
        v2.push(v);
    }
    v2
}

/*fn get_score(r: usize,c:usize,n: usize,map: &Vec<Vec<usize>>) -> usize {
    let current = map[r][c].clone();
    match r {
        0 => if c < n - 1 { current + map[r + 1][c + 1] } else { current }
        1 => if c > 0 { current + map[r - 1][c - 1]} else {current}
        _ => panic!()
    }
}*/

fn get_result(return_point: usize,n: usize,map: &Vec<Vec<usize>>) -> usize{

    let mut r = 0;
    let mut c = 0;
    let mut flag = false;
    let mut result = map[r][c];

    for i in 0..n {
        if c == return_point && !flag {
            r = 1;
            flag = true;
            result += map[r][c]
        } else {
            c += 1;
            result += map[r][c]
        }
    }
    result
}

fn solve_a(){

    /*let mut str1 = read_vec_raw()[0].clone();
    let str2 = read_vec_raw()[0].clone();
    str1.push_str(&str2);*/

    let vec1 : Vec<Vec<usize>> = read_vec2(1);
    let n : usize = vec1[0][0].clone();
    let m : usize = vec1[0][1].clone();
    let mut vec2 : Vec<Vec<usize>> = read_vec2(m);
    vec2.sort();


    /*let mut graph = vec![vec![0;n];n];

    for v in vec2.iter() {
        let diff = v[1] - v[0];
        if diff == 1  {
            graph[v[0] - 1][v[1] - 1] = v[2];
            graph[v[1] - 1][v[0] - 1] = v[2];
        } else {

        }
    }*/

    println!("{:?}",vec2);

}

fn max(a: usize,b:usize) -> usize {
    if a > b {
        a
    } else {
        b
    }
}

fn min(a: usize,b:usize) -> usize {
    if a > b {
        b
    } else {
        a
    }
}

fn diff(a: usize,b: usize) -> usize {
    max(a,b) - min(a,b)
}

fn solve_c() {
    let grid: Vec<Vec<i32>> = read_vec2(3);
    let mut f = true;

    for i in 0..3 {
        for j in 0..3 {
            for k in 0..3 {
                for l in 0..3 {
                    if grid[i][j] + grid[k][l] != grid[j][k] + grid[i][l] {
                        f = false;
                    }
                }
            }
        }
    }
    if f {
        println!("Yes");    
    } else {
        println!("No");
    }
    
}

fn main (){

    solve_c();
}