#include <iostream>
#include <assert.h>
#include <vector>
#include <unordered_map>
#include <queue>
#include <climits>
#include <cmath>
#include <algorithm>
using namespace std;
constexpr int64_t MOD = 1000000007;
//constexpr int64_t MOD = 1e9 + 7;

int64_t minus_product_saerch(int64_t K, vector<int64_t>& minusVals, vector<int64_t>& plusVals) {
  //cout << "search minus " << K << endl;
  sort(minusVals.begin(), minusVals.end());
  sort(plusVals.begin(), plusVals.end());
  int64_t l = minusVals[0] * plusVals[0];
  int64_t r = minusVals.back() * plusVals.back() + 1;
  // [ )
  while (l < r) {
    int64_t mid = (l + r) / 2;
    int64_t cnt = 0;
    bool found = false;
    for (auto mval : minusVals) {
      int64_t tgt = mid / mval;
      auto up_bnd = upper_bound(plusVals.begin(), plusVals.end(), tgt);
      //cout << "mid, mval, tgt, find_idx: "<< mid << "," << mval << "," << tgt << "," << up_bnd - plusVals.begin() << endl;
      cnt += up_bnd - plusVals.begin();
      if (*up_bnd * mval == mid) {found = true;}
    }
    if (cnt < K) {
      l = mid + 1;
    } else if (cnt == K && found == true) {
      return mid;
    } else {
      r = mid;
    }
  }
  return l;
}

int64_t plus_product_saerch(int64_t K, vector<int64_t>& minusVals, vector<int64_t>& plusVals) {
  //cout << "search plus " << K << endl;
  int64_t r = INT_MAX;
  if (!minusVals.empty()) {
    sort(minusVals.begin(), minusVals.end());
    r = minusVals.back() * minusVals.back();
  }
  if (!plusVals.empty()) {
    sort(plusVals.begin(), plusVals.end());
    r = max(r, plusVals.back() * plusVals.back());
  }
  int64_t l = 1;

  // [ )
  while (l < r) {
    int64_t mid = (l + r) / 2;
    int64_t cnt = 0;
    bool found = false;
    for (auto it = minusVals.begin(); it != minusVals.end(); it++) {
      int64_t val = *it;
      int64_t tgt = mid / val;
      auto up_bnd = upper_bound(it + 1, minusVals.end(), tgt); 
      cnt += up_bnd - it - 1;
      if (*up_bnd * val == mid) { found = true; }
    }
    //cout <<"search_plus(minus): " <<  l << "," << r << "," << mid << "," << cnt << endl;
    for (auto it = plusVals.begin(); it != plusVals.end(); it++) {
      int64_t val = *it;
      int64_t tgt = mid / val;
      auto up_bnd = upper_bound(it + 1, plusVals.end(), tgt); 
      //cout << val << "," << tgt << "," << up_bnd - plusVals.begin() << endl;
      cnt += up_bnd - it - 1;
      if (*up_bnd * val == mid) { found = true; }
    }
    //cout <<"search_plus(total): " <<  l << "," << r << "," << mid << "," << cnt << endl;

    if (cnt < K) {
      l = mid + 1;
    } else if (cnt == K && found == true) {
      return mid;
    } else {
      r = mid;
    }
  }
  return l;
}
int main(){
  std::cin.tie(0);
  std::ios::sync_with_stdio(false);

  int32_t N;
  cin >> N;
  int64_t K;
  cin >> K;
  
  vector<int64_t> minusVals;
  vector<int64_t> plusVals;
  int64_t num_zero = 0;
  for (int i = 0; i < N; i++) {
    int64_t A;
    cin >> A;
    if (A == 0) {
      num_zero++;
    } else if (A < 0) {
      minusVals.push_back(-A);
    } else {
      plusVals.push_back(A);
    }
  }
  int64_t num_minus = (int64_t) minusVals.size();
  int64_t num_plus = (int64_t) plusVals.size();
  int64_t num_zero_product = (num_plus + num_minus) * num_zero + (num_zero * (num_zero - 1) / 2);
  int64_t num_minus_product = (num_plus * num_minus);
  //int64_t num_plus_product = (num_plus * num_plus) + (num_minus * num_minus);
  //cout << "num minu, num zero :: " << num_minus_product << "," << num_zero_product << endl;
  if (K <= num_minus_product) {
    int64_t res = minus_product_saerch(num_minus_product - K + 1, minusVals, plusVals);
    cout << -res << endl;
    return 0;
  } else if (K <= num_minus_product + num_zero_product) {
    cout << 0 << endl;
    return 0;
  } else {
    int64_t res = plus_product_saerch(K - num_zero_product - num_minus_product, minusVals, plusVals);
    cout << res << endl;
    return 0;
  }

  return 0;
}


Measured memory_bytes: 2420