use std::io;

macro_rules! parse_input {
   ($x:expr, $t:ident) => ($x.trim().parse::<$t>().unwrap())
}

macro_rules! parse_inputs {
   ($x:expr, $t:ident) => (
       $x.trim()
       .split_whitespace()
       .map(|s| s.parse::<$t>()
       .unwrap()).collect::<Vec<$t>>()
   )
}

macro_rules! print_err {
   ($($arg:tt)*) => (
       {
           use std::io::Write;
           writeln!(&mut ::std::io::stderr(), $($arg)*).ok();
       }
   )
}

fn main() {
    let mut input_line = String::new();
    io::stdin().read_line(&mut input_line).unwrap();
    let nkx = parse_inputs!(input_line, u64);
    let n = nkx[0];
    let k = nkx[1];
    let x = nkx[2];

    let mut c_before = Vec::with_capacity(n as usize);

    for i in 0..n {
        c_before.push(i + 1);
    }

    for _ in 0..x - 1 {
        input_line.clear();
        io::stdin().read_line(&mut input_line).unwrap();
        let swap = parse_inputs!(input_line, u64);
        let tmp = c_before[(swap[0] - 1) as usize];
        c_before[(swap[0] - 1) as usize] = c_before[(swap[1] - 1) as usize];
        c_before[(swap[1] - 1) as usize] = tmp;
    }

    // ? ?
    input_line.clear();
    io::stdin().read_line(&mut input_line).unwrap();

    let mut swap = Vec::new();
    for _ in x..k {
        input_line.clear();
        io::stdin().read_line(&mut input_line).unwrap();
        swap.push(parse_inputs!(input_line, u64));
    }

    input_line.clear();
    io::stdin().read_line(&mut input_line).unwrap();
    let mut c_after = parse_inputs!(input_line, u64);

    for s in swap.iter().rev() {
        let tmp = c_after[(s[0] - 1) as usize];
        c_after[(s[0] - 1) as usize] = c_after[(s[1] - 1) as usize];
        c_after[(s[1] - 1) as usize] = tmp;
    }

    let mut ans = Vec::new();
    for i in 0..(n as usize) {
        if c_before[i] != c_after[i] {
            ans.push(i + 1);
        }
    }
    print!("{} ", ans[0]);
    println!("{}", ans[1]);
}