#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($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)*}
    };
}

#[allow(unused_macros)]
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)*}
    };

    ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

#[allow(unused_macros)]
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<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, bytes) => {
        read_value!($next, String).into_bytes()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

use std::cmp::Ordering;

pub trait BinarySearch<T> {
    fn lower_bound(&self, x: &T) -> usize;
    fn upper_bound(&self, x: &T) -> usize;
}

impl<T: Ord> BinarySearch<T> for [T] {
    fn lower_bound(&self, x: &T) -> usize {
        let mut low = 0;
        let mut high = self.len();

        while low != high {
            let mid = (low + high) / 2;
            match self[mid].cmp(x) {
                Ordering::Less => {
                    low = mid + 1;
                }
                Ordering::Equal | Ordering::Greater => {
                    high = mid;
                }
            }
        }
        low
    }

    fn upper_bound(&self, x: &T) -> usize {
        let mut low = 0;
        let mut high = self.len();

        while low != high {
            let mid = (low + high) / 2;
            match self[mid].cmp(x) {
                Ordering::Less | Ordering::Equal => {
                    low = mid + 1;
                }
                Ordering::Greater => {
                    high = mid;
                }
            }
        }
        low
    }
}

#[test]
fn test_binary_search() {
    let vec = vec![1, 2, 4, 6, 7, 12, 54, 60];

    assert_eq!(vec.lower_bound(&4), 2);
    assert_eq!(vec.upper_bound(&4), 3);
}

#[derive(Eq, Debug)]
struct Edge {
    is_tera: bool,
    distance: i64,
    idx_left_another: Option<usize>,
    idx_right_another: Option<usize>,
}
impl Ord for Edge {
    fn cmp(&self, right: &Self) -> Ordering {
        self.distance.cmp(&right.distance)
    }
}
impl PartialOrd for Edge {
    fn partial_cmp(&self, right: &Self) -> Option<Ordering> {
        Some(self.cmp(right))
    }
}
impl PartialEq for Edge {
    fn eq(&self, right: &Self) -> bool {
        self.distance == right.distance
    }
}

fn main() {
    input! {
        a: usize,
        b: usize,
        q: usize,
        ss: [i64; a],
        ts: [i64; b],
        xs: [i64; q],
    }
    const MAX_DISTANCE: i64 = (1 << 60);
    const MIN_DISTANCE: i64 = -MAX_DISTANCE;
    let v = {
        let mut v = vec![];
        for d in ss.into_iter() {
            v.push(Edge {
                is_tera: false,
                distance: d,
                idx_left_another: None,
                idx_right_another: None,
            });
        }
        for d in ts.into_iter() {
            v.push(Edge {
                is_tera: true,
                distance: d,
                idx_left_another: None,
                idx_right_another: None,
            });
        }
        for b in [false, true].into_iter() {
            for d in [MIN_DISTANCE, MAX_DISTANCE].into_iter() {
                v.push(Edge {
                    is_tera: *b,
                    distance: *d,
                    idx_left_another: None,
                    idx_right_another: None,
                });
            }
        }
        v.sort();
        let mut last_t = None;
        let mut last_s = None;
        for i in 0..v.len() {
            if v[i].is_tera {
                if last_s.is_some() {
                    v[i].idx_left_another = last_s;
                    if v[last_s.unwrap()].idx_right_another.is_none() {
                        v[last_s.unwrap()].idx_right_another = Some(i);
                    }
                }
                last_t = Some(i);
            } else {
                if last_t.is_some() {
                    v[i].idx_left_another = last_t;
                    if v[last_t.unwrap()].idx_right_another.is_none() {
                        v[last_t.unwrap()].idx_right_another = Some(i);
                    }
                }
                last_s = Some(i);
            }
        }
        let mut last_t = None;
        let mut last_s = None;
        for i in (0..v.len()).rev() {
            if v[i].is_tera {
                if last_s.is_some() {
                    v[i].idx_right_another = last_s;
                    if v[last_s.unwrap()].idx_left_another.is_none() {
                        v[last_s.unwrap()].idx_left_another = Some(i);
                    }
                }
                last_t = Some(i);
            } else {
                if last_t.is_some() {
                    v[i].idx_right_another = last_t;
                    if v[last_t.unwrap()].idx_left_another.is_none() {
                        v[last_t.unwrap()].idx_left_another = Some(i);
                    }
                }
                last_s = Some(i);
            }
        }
        v
    };
    for x in xs.into_iter() {
        let ub = v.upper_bound(&Edge {
            is_tera: false,
            distance: x,
            idx_left_another: None,
            idx_right_another: None,
        });
        let ans0 = (x - v[ub].distance).abs()
            + match (v[ub].idx_left_another, v[ub].idx_right_another) {
                (Some(l), Some(r)) => std::cmp::min(
                    (v[ub].distance - v[l].distance).abs(),
                    (v[ub].distance - v[r].distance).abs(),
                ),
                (Some(l), None) => (v[ub].distance - v[l].distance).abs(),
                (None, Some(r)) => (v[ub].distance - v[r].distance).abs(),
                (None, None) => unreachable!(),
            };
        let ans1 = (x - v[ub - 1].distance).abs()
            + match (v[ub - 1].idx_left_another, v[ub - 1].idx_right_another) {
                (Some(l), Some(r)) => std::cmp::min(
                    (v[ub - 1].distance - v[l].distance).abs(),
                    (v[ub - 1].distance - v[r].distance).abs(),
                ),
                (Some(l), None) => (v[ub - 1].distance - v[l].distance).abs(),
                (None, Some(r)) => (v[ub - 1].distance - v[r].distance).abs(),
                (None, None) => unreachable!(),
            };
        println!("{}", *[ans0, ans1].iter().min().unwrap());
    }
}

#[test]
fn test() {
    let mut v = vec![];
    let array = [4, 4, 4, 0, 10, 9];
    for &i in array.iter() {
        v.push(Edge {
            is_tera: false,
            distance: i,
            idx_left_another: None,
            idx_right_another: None,
        });
    }
    v.sort(); // 0, 4, 4, 4, 9, 10
    assert_eq!(
        4,
        v.upper_bound(&Edge {
            is_tera: false,
            distance: 4,
            idx_left_another: None,
            idx_right_another: None
        })
    );
    assert_eq!(
        4,
        v.upper_bound(&Edge {
            is_tera: false,
            distance: 6,
            idx_left_another: None,
            idx_right_another: None
        })
    );
    assert_eq!(
        1,
        v.lower_bound(&Edge {
            is_tera: false,
            distance: 4,
            idx_left_another: None,
            idx_right_another: None
        })
    );
    assert_eq!(
        4,
        v.lower_bound(&Edge {
            is_tera: false,
            distance: 6,
            idx_left_another: None,
            idx_right_another: None
        })
    );
}


Measured memory_bytes: 21612