We have a deck consisting of N cards. Each card has an integer written on it. The integer on the i-th card from the top is a_i.
Two people X and Y will play a game using this deck. Initially, X has a card with Z written on it in his hand, and Y has a card with W written on it in his hand. Then, starting from X, they will alternately perform the following action:
 - Draw some number of cards from the top of the deck. Then, discard the card in his hand and keep the last drawn card instead. Here, at least one card must be drawn.
The game ends when there is no more card in the deck. The score of the game is the absolute difference of the integers written on the cards in the two players' hand.
X will play the game so that the score will be maximized, and Y will play the game so that the score will be minimized. What will be the score of the game?

-----Constraints-----
 - All input values are integers.
 - 1 \leq N \leq 2000
 - 1 \leq Z, W, a_i \leq 10^9

-----Input-----
Input is given from Standard Input in the following format:
N Z W
a_1 a_2 ... a_N

-----Output-----
Print the score.

-----Sample Input-----
3 100 100
10 1000 100

-----Sample Output-----
900

If X draws two cards first, Y will draw the last card, and the score will be |1000 - 100| = 900.

Difficulty: interview

Starter code:

Solutions:
#難しく考えすぎていた
#こういう問題は最後どうなるかを考える
#最後は結局一番最後のカードを必ず引くことになる
#そのカードをどちらが引くのか
#先攻が圧倒的有利

n,z,w=map(int,input().split())
a=list(map(int,input().split()))
if len(a)==1:
    print(abs(a[-1]-w))
else:
    print(max(abs(a[-1]-w),abs(a[-1]-a[-2])))

N, Z, W = list(map(int,input().split()))
A = list(map(int,input().split()))
idea = abs(A[-1] - W)
try: idea2 = abs(A[-2] - A[-1])
except:
    print(idea)
    return
print((max(idea,idea2)))


import sys

def solve():
    input = sys.stdin.readline
    N, Z, W = map(int, input().split())
    A = [int(a) for a in input().split()]
    if N == 1: print(abs(W - A[0]))
    else: print(max(abs(W - A[N-1]), abs(A[N-2] - A[N-1])))

    return 0

def __starting_point():
    solve()
__starting_point()

N,Z,W = map(int,input().split())
a = list(map(int,input().split()))
print(max(abs(W-a[-1]),abs(a[N-1]-a[N-2])))

import sys
from itertools import product
input = sys.stdin.readline

def main():
    n, z, w = list(map(int, input().split()))
    
    a = list(map(int, input().split()))
    
    ans = abs(w-a[-1])
    if n != 1:
        ans = max(ans, abs(a[-2]-a[-1]))
    
    print(ans)
        

    
def __starting_point():
    main()

__starting_point()

n, z, w = list(map(int, input().split()))
a = list(map(int, input().split()))
INF = 10 ** 10

dp = [[None] * 2 for _ in range(n)]
for i in range(n - 1, -1, -1):
    dp[i][0] = -INF
    y = a[i-1] if i else w
    dp[i][0] = max(dp[i][0], abs(y - a[-1]))
    for j in range(i + 1, n):
        dp[i][0] = max(dp[i][0], dp[j][1])

    dp[i][1] = INF
    x = a[i-1] if i else z
    dp[i][1] = min(dp[i][1], abs(x - a[-1]))
    for j in range(i + 1, n):
        dp[i][1] = min(dp[i][1], dp[j][0])

ans = dp[0][0]
print(ans)


N, Z, W = map(int, input().split())
A = list(map(int, input().split()))
if N == 1:
    print(abs(W - A[0]))
else:
    ans = max(abs(A[-1] - W), abs(A[-1] - A[-2]))
    print(ans)

n, z, w = list(map(int, input().split()))
a = list(map(int, input().split()))
if n == 1:
    print((abs(a[0]-w)))
    return
print((max(abs(a[-1]-w), abs(a[-1]-a[-2]))))


import sys
readline = sys.stdin.readline

# 最後の一枚を取るか、その直前を取るかしかない
# なぜなら、最後から数えて3枚目を取る場合は相手に最後から2枚目を取ることを期待するが、
# それなら自分が最後から2枚目を取ったほうが有利なため。

