import bisect
d = int(input())
N = int(input())
M = int(input())
shop = [0]
home = []
for n in range(N-1):
    shop.append(int(input()))
for m in range(M):
    home.append(int(input()))
shop.sort()
shop.append(d)
ans = 0
for h in home:
    i = bisect.bisect(shop, h)
    ans += min(abs(shop[i-1]-h), abs(shop[i]-h))
print (ans)

import bisect
N = input()
INF = 10**10
S = list(map(int,input().split())) + [INF]
A = input()
T = list(map(int,input().split()))
ans = 0
for t in T:
    i = bisect.bisect_left(S, t)
    if (S[i] == t): # Sにtが含まれれば挿入点の値と等しい
        ans += 1
print(ans)

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

import numpy as np

N = int(readline())
A = np.array(read().split(),np.int64)

# 順に二回並べることで円環を区間につぶしたまま作業できる
A = np.concatenate([A,A])

# dp: 残りのピースがn個（A[i:i+n]）だったとして、最終的にJOI君が得るスコア
# 小さいnから逐次的に更新していく（一次元配列を使い回す）
dp = np.zeros(N,np.int64)
for n in range(1,N+1):
    dp = np.append(dp,dp[0]) # dpも円環
    player = (N - n) & 1 # 最後のターンから考えるので、Nが偶数なら最後はIOI、奇数なら最後はJOI
    if player == 0:
        # JOI君
        left = dp[1:N+1] + A[:N]
        right = dp[:N] + A[n-1:N+n-1]
        dp = np.maximum(left,right)
    else:
        # IOIちゃん
        dp = np.where(A[:N] > A[n-1:N+n-1], dp[1:N+1], dp[:N])

answer = dp.max()
print(answer)

def move(board): # 空きを埋める関数
    board = [list(x) for x in zip(*board)]
    for i in range(len(board)):
        row = board[i]
        row = [i for i in row if i!=0]
        n = len(board[i]) - len(row)
        row.extend([0]*n)
        board[i] = row
    board = [list(x) for x in zip(*board)]
    return board

ls_ans = []
while(1):
    ans = 0
    H = int(input())
    if H==0:
        break
    board = []
    for h in range(H):
        C = list(map(int,input().split()))
        board.append(C)
    board = board[::-1]
    for t in range(H):
        for h in range(H):
            C = board[h]
            changed = set()
            old_c = ''
            oldold_c = ''
            streak = 0
            for i,c in enumerate(C):
                if c == old_c and c == oldold_c:
                    if streak == 0:
                        streak += 3*c
                        C[i] = C[i-1] = C[i-2] = 0
                    else:
                        streak += c
                        C[i] = 0
                else:
                    ans += streak
                    streak = 0
                oldold_c = old_c
                old_c = c
            ans += streak
            board[h] = C
        board = move(board)
    ls_ans.append(ans)

for ans in ls_ans:
    print (ans)

import math
a,b,x = map(int,input().split())
if x < a**2*b/2:
    y = 2*x/(a*b)
    print (math.degrees(math.atan(b/y)))
else:
    y = 2*(b-x/(a**2))
    print (math.degrees(math.atan(y/a)))

from itertools import accumulate
N = int(input())
A = [0] + list(map(int, input().split()))
csum = list(accumulate(A))

for i in range(1,N+1):
    ans = 0
    for j in range(N-i+1):
        diff = csum[j+i] - csum[j]        
        ans = max(diff,ans)
    print (ans)

from itertools import product
N = int(input())
S = input()
S = [int(s) for s in S]
ans = 0
for q in product(range(10),repeat=3):
    i = 0
    for s in S:
        if s==q[i]:
            if i==2:
                ans += 1
                break
            else:
                i+=1
print (ans)

N = int(input())
S = input()

st = [set() for _ in range(3)]

for s in S:
    for pre in st[1]:
        st[2].add(pre+s) # 3桁目
    for pre in st[0]:
        st[1].add(pre+s) # 2桁目
    st[0].add(s) # 1桁目
        
print (len(st[2]))

from itertools import combinations
N, M = map(int, input().split())
A = []
for n in range(N):
    a = list(map(int, input().split()))
    A.append(a)

ans = 0
for m1, m2 in combinations(range(M),2):
    score = 0
    for a in A:
        score += max(a[m1],a[m2])
    ans = max(ans, score)
print (ans)

INF = 10**10
N = int(input())
dp = [[INF]*N for _ in range(N)]
R = []
for n in range(N):
    r, c = map(int,input().split())
    R.append(r)
R.append(c)

for i in range(N):
    dp[i][i] = 0 # 対角成分すなわち、行列積Miを計算するコストは0である

for l in range(1,N): # iとjの差分
    for i in range(N-l):
        j = i+l    
        for k in range(i,j):
            # cost(左側行列積) + cost(右側行列積) + 行列計算のコスト
            dp[i][j] = min(dp[i][j], dp[i][k]+dp[k+1][j]+R[i]*R[k+1]*R[j+1]) # 初回はR[0]*R[1]*R[2]
print (dp[0][-1])

from itertools import combinations
INF = 10**10
ans = INF # 最小値を更新するのでINFで初期化
N, M = map(int,input().split())
c_n = []
c_m = []
for n in range(N):
    c_n.append(list(map(int,input().split())))
for m in range(M):
    c_m.append(list(map(int,input().split())))

def dist(c1,c2): # ユークリッド距離を返却する
    return pow(((c1[0]-c2[0])**2 + (c1[1]-c2[1])**2),0.5)

for c1,c2 in combinations(c_m,2): # M個の円同士
    ans = min(ans,dist(c1,c2)/2) # 二点間の距離の半分

for c1 in c_n: # N個の円とM個の円
    ans = min(ans,c1[2]) # 半径が決まっている円もチェック対象
    for c2 in c_m:
        ans = min(dist(c1[:2],c2) - c1[2], ans) # 二点間の距離から半径が決まっている円の半径を引く
print (ans)