program enclose_all
  implicit none
  real(8), parameter :: pi = 3.14159265358979d0
  integer :: n, m, i, j, k, l
  real(8) :: r = 1e18, ai, aj, ak, p(2), a, b, c, x, y, z, d
  real(8), dimension(50,2) :: g = 0.d0, h = 0.d0
  character(64) :: s
  read(*,*) n
  do i = 1, n
    read(*,*) g(i,:)
  end do
  call get_hull(g(1:n,:),h(1:n,:),m)
  if (m == 1) then
    write(*,'(i0)') 0
    stop
  end if
  if (m == 2) then
    write(s,'(f32.16)') 0.5d0*dist(h(1,:),h(2,:))
    write(*,'(a)') trim(adjustl(s))
    stop
  end if
  do concurrent (i=1:m,j=1:m,k=1:m)
    if (i == j .or. j == k .or. k == i) cycle
    ai = angle(h(k,:),h(i,:),h(j,:))
    if (ai < 0.d0) ai = ai+2.d0*pi
    aj = angle(h(i,:),h(j,:),h(k,:))
    if (aj < 0.d0) aj = aj+2.d0*pi
    ak = angle(h(j,:),h(k,:),h(i,:))
    if (ak < 0.d0) ak = ak+2.d0*pi
    if (ai >= 0.5d0*pi) then
      p = 0.5d0*(h(k,:)+h(j,:))
    else if (aj >= 0.5d0*pi) then
      p = 0.5d0*(h(i,:)+h(k,:))
    else if (ak >= 0.5d0*pi) then
      p = 0.5d0*(h(j,:)+h(i,:))
    else
      a = dist2(h(k,:),h(j,:))
      b = dist2(h(i,:),h(k,:))
      c = dist2(h(j,:),h(i,:))
      x = a*(b+c-a)
      y = b*(c+a-b)
      z = c*(a+b-c)
      p = (x*h(i,:)+y*h(j,:)+z*h(k,:))/(x+y+z)
    end if
    d = 0.d0
    do l = 1, m
      d = max(d,dist(p,h(l,:)))
    end do
    r = min(r,d)
  end do
  write(s,'(f32.16)') r
  write(*,'(a)') trim(adjustl(s))
contains
  ! angle of b
  pure real(8) function angle(a,b,c)
    real(8), dimension(2), intent(in) :: a, b, c
    real(8) :: ax, ay, bx, by
    ax = a(1)-b(1)
    ay = a(2)-b(2)
    bx = c(1)-b(1)
    by = c(2)-b(2)
    angle = atan2(ax*by-ay*bx,ax*bx+ay*by)
  end
  pure real(8) function dist2(a,b)
    real(8), dimension(2), intent(in) :: a, b
    dist2 = dot_product(a-b,a-b)
  end
  pure real(8) function dist(a,b)
    real(8), dimension(2), intent(in) :: a, b
    dist = sqrt(dist2(a,b))
  end
  subroutine get_hull(p,h,m)
    real(8), intent(inout) :: p(:,:)
    real(8), intent(out) :: h(:,:)
    integer, intent(out) :: m
    integer :: n, i
    real(8), dimension(2) :: prv, now, nxt
    real(8) :: a, mina, d, maxd
    call merge_sort(p)
    n = size(p,1)
    now = p(1,:)
    prv = (/now(1),now(2)-1.d0/)
    h(1,:) = now
    m = 1
    do
      mina = 2.d0*pi
      maxd = 0.d0
      nxt = p(1,:)
      do i = 1, n
        if (all(p(i,:) == now)) cycle
        a = angle(prv,now,p(i,:))
        d = dist(now,p(i,:))
        if (a < 0.d0) a = a+2.d0*pi
        if (a < mina .and. a >= pi) then
          mina = a
          nxt = p(i,:)
          maxd = d
        else if (a == mina .and. d > maxd) then
          nxt = p(i,:)
          maxd = d
        end if
      end do
      if (all(nxt == h(1,:))) exit
      m = m+1
      h(m,:) = nxt
      prv = now
      now = nxt
    end do
  end
  subroutine merge_sort(a)
    real(8), intent(inout) :: a(:,:)
    integer :: n, m, l, i, u
    n = size(a,1)
    m = n
    l = 1
    do while (m > 1)
      do i = 1, m/2
        u = min(2*i*l,n)
        call merger(a(2*(i-1)*l+1:(2*i-1)*l,:),a((2*i-1)*l+1:u,:))
      end do
      l = 2*l
      m = (m+1)/2
    end do
  end
  subroutine merger(a1,a2)
    real(8), intent(inout) :: a1(:,:), a2(:,:)
    real(8) :: a(size(a1,1)+size(a2,1),size(a1,2))
    integer :: i1, i2, n1, n2
    i1 = 1
    i2 = 1
    n1 = size(a1,1)
    n2 = size(a2,1)
    do while (i1 <= n1 .and. i2 <= n2)
      if (a1(i1,1) > a2(i2,1) .or. (a1(i1,1) == a2(i2,1) .and. a1(i1,2) >= a2(i2,2))) then
        a(i1+i2-1,:) = a1(i1,:)
        i1 = i1+1
      else
        a(i1+i2-1,:) = a2(i2,:)
        i2 = i2+1
       end if
    end do
    if (i1 <= n1) then
      a(i1+i2-1:n1+n2,:) = a1(i1:n1,:)
    else
      a(i1+i2-1:n1+n2,:) = a2(i2:n2,:)
    end if
    a1 = a(1:n1,:)
    a2 = a(n1+1:n1+n2,:)
  end
end program enclose_all

Measured memory_bytes: 256