N,Z,W = map(int,readline().split())
A = list(map(int,readline().split()))

if N == 1:
  # 1枚の場合は取るしかない
  print(abs(A[0] - W))
  return
  
# 最後の一枚を取る場合
last_one = abs(A[-1] - W)

# 最後から二枚目を取る場合
last_two = abs(A[-1] - A[-2])

if last_one > last_two:
  print(last_one)
else:
  print(last_two)

def main():
    N, Z, W = list(map(int, input().split()))
    A = list(map(int, input().split()))
    if N == 1:
        return abs(A[-1] - W)
    return max(abs(A[-1] - W), abs(A[-1] - A[-2]))


print((main()))


n,z,w = list(map(int,input().split()))
A = list(map(int,input().split()))

if n == 1:
    print((abs(A[0] - w)))
else:
    print((max(abs(A[-1] - w), abs(A[-2] - A[-1]))))


import sys
INF = 10 ** 9
MOD = 10 ** 9 + 7
from collections import deque
sys.setrecursionlimit(100000000)
input = sys.stdin.readline
MAXN = 2005

dp0 = [[-1] * MAXN for _ in range(MAXN)]
dp1 = [[-1] * MAXN for _ in range(MAXN)]

def dfs(i,j,p,z,w,a,n):
    if p == 0:
        if dp0[i][j] != -1:
            return dp0[i][j]
        if i == n:
            if j == 0:
                return abs(w - a[-1])
            return abs(a[j -1] - a[-1])
        ans = 0
        for k in range(i,n):
            ans = max(ans,dfs(k + 1,k,1,z,w,a,n))
        if i == 1:
            ans = max(ans,abs(a[-1] - w))
        else:
            ans = max(ans,abs(a[-1]- a[i - 1]))
        dp0[i][j] = ans
        return ans
    elif p == 1:
        if dp1[i][j] != -1:
            return dp1[i][j]
        if i == n:
            if j == 0:
                return abs(z - a[-1])
            return abs(a[j - 1] - a[-1])
        ans = INF
        for k in range(i,n):
            ans = min(ans,dfs(k + 1,k,0,z,w,a,n))
        if i == 1:
            ans = min(ans,abs(a[-1] - z))
        else:
            ans = min(ans,abs(a[-1] - a[i - 1]))
        dp1[i][j] = ans
        return ans

def main():
    n,z,w = map(int,input().split())
    a = list(map(int,input().split()))

    ans = dfs(1,0,0,z,w,a,n)
    print(ans)

def __starting_point():
    main()
__starting_point()

import collections
def main():
    n,z,w=list(map(int, input().split()))
    a=[int(i) for i in input().split()]
    #途中選り好みしても結局a_n - a_n-1になる
    if(n==1):
        print((abs(w-a[0])))
    else:
        print((max(abs(a[n-1]-a[n-2]), abs(a[n-1]-w))))

def __starting_point():
    main()

__starting_point()

n, z, w = map(int, input().split())
a = list(map(int, input().split()))
print(abs(a[0] - w) if n == 1 else max(abs(a[n - 1] - w), abs(a[n - 2] - a[n - 1])))

n, z, w = list(map(int, input().split()))
a = list(map(int, input().split()))
if n == 1:
  print((abs(a[0] - w)))
else:
  print((max(abs(a[-1] - a[-2]), abs(a[-1] - w))))


n, z, w = map(int, input().split())
arr = list(map(int, input().split()))

if n == 1:
    print(abs(arr[0] - w))
else:
    print(max(abs(arr[-1] - w), abs(arr[-2] - arr[-1])))

N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))

if N == 1:
    print((abs(a[0] - W)))

else:
    print((max(abs(a[-1]-W), abs(a[-1] - a[-2]))))


n, z, w, *a = list(map(int, open(0).read().split()))
if n>1: print((max(abs(a[-2]-a[-1]), abs(a[-1]-w))))
else: print((abs(a[0]-w)))


import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

N, Z, W = list(map(int, input().split()))

A = list(map(int, input().split()))

if N == 1:
    print((abs(A[-1] - W)))
else:
    print((max(abs(A[-1] - W), abs(A[-1] - A[-2]))))


