#![allow(unused_mut, unused_macros, unused_variables, unused_assignments, non_snake_case, unused_imports, dead_code, non_camel_case_types)]

use std::collections::{HashMap, BinaryHeap, BTreeMap};

// [Rustで競技プログラミングの入力をスッキリ記述するマクロ - Qiita]
// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 から拝借
macro_rules! input {
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}
macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};
    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}
macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };
    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };
    // ABC128-C-Switches用に拡張
    ($next:expr, [ $t:tt ]) => {{
        let len = read_value!($next, $t);
        (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    }};
    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };
    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };
    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

// 可愛い可愛い、お手製のライブラリ達
// 出力
macro_rules! p {
    ($t:expr) => {
        println!("{}", $t);
    };
}
macro_rules! debug {
    ($t:expr) => {
        println!("{:?}", $t);
    };
}
// 最大公約数 / 最小公倍数
fn gcd(a:usize, b:usize) -> usize {
    if b == 0 {return a};
    gcd(b, a % b)
}
fn lcm(a:usize, b:usize) -> usize {
    a / gcd(a, b) * b
}
// 置換
macro_rules! chmax {
    ($x : expr, $y : expr) => {
        if $x < $y {$x = $y;}
    }
}
macro_rules! chmin {
    ($x : expr, $y : expr) => {
        if $x > $y {$x = $y;}
    }
}
// Union-Find木
struct uft {
    g: Vec<isize>,
}
impl uft {
    fn new(n:usize) -> uft {
        uft {g:vec![-1; n]}
    }
    fn root(&mut self, a:usize) -> usize {
        let va = self.g[a];
        if va.is_negative() {a}
        else {
            let na = self.root(va as usize);
            self.g[a] = na as isize;
            na
        }
    }
    fn merge(&mut self, a:usize, b:usize) -> bool {
        let (na, nb) = (self.root(a), self.root(b));
        if na == nb {return false;}
        self.g[na] += self.g[nb];
        self.g[nb] = na as isize;
        true
    }
    fn size(&mut self, a:usize) -> usize {
        let na = self.root(a);
        (self.g[na] * -1) as usize
    }
}
// グラフ(深さ優先探索DFS/幅優先探索BFS)

// 検索(二分探索：右)
fn bsr(g:&[isize], v:isize, lo:usize, hi:usize) -> usize {
    if hi < lo {return lo;}
    let mi = (hi + lo) / 2;
    if g[mi] < v {
        return bsr(&g, v, mi + 1, hi);
    } else {
        return bsr(&g, v, lo, mi - 1);
    }
}

// エントリーポイント
fn main() {
    input! {
        A : usize,
        B : usize,
        Q : usize,
        S : [isize; A],
        T : [isize; B],
        X : [isize; Q],
    }
    let s = {
        let mut s = vec![-1_000_000_000_000];
        s.extend(S.iter().cloned());
        s.push(1_000_000_000_000);
        s
    };
    let t = {
        let mut t = vec![-1_000_000_000_000];
        t.extend(T.iter().cloned());
        t.push(1_000_000_000_000);
        t
    };
    for x in &X {
        let sr = bsr(&s, *x, 0, s.len() - 1);
        let tr = bsr(&t, *x, 0, t.len() - 1);
        let (sl, tl) = (sr - 1, tr - 1);
        let mut cost = vec![];
        for st in [s[sl], s[sr]].iter() {
            for tt in [t[tl], t[tr]].iter() {
                cost.push((tt - x).abs() + (tt - st).abs());
                cost.push((st - x).abs() + (tt - st).abs());
            }
        }
        p!(*cost.iter().min().unwrap());
    }
}


Measured memory_bytes: 11516