Problem:
Score : 100 points

Problem Statement

We have A balls with the string S written on each of them and B balls with the string T written on each of them.

From these balls, Takahashi chooses one with the string U written on it and throws it away.

Find the number of balls with the string S and balls with the string T that we have now.

Constraints

S, T, and U are strings consisting of lowercase English letters.

The lengths of S and T are each between 1 and 10 (inclusive).

S \not= T

S=U or T=U.

1 \leq A,B \leq 10

A and B are integers.

Input

Input is given from Standard Input in the following format:

S T
A B
U

Output

Print the answer, with space in between.

Sample Input 1

red blue
3 4
red

Sample Output 1

2 4

Takahashi chose a ball with red written on it and threw it away.
Now we have two balls with the string S and four balls with the string T.

Sample Input 2

red blue
5 5
blue

Sample Output 2

5 4

Takahashi chose a ball with blue written on it and threw it away.
Now we have five balls with the string S and four balls with the string T.

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

fn main() {
    let r = std::io::stdin();
    let mut sc = Scanner::new(r.lock());

    let v = sc.read_line();
    let (s, t) : (&String, &String) = (&v[0], &v[1]);

    let v = sc.read_line();
    let (a, b) : (usize, usize) = (v[0].parse().unwrap(), v[1].parse().unwrap());

    let v = sc.read_line();
    let u: &String = &v[0];

    if u == s {
        println!("{} {}", a - 1, b);
    } else {
        println!("{} {}", a, b - 1);
    }

}
 
fn solve(n: usize, v: Vec<String>) -> bool {
    for i in 0..n {
        let x: usize = v[i].parse().unwrap();
        if x % 2 == 0 { // 偶数
            if x % 3 != 0 && x % 5 != 0 { // 3 でも 5 でも割れない
                return false;
            }
        }
    }

    true
}

pub struct Scanner<R: std::io::Read> (std::io::BufReader<R>);
 
impl<R: std::io::Read> Scanner<R> {
    pub fn new(r: R) -> Scanner<R> {
        Scanner (std::io::BufReader::new(r))
    }
 
    pub fn read_line(&mut self) -> Vec<String> {
        use std::io::BufRead;
        let mut line = String::new();
        self.0
            .read_line(&mut line)
            .unwrap();
 
        line.split_whitespace()
            .map(|b| b.to_string())
            .collect::<Vec<String>>()
    }
}