n,z,w = map(int,input().split())
a = [int(i) for i in input().split()]

if n == 1:
    print(abs(w-a[0]))
    return

print(max(abs(w-a[n-1]),abs(a[n-1]-a[n-2])))

n,z,w = map(int,input().split())
l = list(map(int,input().split()))
if n==1:
    print(abs(l[-1]-w))
else:
    print(max(abs(l[-1]-w),abs(l[-1]-l[-2])))

n,z,w = map(int,input().split())
a = list(map(int,input().split()))

ma = max( abs(a[n-2]-a[n-1]) , abs(a[n-1]-w) )
print(ma)

#どっちで出すか注意, rstrip注意
#提出前に見返すこと！
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    #from collections import defaultdict
    from itertools import combinations, permutations, accumulate
    #from itertools import product
    from bisect import bisect_left,bisect_right
    import heapq
    from math import floor, ceil
    #from operator import itemgetter

    #inf = 10**17
    #mod = 10**9 + 7

    N,Z,W = map(int, input().split())
    a = list(map(int, input().split()))
    if N>=2:
        print(max(abs(a[-1]-W), abs(a[-1]-a[-2])))
    else:
        print(abs(a[0]-W))


def __starting_point():
    main()
__starting_point()

N, Z, W = map(int, input().split())
a = list(map(int, input().split()))

ans = abs(W - a[-1])
if N > 1:
    ans = max(ans, abs(a[-2] - a[-1]))
print(ans)

n,z,w= map(int, input().split())
a = list(map(int, input().split()))
if n == 1:
  print(abs(a[0] - w))
else:
  print(max(abs(a[-1]-w), abs(a[-2]-a[-1])))

#078_D
n, z, w = map(int, input().split())
a = list(map(int, input().split()))
if n == 1:
    print(abs(a[0] - w))
else:
    print(max(abs(a[-1] - a[-2]), abs(a[-1] - w)))

n, z, w = map(int, input().split())
A = list(map(int, input().split()))

ans = max(
  abs(A[-2] - A[-1]) if len(A) > 1 else 0,
  abs(A[-1] - w)
)

print(ans)

N, Z, W = list(map(int, input().split()))
A = tuple(map(int, input().split()))

if N == 1:
    print((abs(A[0] - W)))
else:
    print((max(abs(A[-1] - W), abs(A[-1] - A[-2]))))


n,z,w=map(int,input().split())
a=list(map(int,input().split()))
if len(a)==1:
    print(abs(a[-1]-w))
else:
    print(max(abs(a[-1]-w),abs(a[-1]-a[-2])))

n, z, w = map(int,input().split())
a = list(map(int,input().split()))
if n == 1:
    print(abs(a[0]-w))
else:
    p = abs(a[-2] - a[-1])
    q = abs(a[-1] - w)
    print(max(p,q))

N,Z,W=map(int,input().split())
a=list(map(int,input().split()))
if N==1:
    print(abs(W-a[0]))
else:
    print(max(abs(a[-1]-a[-2]),abs(W-a[-1])))

N,Z,W = map(int,input().split())
A = list(map(int,input().split()))

if N==1:
    print(abs(A[0] - W))
else:
    print(max(abs(A[-1] - W), abs(A[-2] - A[-1])))

import sys
INF = 10 ** 9
MOD = 10 ** 9 + 7
from collections import deque
sys.setrecursionlimit(100000000)
input = sys.stdin.readline

def main():
    n,z,w = map(int,input().split())
    a = list(map(int,input().split()))
    if n == 1:
        ans = abs(w - a[0])
    else:
        ans = max(abs(w - a[-1]),abs(a[-1] - a[-2]))
    print(ans)

def __starting_point():
    main()
__starting_point()

n, z, w = map(int, input().split())
a = list(map(int, input().split()))

if n == 1:
	print(abs(a[0]-w))
else:
	print(max(abs(a[n-2]-a[n-1]), abs(w-a[n-1])))

n,z,w = map(int,input().split())
a = [w] + list(map(int,input().split()))
print(max(abs(a[-1]-w), abs(a[-2]-a[-1])))

N,Z,W = map(int,input().split())
a = list(map(int,input().split()))

