import java.io._
import java.util.StringTokenizer
import scala.util.control.Breaks.{breakable,break}
import scala.collection.mutable.{Map, Stack, Queue, PriorityQueue, Set}

object Main extends App {
  val in = new InputReader(System.in)
  val pw = new PrintWriter(System.out)

  val N = in.next().toInt
  var K = in.next().toInt
  val A = new Array[Long](N)
  var zero = 0
  var _posi = List[Long]()
  var _nega = List[Long]()
  for (i <- 0 until N) {
    val now = in.next().toLong
    A(i) = now

    if (now == 0)
      zero += 1
    else if (now < 0)
      _nega = now :: _nega
    else
      _posi = now :: _posi
  }

  val posi = _posi.toArray.sorted
  val nega = _nega.toArray.sorted.reverse
  // println(posi.toList)
  // println(nega.toList)

  //
  // 条件を満たす最小の値を返す
  def binarySearch(_min: Long, _max: Long, k: Long): Long = {
    def check(i: Long): Boolean = {
      var cnt = 0

      var pos = 0
      var neg = 0
      while (neg < negaNum) {
        if (nega(neg) * posi(pos) <= i) {
          if (pos == posiNum - 1) {
            cnt += pos+1
            neg += 1
          }
          else
            pos += 1
        }
        else {
          cnt += pos
          neg += 1
        }
      }

      cnt >= k
    }

    def func(min: Long, max: Long): Long = {
      val mid: Long = (max + min) / 2
        (max - min) match{
        case 0 | 1 =>
          check(min) match{
            case true  => min
            case false => max
          }
        case _ =>
          (check(mid)) match{
            case true  => func(min, mid)
            case false => func(mid, max)
          }
      }
    }

    func(_min, _max)
  }


  val posiNum = posi.length
  val negaNum = nega.length

  var ans = 0L
  breakable {
    val minus = posiNum * negaNum
    if (K <= minus) {
      ans = binarySearch(-1e18.toLong, -1, K)
      break
    }
    K -= minus

    if (K <= zero) {
      ans = 0
      break
    }
    K -= zero

    // TODO: プラスのにぶたん
  }

  println(ans)
}

object Sub {
  def print2DimArray[A](mat: Array[Array[A]]): Unit = {
    mat.foreach(lin => println(lin.toList))
  }
}

class InputReader(stream: InputStream) {
  private[this] val reader = new BufferedReader(new InputStreamReader(stream))
  private[this] var tokenizer: StringTokenizer = new StringTokenizer(reader.readLine())
  def next(): String = {
    while (!tokenizer.hasMoreTokens()) {
      tokenizer = new StringTokenizer(reader.readLine())
    }
    tokenizer.nextToken()
  }
}
