use std::io;
use std::str::FromStr;
use std::cmp::min;
use std::cmp::max;

fn input_tuple() -> (u64, u64, u64) {
    let mut line: String = String::new();
    io::stdin().read_line(&mut line);
    let vec: Vec<u64> = line.split_whitespace().map(|s| s.parse().unwrap()).collect();
    (vec[0], vec[1], vec[2])
}

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

fn main() {
    let (a, b, q) = input_tuple();
    let mut s_vec: Vec<u64> = Vec::new();
    let mut t_vec: Vec<u64> = Vec::new();
    let mut x_vec: Vec<u64> = Vec::new();
    for _ in 0..a {
        let s: u64 = input();
        s_vec.push(s);
    }
    for _ in 0..b {
        let t: u64 = input();
        t_vec.push(t);
    }
    for _ in 0..q {
        let x: u64 = input();
        x_vec.push(x);
    }

    for x in x_vec {
        match s_vec.binary_search(&x) {
            Ok(s_idx) => {
                let t_idx = t_vec.binary_search(&x).unwrap_err();
                let mut tmp1 = 1_000_000_000_000;
                if t_idx < t_vec.len() && s_idx < s_vec.len() {
                    tmp1 = t_vec[t_idx] - s_vec[s_idx];
                }
                let mut tmp2 = 1_000_000_000_000;
                if t_idx > 0 {
                    tmp2 = s_vec[s_idx] - t_vec[t_idx - 1];
                }
                println!("{}", min(tmp1, tmp2));
            },
            Err(s_idx) => {
                match t_vec.binary_search(&x) {
                    Ok(t_idx) => {
                        let mut tmp1 = 1_000_000_000_000;
                        if s_idx < s_vec.len() && t_idx < t_vec.len() {
                            tmp1 = s_vec[s_idx] - t_vec[t_idx];
                        }
                        let mut tmp2 = 1_000_000_000_000;
                        if s_idx > 0 {
                            tmp2 = t_vec[t_idx] - s_vec[s_idx];
                        }
                        println!("{}", min(tmp1, tmp2));
                    },
                    Err(t_idx) => {
                        let mut tmp1 = 1_000_000_000_000;
                        if t_idx > 0 && s_idx > 0 {
                            tmp1 = x - min(t_vec[t_idx - 1], s_vec[s_idx - 1]);  // -s-t-x- or -t-s-x-
                        }
                        let mut tmp2 = 1_000_000_000_000;
                        if s_idx > 0 && t_idx < t_vec.len() {
                            tmp2 = t_vec[t_idx] - s_vec[s_idx - 1] + min(x - s_vec[s_idx - 1], t_vec[t_idx] - x); // -s-x-t-
                        }
                        let mut tmp3 = 1_000_000_000_000;
                        if t_idx > 0 && s_idx < s_vec.len() {
                            tmp3 = s_vec[s_idx] - t_vec[t_idx - 1] + min(x - t_vec[t_idx - 1], s_vec[s_idx] - x); // -t-x-s-
                        }
                        let mut tmp4 = 1_000_000_000_000;
                        if t_idx < t_vec.len() && s_idx < s_vec.len() {
                            tmp4 = max(t_vec[t_idx], s_vec[s_idx]) - x; // -x-t-s- or -x-s-t-
                        }
                        println!("{}", min(min(tmp1, tmp2), min(tmp3, tmp4)));
                    }
                }
            },
        }
    }
 
}


Measured memory_bytes: 9468