if N == 1:
    print(abs(W-a[N-1]))
else:
    print(max(abs(W-a[N-1]),abs(a[N-1]-a[N-2])))

N,Z,W=map(int,input().split())
a=list(map(int,input().split()))
print(abs(W-a[0])if N==1 else max(abs(W-a[-1]),abs(a[-1]-a[-2])))

n, _, w = map(int, input().split())
a = list(map(int, input().split()))
if n == 1:
    print(abs(a[-1] - w))
else:
    print(max(abs(a[-1] - w), abs(a[-2] - a[-1])))

import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline

n, z, w= list(map(int, input().split()))
a = list( map(int, input().split()))

last = a[-1]

if n == 1:
    print((abs(w-last)))
    return

last2 = a[-2]

print((max(abs(last2-last), abs(last-w))))


N, Z, W = map(int, input().split())
As = list(map(int, input().split()))

max_score = abs(As[-1] - W)
if N >= 2 and max_score < abs(As[-2] - As[-1]):
    max_score = abs(As[-2] - As[-1])

print(max_score)

def solve():
    N, Z, W = list(map(int, input().split()))
    a = list(map(int, input().split()))
    
    if N == 1:
        print((abs(a[0] - W)))
        return
    
    print((max(abs(a[-1] - W), abs(a[-2] - a[-1]))))


def __starting_point():
    solve()

__starting_point()

N,Z,W = map(int,input().split())
A = list(map(int,input().split()))
print(max(abs(A[N-1]-A[N-2]),abs(A[N-1]-W)))

n, z, w = list(map(int, input().split()))
a = list(map(int, input().split()))
INF = 10 ** 10

coef = [-1, 1]
initial = [w, z]
func = [max, min]
turn = [0, 1]

dp = [[None] * 2 for _ in range(n)]
for i in range(n - 1, -1, -1):
    for c, ini, f, t in zip(coef, initial, func, turn):
        dp[i][t] = c * INF
        opo_card = a[i-1] if i else ini
        dp[i][t] = f(dp[i][t], abs(a[-1] - opo_card))
        opo_t = (t + 1) % 2
        for j in range(i + 1, n):
            dp[i][t] = f(dp[i][t], dp[j][opo_t])

ans = dp[0][0]
print(ans)


def main():
    N, Z, W = list(map(int, input().split(' ')))
    A = list(map(int, input().split(' ')))
    if N == 1:
        print(abs(A[0] - W))
    else:
        print(max([abs(A[-1] - W), abs(A[-2] - A[-1])]))


def __starting_point():
    main()
__starting_point()

n, z, w = map(int, input().split())
a = list(map(int, input().split()))

"""
xの選択肢は2つ。最後を取ってwと比較するか、最後から2番目を取って最後と比較する
"""

if n<2:
    ans = abs(a[-1]-w)
else:
    ans = max(abs(a[-2]-a[-1]), abs(a[-1]-w))
print(ans)

n,z,w=map(int,input().split())
a=list(map(int,input().split()))
print(abs(w-a[0])if n==1else max(abs(w-a[-1]),abs(a[-1]-a[-2])))

N, Z, W = map(int,input().split())
A = list(map(int,input().split()))

ans = abs(A[-1] - W)

if N >= 2:
    ans = max(ans, abs(A[-2] - A[-1]))

print(ans)

n, z, w = map(int, input().split())
a = list(map(int, input().split()))
if n == 1:
    print(abs(a[-1] - w))
    return
ans = abs(a[-1] - a[-2])
tmp = abs(a[-1] - w)
print(max(ans, tmp))

n, z, w = map(int, input().split())
a = list(map(int, input().split()))
if n == 1:
  print(abs(w-a[-1]))
else:
  print(max(abs(w-a[-1]), abs(a[-1]-a[-2])))

n,z,w = map(int, input().split())

al = list(map(int, input().split())) 

if n ==1:
    print(abs(al[0]-w))
    return

al1 = al[-2]
al2 = al[-1]

d1 = abs(al1-al2)
d2 = abs(al2-w)

print(max(d1,d2))

N, Z, W = map(int, input().split())
A = list(map(int, input().split()))
if N == 1:
  print(abs(A[0]-W))
  return

