program main
  implicit none
  integer(8) :: n, k, mi, ma, md, i, x, y, z, negs, zeros, poss
  integer(8), allocatable :: a(:)
  read (*, *) n, k
  allocate (a(n))
  read (*, *) a(:)
  call quicksort(a)
  call count_pairs(a, n, negs, zeros, poss, x, y, z)
  if (negs < k .and. k <= negs + zeros) then  ! Zero
    write (*, "(i0)") 0
  else
    mi = -2 * 10_8 ** 18  ! Not large enough
    ma = 2 * 10_8 ** 18  ! Large enough
    do i = 1, 200
      md = mi + (ma - mi) / 2
      if (m_is_large_enough(md, k, n, a, negs, x)) then
        ma = md
      else
        mi = md
      end if
    end do
    write (*, "(i0)") ma
  end if

  contains

  logical function m_is_large_enough(m, k, n, a, negs, x)
    integer(8), intent(in) :: n, k, m, a(n), x, negs
    integer(8) :: cnt
    if (k <= negs) then  ! Negative
      cnt = shakutori_n(x, z, a(1:x), a(x + y + 1:n), m)
    else
      cnt = 0  ! ttk shakutori_p(a(1:x), a(x + y + 1:n), m)
    end if
    m_is_large_enough = (cnt >= k)
  end function m_is_large_enough

  integer(8) function shakutori_n(x, z, negs, poss, m)
    integer(8), intent(in) :: x, z, negs(x), poss(z), m
    integer(8) :: p1, p2
    ! Count combinations no more than m
    shakutori_n = 0
    p2 = z + 1
    outer: do p1 = 1, x
      do while (negs(p1) * poss(p2 - 1) > m)
        p2 = p2 - 1
        if (p2 <= 1) exit outer
      end do
      shakutori_n = shakutori_n + p2 - 1
    end do outer
  end function shakutori_n

  recursive subroutine quicksort(a)
    integer(8), intent(inout) :: a(:)
    integer(8) :: pivot, i, j, k, tmp, n
    real(4) :: r
    n = size(a)
    if (n <= 1) return
    i = 1
    j = n
    call random_number(r)
    k = 1 + floor(r * n)
    k = max(1, min(k, n))
    pivot = a(k)
    do
      do while (.not. pivot <= a(i))
        i = i + 1
      end do
      do while (.not. a(j) <= pivot)
        j = j - 1
      end do
      if (i >= j) exit
      tmp = a(i)
      a(i) = a(j)
      a(j) = tmp
      i = i + 1
      j = j - 1
    end do
    call quicksort(a(1:i - 1))
    call quicksort(a(j + 1:n))
  end subroutine quicksort

  subroutine count_pairs(a, n, negs, zeros, poss, nega, zeroa, posa)
    integer(8), intent(in) :: n, a(n)
    integer(8), intent(out) :: negs, zeros, poss, nega, zeroa, posa
    integer(8) :: i
    do i = 1, n
      if (a(i) < 0) nega = i
      if (a(i) <= 0) zeroa = i
    end do
    posa = n - zeroa
    zeroa = zeroa - nega
    negs = nega * posa
    zeros = zeroa * (posa + nega) + (zeroa * (zeroa - 1)) / 2
    poss = (n * (n - 1)) / 2 - negs - zeros
  end subroutine count_pairs
end program main
