where can be possible runtime error in this code

import sys

# максимизировать минимальное расстояние между двумя занятыми координатами
# нужно дополнительно занять еще n - k точек

INF = 1e12


# возможно нужно 2 указателя налево и направо для определения
# можно ли расставить точки с данной дистанцией
# начинать можно откуда угодно, можно взять первый buisy point
# нужно рассматривать расстояние не только до предыдущей точки, но и до следующей
# также дополнительно нужно проверять, что расстояние между уже занятыми координатами подходит для заданной дистанции
def can_place(coords, buisy_coords, dist, to_place, start_point_id, mapping):
    right_pointer_cur = mapping[start_point_id]
    right_pointer_prev = start_point_id
    left_pointer_cur = mapping[start_point_id]
    left_pointer_prev = start_point_id

    right_pointer_next = start_point_id + 1
    left_pointer_next = start_point_id - 1

    limited_right = False
    limited_left = False
    buisy_right_setted = False
    buisy_left_setted = False
    n = len(coords)

    # Проверяем минимальное расстояние между уже занятыми точками
    for i in range(1, len(buisy_coords)):
        if buisy_coords[i] - buisy_coords[i - 1] < dist:
            return False  # Нарушено условие минимального расстояния

    while to_place > 0 and not (limited_left and limited_right):
        if not limited_right:
            cur_val_right = coords[right_pointer_cur]
            if not buisy_right_setted:
                prev_val_right = buisy_coords[right_pointer_prev]
            else:
                buisy_right_setted = False
            next_val_right = (
                buisy_coords[right_pointer_next]
                if right_pointer_next < len(buisy_coords)
                else INF
            )
            # move to the right
            while cur_val_right - prev_val_right < dist:
                right_pointer_cur += 1
                if right_pointer_cur >= n:
                    break    
                cur_val_right = coords[right_pointer_cur]

            if right_pointer_cur >= n:
                limited_right = True

            if next_val_right - cur_val_right < dist:
                right_pointer_prev += 1
                right_pointer_next += 1
                right_pointer_cur = mapping[right_pointer_prev]
                continue

            # set new right point
            if (
                right_pointer_cur < n
                and cur_val_right - prev_val_right >= dist
                and next_val_right - cur_val_right >= dist
            ):
                # засеттили новый занятый поинт, который находится между двумя уже засетчеными
                # обновляем его вэлью, но не индекс, т.к. такого не было изначально в buisy set'e
                prev_val_right = coords[right_pointer_cur]
                buisy_right_setted = True
                to_place -= 1

        if not limited_left:
            cur_val_left = coords[left_pointer_cur]
            if not buisy_left_setted:
                prev_val_left = buisy_coords[left_pointer_prev]
            else:
                buisy_left_setted = False
            next_val_left = (
                buisy_coords[left_pointer_next] if left_pointer_next >= 0 else -INF
            )
            # move to the left
            while prev_val_left - cur_val_left < dist:
                left_pointer_cur -= 1
                if left_pointer_cur < 0:
                    break
                cur_val_left = coords[left_pointer_cur]

            if left_pointer_cur < 0:
                limited_left = True

            if cur_val_left - next_val_left < dist:
                left_pointer_prev -= 1
                left_pointer_next -= 1
                right_pointer_cur = right_pointer_prev
                continue

            # set new left point
            if (
                left_pointer_cur >= 0
                and cur_val_left - next_val_left >= dist
                and prev_val_left - cur_val_left >= dist
            ):
                # left_pointer_prev = left_pointer_cur
                prev_val_left = coords[left_pointer_cur]
                buisy_left_setted = True
                to_place -= 1
    return to_place <= 0


def max_min_distance(n, m, k, coords, buisy_coords, no_buisy):
    coords.sort()
    buisy_coords.sort()

    if no_buisy:
        k += 1
        assert len(buisy_coords) == 0
        buisy_coords.append(coords[0])

    buisy2all_map = {}
    b_index = 0
    c_index = 0
    while b_index < len(buisy_coords) and c_index < len(coords):
        if coords[c_index] == buisy_coords[b_index]:
            buisy2all_map[b_index] = c_index
            b_index += 1
        c_index += 1

    # Бинарный поиск по минимальному расстоянию
    left, right = 0, coords[-1] - coords[0]

    while left < right:
        mid = (left + right + 1) // 2
        # Проверяем, можно ли разместить дополнительные точки с расстоянием не меньше mid
        possible = False
        if can_place(
            coords, buisy_coords, mid, n - k, start_point_id=0, mapping=buisy2all_map
        ):
            possible = True
        if possible:
            left = mid  # Если возможно, пробуем увеличить расстояние
        else:
            right = mid - 1  # Иначе уменьшаем

    return left


# with open("b.txt", "r") as sys.stdin:
n, m, k = map(int, input().split())
coords = list(map(int, input().split()))  # координаты всех лежанок
no_buisy = True
if k != 0:
    buisy_coords = list(map(int, input().split()))  # координаты занятых лежанок
    no_buisy = False
else:
    buisy_coords = []

# Вычисление максимального минимального расстояния
result = max_min_distance(n, m, k, coords, buisy_coords, no_buisy)
print(result)