dp = [[0, 0] for i in range(N)]
dp[-1][0] = abs(A[-1]- W)
dp[-1][1] = - 1
dp[-2][0] = dp[-2][1] = dp1min = abs(A[-2] - A[-1])
dp0max = max(dp1min, dp[-1][0])

for i in range(N-3, -1, -1):
  ai = A[i]
  diff = abs(ai - A[-1])
  dp[i][0] = min(diff, dp1min)
  dp[i][1] = max(diff, dp0max)
  dp0max = max(dp0max, dp[i][0])
  dp1min = min(dp1min, dp[i][1])

print(dp0max)

#!/usr/bin/env python3
import sys
try:
    from typing import List
except ImportError:
    pass


def solve(N: int, Z: int, W: int, a: "List[int]"):
    dp = [(0, 0)] * N
    if N == 1:
        dp[N - 1] = (abs(a[N - 1] - W), abs(Z - a[N - 1]))
    else:
        dp[N - 1] = (abs(a[N - 1] - a[N - 2]), abs(a[N - 2] - a[N - 1]))
    for i in reversed(list(range(N - 1))):
        v1 = max(dp[j][1] for j in range(i + 1, N))
        if i == 0:
            v1 = max(v1, abs(a[N - 1] - W))
        else:
            v1 = max(v1, abs(a[N - 1] - a[i - 1]))
        v2 = min(dp[j][0] for j in range(i + 1, N))
        if i == 0:
            v2 = min(v2, abs(Z - a[N - 1]))
        else:
            v2 = min(v2, abs(a[i - 1] - a[N - 1]))
        dp[i] = (v1, v2)
    print((dp[0][0]))


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    Z = int(next(tokens))  # type: int
    W = int(next(tokens))  # type: int
    a = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(N, Z, W, a)


def __starting_point():
    main()

__starting_point()

n, z, w = map(int, input().split())
cards = list(map(int, input().split()))
#print(getX(z, w, cards, 0))
if(abs(cards[len(cards)-1]-w)>abs(cards[len(cards)-1]-cards[len(cards)-2])):
    print(abs(cards[len(cards)-1]-w))
else:
    print(abs(cards[len(cards)-1]-cards[len(cards)-2]))

N, Z, W = (int(x) for x in input().split())
A = [int(x) for x in input().split()]

ans = max(abs(A[N-2]-A[N-1]), abs(A[N-1]-W))
print(ans)

n,z,w=map(int,input().split())
a=list(map(int,input().split()))
if n==1:
    print(abs(a[0]-w))
else:
    print(max(abs(a[-1]-a[-2]),abs(a[-1]-w)))

N,X,Y=map(int,input().split())
L=list(map(int,input().split()))
if N>2:
  print(max(abs(L[-2]-L[-1]),abs(Y-L[-1])))
else:
  print(abs(L[-1]-Y))

N, Z, W = list(map(int, input().split()))
A = list(map(int, input().split()))

if N == 1:
    print((abs(A[0] - W)))
else:
    print((max(abs(A[-1] - W), abs(A[-1] - A[-2]))))


n,z,w=list(map(int,input().split()))
card=list(map(int,input().split()))

if n==1:
  print((abs(card[0]-w)))
else:
  print((max(abs(card[-2]-card[-1]),abs(card[-1]-w))))


N, Z, W = list(map(int, input().split()))
A = list(map(int, input().split()))

if N == 1:
    print((abs(A[0] - W)))
    return

print((max(abs(A[-1] - W), abs(A[-2] - A[-1]))))


n,z,w=list(map(int,input().split()))
a=list(map(int,input().split()))
a.insert(0,a[0])

print((max(abs(w-a[-1]),abs(a[-1]-a[-2]))))


N, Z, W = map(int, input().split())
A = list(map(int, input().split()))

print(max(abs(A[N-1] - W), abs(A[N-2] - A[N-1])))

N,Z,W = map(int,input().split())
A = list(map(int,input().split()))

ans = abs(W - A[-1])
if N > 1:
    a = abs(A[-2] - A[-1])
    ans = max(ans, a)
print(ans)

N,_,W = map(int, input().split())
A = [int(i) for i in input().split()]

