// Readiz lesson: complete local C++17 example.
#include <algorithm>
#include <deque>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int lowerBound(const vector<int>& a, int target) {
    int left = 0;
    int right = (int)a.size();

    while (left < right) {
        int mid = left + (right - left) / 2;
        if (a[mid] < target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

bool canMake(const vector<long long>& time, long long need, long long t) {
    long long made = 0;
    for (long long one : time) {
        made += t / one;
        if (made >= need) return true;
    }
    return false;
}

long long minimumTime(const vector<long long>& time, long long need) {
    long long left = 0;
    long long right = 1;
    while (!canMake(time, need, right)) {
        right *= 2;
    }

    while (left < right) {
        long long mid = left + (right - left) / 2;
        if (canMake(time, need, mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}

bool canPlace(const vector<int>& pos, int k, int d) {
    int count = 1;
    int last = pos[0];

    for (int i = 1; i < (int)pos.size(); ++i) {
        if (pos[i] - last >= d) {
            count++;
            last = pos[i];
            if (count >= k) return true;
        }
    }
    return false;
}

int maximizeMinimumDistance(vector<int> pos, int k) {
    sort(pos.begin(), pos.end());

    int left = 0;
    int right = pos.back() - pos.front();

    while (left < right) {
        int mid = left + (right - left + 1) / 2;
        if (canPlace(pos, k, mid)) {
            left = mid;
        } else {
            right = mid - 1;
        }
    }
    return left;
}

int upperBound(const vector<int>& a, int target) {
    int left = 0, right = (int)a.size();
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (a[mid] <= target) left = mid + 1;
        else right = mid;
    }
    return left;
}

int main(int argc, char** argv) {
    ios::sync_with_stdio(false); cin.tie(nullptr);
    string mode = argc == 1 ? "--make" : argc == 2 ? argv[1] : "";
    if (mode == "--bounds") {
        int n, target;
        if (!(cin >> n >> target) || n < 0 || n > 200000 || target < -1000000000 || target > 1000000000) return 1;
        vector<int> a(n);
        for (int& v : a) if (!(cin >> v) || v < -1000000000 || v > 1000000000) return 1;
        if (!is_sorted(a.begin(), a.end())) return 1;
        int lower = lowerBound(a, target), upper = upperBound(a, target);
        cout << lower << ' ' << upper << ' ' << upper - lower << '\n';
    } else if (mode == "--place") {
        int n, k;
        if (!(cin >> n >> k) || n < 2 || n > 200000 || k < 2 || k > n) return 1;
        vector<int> positions(n);
        for (int& p : positions) if (!(cin >> p) || p < 0 || p > 1000000000) return 1;
        cout << maximizeMinimumDistance(positions, k) << '\n';
    } else if (mode == "--make") {
        int n; long long need;
        if (!(cin >> n >> need) || n < 1 || n > 200000 || need < 1 || need > 1000000000) return 1;
        vector<long long> times(n);
        for (auto& t : times) if (!(cin >> t) || t < 1 || t > 1000000000) return 1;
        cout << minimumTime(times, need) << '\n';
    } else return 1;
    return 0;
}