#!/usr/bin/env ruby

require 'set'

class Hash
  def push(key, value)
    self[key] = [] if self[key] == nil
    self[key].push(value)
  end
end

class Array
  def lower_bound(value)
    left = -1;
    right = self.length;
    while left + 1 < right
      mid = left + (right - left) / 2;
      if self[mid] >= value
        right = mid
      else
        left = mid
      end
    end
    right
  end

  def unique
    res = [self.first]
    each_cons(2) do |a, b|
      if a != b
        res.push(b)
      end
    end
    res
  end
end

def get_ints
  gets.chomp.split.map(&:to_i)
end

def get_ints_minus_one
  get_ints.map { |x| x - 1 }
end

def get_int
  gets.chomp.to_i
end

A, B, Q = get_ints
S = []
T = []
X = []

A.times do
  S << get_int
end

B.times do
  T << get_int
end

Q.times do
  X << get_int
end

S.sort!
T.sort!

X.each do |x|
  s_index = S.bsearch_index { |v| v > x }
  t_index = T.bsearch_index { |v| v > x }
  s_left = s_index.nil? ? S.last : s_index > 0 ? S[s_index - 1] : nil
  s_right = s_index.nil? ? nil : S[s_index]
  t_left = t_index.nil? ? T.last : t_index > 0 ? T[t_index - 1] : nil
  t_right = t_index.nil? ? nil : T[t_index]

  left_distance = if s_left.nil? && t_left.nil?
    2 * 10 ** 10
  elsif s_left.nil?
    (x - t_left).abs * 2 + (x - s_right).abs
  elsif t_left.nil?
    (x - s_left).abs * 2 + (x - t_right).abs
  else
    [(x - s_left).abs, (x - t_left).abs].max
  end

  right_distance = if s_right.nil? && t_right.nil?
    2 * 10 ** 10
  elsif s_right.nil?
    (x - t_right).abs * 2 + (x - s_left).abs
  elsif t_right.nil?
    (x - s_right).abs * 2 + (x - t_left).abs
  else
    [(x - s_right).abs, (x - t_right).abs].max
  end

  puts [left_distance, right_distance].min
end