if N == 1:
    ans = abs(A[0] - W)
else:
    # 1枚残す場合
    ans = abs(A[-1] - A[-2])
    # 0枚残す場合
    ans = max(ans, abs(A[-1] - W))

print(ans)

n,z,w=map(int,input().split())
A=list(map(int,input().split()))
if n==1:
    print(abs(A[0]-w))
else:
    print(max(abs(A[-1]-w),abs(A[-2]-A[-1])))

import sys

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


def resolve():
    n, z, w = list(map(int, input().split()))
    A = list(map(int, input().split()))

    res = abs(w - A[-1])
    if n > 1:
        res = max(res, abs(A[-2] - A[-1]))
    print(res)


def __starting_point():
    resolve()

__starting_point()

N, Z, W = map(int, input().split())
A = list(map(int, input().split()))
if N == 1:
    print(abs(A[0]-W))
else:
    print(max(abs(A[-1]-W), abs(A[-2]-A[-1])))

n,z,w=map(int,input().split())
a=list(map(int,input().split()))
print(max(abs(a[n-1]-a[n-2]),abs(a[n-1]-w)))

#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**6)

n, z, w = list(map(int, input().split()))
a = list(map(int, input().split()))

if n == 1:
    ans = abs(a[0]-w)
    print(ans)
    return

ans1 = abs(a[-2]-a[-1])
ans2 = abs(a[-1]-w)
# print(ans1, ans2)
print((max(ans1, ans2)))


N,Z,W=map(int,input().split())
alist=list(map(int,input().split()))

if N==1:
  print(abs(alist[-1]-W))
else:
  ans1=abs(alist[-2]-alist[-1])
  ans2=abs(alist[-1]-W)
  print(max(ans1,ans2))

n,z,w=map(int,input().split())
a=list(map(int,input().split()))
if n==1:
  print(abs(w-a[0]))
else:
  ans=0
  ans=max(ans,abs(a[-1]-w))
  ans=max(ans,abs(a[-1]-a[-2]))
  print(ans)

n, z, w = map(int, input().split())
A = list(map(int, input().split()))

if n == 1:
    print(abs(A[0]-w))
else:
    z1 = A[-1]
    w1 = A[-2]
    print(max(abs(z1-w), abs(z1-w1)))

n,z,w=map(int,input().split())
a=list(map(int,input().split()))
if n==1:
  print(abs(a[-1]-w))
else:
  print(max(abs(a[-1]-w),abs(a[-1]-a[-2])))

n, z, w = map(int, input().split())
a = list(map(int, input().split()))
if n == 1:
    print(abs(a[0]-w))
else:
    print(max([abs(a[n-1]-w), abs(a[n-2]-a[n-1])]))

N, Z, W = map(int, input().split())
A = list(map(int, input().split()))

if N == 1:
  print(abs(A[-1] - W))
else:
  print(max(abs(A[-1] - W), abs(A[-2] - A[-1])))

n,z,w=map(int,input().split())
A=list(map(int,input().split()))
if n==1:
    print(abs(A[0]-w));return
print(max( abs(A[-1]-w),abs(A[-2]-A[-1]) ))

def main():
    n,z,w = map(int,input().split())
    a = list(map(int,input().split()))
    ans = 0
    if n == 1:
        ans = abs(w-a[0])
    else:
        ans = max(abs(a[-1] - w),abs(a[-2] - a[-1]))
    
    print(ans)

def __starting_point():
    main()
__starting_point()

N,Z,W =  map(int,input().split(" "))        # Z は要らん子
 
a = list(map(int,input().split(" ")))
 
if N == 1:
	ans = abs(a[-1]-W)
else:
	ans = max(abs(a[-1]-a[-2]),abs(a[-1]-W))
 
 
print(ans)

n,z,w=map(int,input().split())
a=list(map(int,input().split()))
if n==1:
  ans=abs(a[0]-w)
else:
  ans=max(abs(a[-1]-a[-2]),abs(a[-1]-w))
print(ans)

n,z,w=map(int,input().split())
a=list(map(int,input().split()))
if n==1:print(abs(a[0]-w))
else:print(max(abs(a[n-2]-a[n-1]),abs(a[n-1]-w)))

