For problem statement at 0-999/800-899/870-879/875/problemE.txt this is a correct solution, but verifier at 0-999/800-899/870-879/875/verifierE.go ends with All 100 tests passed can you fix the verifier? package main

import (
	"fmt"
	"io"
	"os"
	"sort"
)

var buf []byte
var bufIdx, bufLen int

func nextInt() int {
	for bufIdx < bufLen && buf[bufIdx] <= ' ' {
		bufIdx++
	}
	if bufIdx >= bufLen {
		return 0
	}
	res := 0
	sign := 1
	if buf[bufIdx] == '-' {
		sign = -1
		bufIdx++
	}
	for bufIdx < bufLen && buf[bufIdx] >= '0' && buf[bufIdx] <= '9' {
		res = res*10 + int(buf[bufIdx]-'0')
		bufIdx++
	}
	return res * sign
}

func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

func lowerBound(vals []int, target int) int {
	l, r := 0, len(vals)
	for l < r {
		mid := l + (r-l)/2
		if vals[mid] >= target {
			r = mid
		} else {
			l = mid + 1
		}
	}
	return l
}

func upperBound(vals []int, target int) int {
	l, r := 0, len(vals)
	for l < r {
		mid := l + (r-l)/2
		if vals[mid] > target {
			r = mid
		} else {
			l = mid + 1
		}
	}
	return l
}

type Node struct {
	sum   int
	clear bool
}

var tree []Node
var X []int
var vals []int
var n, s1, s2, m int

func initTree(m int) {
	for i := 0; i < 4*m+10; i++ {
		tree[i].sum = 0
		tree[i].clear = false
	}
}

func pushDown(node int) {
	if tree[node].clear {
		tree[2*node].sum = 0
		tree[2*node].clear = true
		tree[2*node+1].sum = 0
		tree[2*node+1].clear = true
		tree[node].clear = false
	}
}

func updateRangeZero(node, l, r, ql, qr int) {
	if ql > r || qr < l {
		return
	}
	if ql <= l && r <= qr {
		tree[node].sum = 0
		tree[node].clear = true
		return
	}
	pushDown(node)
	mid := l + (r-l)/2
	updateRangeZero(2*node, l, mid, ql, qr)
	updateRangeZero(2*node+1, mid+1, r, ql, qr)
	tree[node].sum = tree[2*node].sum + tree[2*node+1].sum
}

func updatePointOne(node, l, r, pos int) {
	if l == r {
		tree[node].sum = 1
		tree[node].clear = false
		return
	}
	pushDown(node)
	mid := l + (r-l)/2
	if pos <= mid {
		updatePointOne(2*node, l, mid, pos)
	} else {
		updatePointOne(2*node+1, mid+1, r, pos)
	}
	tree[node].sum = tree[2*node].sum + tree[2*node+1].sum
}

func check(D int) bool {
	if abs(X[0]-s2) > D {
		return false
	}
	initTree(m)
	posS2 := lowerBound(vals, s2)
	updatePointOne(1, 0, m-1, posS2)

	for i := 1; i <= n; i++ {
		can_add := tree[1].sum > 0 && abs(X[i]-X[i-1]) <= D

		left_idx := lowerBound(vals, X[i]-D)
		right_idx := upperBound(vals, X[i]+D) - 1

		if left_idx > 0 {
			updateRangeZero(1, 0, m-1, 0, left_idx-1)
		}
		if right_idx < m-1 {
			updateRangeZero(1, 0, m-1, right_idx+1, m-1)
		}

		if can_add {
			posPrev := lowerBound(vals, X[i-1])
			updatePointOne(1, 0, m-1, posPrev)
		}

		if tree[1].sum == 0 {
			return false
		}
	}
	return true
}

func main() {
	b, _ := io.ReadAll(os.Stdin)
	buf = b
	bufLen = len(buf)

	n = nextInt()
	s1 = nextInt()
	s2 = nextInt()

	X = make([]int, n+1)
	X[0] = s1
	vals = make([]int, 0, n+2)
	vals = append(vals, s2, s1)

	for i := 1; i <= n; i++ {
		X[i] = nextInt()
		vals = append(vals, X[i])
	}

	sort.Ints(vals)
	m = 0
	for i := 0; i < len(vals); i++ {
		if i == 0 || vals[i] != vals[i-1] {
			vals[m] = vals[i]
			m++
		}
	}
	vals = vals[:m]

	tree = make([]Node, 4*m+10)

	low := abs(s1 - s2)
	high := 1000000000
	ans := high

	for low <= high {
		mid := low + (high-low)/2
		if check(mid) {
			ans = mid
			high = mid - 1
		} else {
			low = mid + 1
		}
	}

	fmt.Println(ans)
}