import sys
sys.setrecursionlimit(10**8)

def sort(a):
	a.sort()

def rev(a):
	a.reverse()

def sd():
	return int(input())

def _sd():
	return list(map(int,input().split()))

def sa():
	return list(map(int,input().split()))

def ss():
	return input()

def sf():
	return float(input())
 
def main():
	N,Z,W=_sd()
	a=sa()
	if(N>1):
		print((max(abs(a[N-1]-W),abs(a[N-2]-a[N-1]))))
	else:
		print((abs(a[0]-W)))
main()


import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

n,z,w = na()
a = na()

if n == 1:
    print(abs(a[-1]-w))
    return

print(max(abs(a[-1]-w),abs(a[-2]-a[-1])))

n,z,w=map(int,input().split())
a=list(map(int,input().split()))
if n==1:
    print(abs(a[0]-w))
else:
    print(max(abs(a[-1]-w),abs(a[-2]-a[-1])))

n, z, w = list(map(int, input().split()))
a = list(map(int, input().split()))
if n == 1:
    print((abs(a[0]-w)))
    return
print((max(abs(a[-1]-w), abs(a[-1]-a[-2]))))


n,z,w=map(int,input().split())
a=list(map(int,input().split()))
b=[abs(a[i]-a[-1]) for i in range(n-1)]
b=[abs(w-a[-1])]+b
if n==1:print(abs(w-a[0]));return
print(max(abs(w-a[-1]),abs(a[-2]-a[-1])))

n,z,w = list(map(int,input().split()))
a = list(map(int,input().split()))

if n == 1:
    print((abs(a[-1] - w)))
else:
    print((max(abs(a[-1] - w), abs(a[-1] - a[-2]))))


#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**6)

n, z, w = list(map(int, input().split()))
a = list(map(int, input().split()))

if n == 1:
    ans = abs(a[0]-w)
    print(ans)
    return

ans1 = abs(a[-2]-a[-1])
ans2 = abs(a[-1]-w)
# print(ans1, ans2)
print((max(ans1, ans2)))


# solution

import io
import math
import scipy.sparse

nim,mike,kite = map(int, input().split())

array = list(map(int, input().split()))

print(max(abs(kite-array[nim-1]), abs(array[nim-1]-array[nim-2])))

n, z, w = list(map(int, input().split()))
a = list(map(int, input().split()))

ans = abs(a[-1] - w)
if n > 1:
    ans = max(ans, abs(a[-2] - a[-1]))

print(ans)


N,Z,W = map(int,input().split(' '))
a=list(map(int,input().split(' ')))

# Xが全部とる
t1=abs(a[N-1]-W)
# Xが1個残しでとる
if N>1:
    t2=abs(a[N-1-1]-a[N-1])
else:
    t2=0
# Xが2個残しで取る場合、Yの都合に従う
if N>2:
    t3=min( abs(a[N-2-1]-a[N-1]),abs(a[N-1]-a[N-1-1]) )
else:
    t3=0

print(max(t1,t2,t3))

N,Z,W=map(int,input().split())
a=list(map(int,input().split()))

if N==1:
    print(abs(a[0]-W))
else:
    print(max(abs(a[-1]-W),abs(a[N-2]-a[N-1])))

n, z, w = map(int, input().split())
a = list(map(int, input().split()))
if n == 1:
    print(abs(a[0]-w))
    return
print(max(abs(a[-1]-w),abs(a[-2]-a[-1])))

N,Z,W = (int(x) for x in input().split())
a = list(map(int, input().split()))
if N == 1:
    print(abs(W-a[0]))
else:
    print(max(abs(a[-1]-W),abs(a[-1]-a[-2])))

n, z, w = list(map(int, input().split()))
a = list(map(int, input().split()))

if n >= 2:

    # xがaiをとったときにyが最適に行動した時のスコア
    dp_x = [abs(a[-1] - a[i]) for i in range(n)]
    # yがaiをとったときにxが最適に行動した時のスコア
    dp_y = [abs(a[-1] - a[i]) for i in range(n)]

    for i in reversed(list(range(n-1))):
        for j in range(i):
            dp_x[j] = min(dp_x[j], dp_y[i])
            dp_y[j] = max(dp_y[j], dp_x[i])

    print((max(abs(a[-1]-w), max(dp_x))))
else:
    print((abs(a[-1]-w)))



n, z, w = list(map(int, input().split()))
a = list(map(int, input().split()))
if n == 1:
    print((abs(a[0]-w)))
    return
print((max(abs(a[-1]-w), abs(a[-1]-a[-2]))))


n, z, w = map(int, input().split())
a = list(map(int, input().split()))
if n==1:
    print(abs(a[0]-w))
else:
    print(max(abs(a[-1]-w), abs(a[-2]-a[-1])))

import numpy as np

def solve(N, Z, W, A):
    # dp_x[n] := y さんが n 枚目を引いて x さんに手番が回ったときの最大値
    dp_x = np.full(N+1, 1<<61, dtype=np.int64)
    dp_y = np.zeros(N+1, dtype=np.int64)
    for i in range(N-1, 0, -1):
        dp_x[i] = max(dp_y[i+1:].max(), abs(A[-1]-A[i-1]))
        dp_y[i] = min(dp_x[i+1:].min(), abs(A[-1]-A[i-1]))
    ans = max(abs(A[-1]-W), dp_y[1:].max())
    return ans

N, Z, W = map(int, input().split())
A = np.array(input().split(), dtype=np.int64)
ans = solve(N, Z, W, A)
print(ans)

import bisect
import copy
import heapq
import sys
import itertools
import math
import queue
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7

def read_values(): return list(map(int, input().split()))
def read_index(): return [int(x) - 1 for x in input().split()]
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]
def init_dp1(init, N): return [init for _ in range(N)]
def init_dp2(init, N, M): return [[init for _ in range(M)] for _ in range(N)]


class V:
    def __init__(self, f, v=None):
        self.f = f
        self.v = v
 
    def __str__(self):
        return str(self.v)
 
    def ud(self, n):
        if n is None:
            return

        if self.v is None:
            self.v = n
            return
        self.v = self.f(self.v, n) 


def main():
    N, Z, W = read_values()
    A = read_list()
    res = V(max, abs(W - A[-1]))
    if N >= 2:
        res.ud(abs(A[-1] - A[-2]))

    print(res)


def __starting_point():
    main()


__starting_point()

N,Z,W = map(int,input().split())
a_ls = list(map(int, input().split()))

iA = [0] * N
iB = [0] * N

iA[N-1] = abs(a_ls[N-2]-a_ls[N-1])
iB[N-1] = abs(a_ls[N-2]-a_ls[N-1])

# 「次がi番目のカード」という状況でAorBに回ってくる
for i in range(N-2,-1,-1):
    # i番目がAの場合
    if i != 0:
        prev = a_ls[i-1]
    else:
        prev = W
    
    ans = -float('inf')
    # j := 次がj番目、という状態で相手に渡す
    for j in range(i+1,N):
        #print("渡す",j)
        ans = max(ans,iB[j])
    # Aがゲームを終了させる場合
    ans = max(ans,abs(prev-a_ls[-1]))
    iA[i] = ans
    
    # i番目がBの場合
    if i != 0:
        prev = a_ls[i-1]
    else:
        prev = Z

    ans = float('inf')
    # j := 次がj番目、という状態で相手に渡す
    for j in range(i+1,N):
        ans = min(ans,iA[j])
    # Bがゲームを終了させる場合
    ans = min(ans,abs(prev-a_ls[-1]))
    iB[i] = ans

if N != 1:
    print(iA[0])
else:
    print(abs(W-a_ls[0]))

N, Z, W = map(int, input().split())
A = list(map(int, input().split()))
if N == 1:
    print(abs(W - A[0]))
else:
    # Xが自由に決定できるのは結局A[-1] - WかA[-1] - A[-2]の二通りのみ
    # 2枚以上カードを残してもYによってA[-1] - A[-2]にされてしまう
    # いくら他に値が大きくなる手があっても結局この二手に限られてしまうので
    # その中の最大値を出力する
    ans = max(abs(A[-1] - W), abs(A[-1] - A[-2]))
    print(ans)