static long minTime(long[] machines, long goal) {
        Arrays.sort(machines);
        long fastestMachineNumDays = machines[0];

        // Binary search bounds
        long lowNumDays = 1;
        long highNumDays = fastestMachineNumDays * goal;
        long result = highNumDays;
        
        while (lowNumDays <= highNumDays) {
            long midNumDays = lowNumDays + (highNumDays - lowNumDays) / 2;
            // Compute production in 'midNumDays' days
            long total = 0;
            for (long m : machines) {
                total += midNumDays / m;
                if (total >= goal) {
                    break; // early exit if goal reached
                }
            }
            if (total < goal) {
                lowNumDays = midNumDays + 1;
            } else {
                result = midNumDays;
                highNumDays = midNumDays - 1;
            }
        }
        return result;
    }

def minTime(machines, goal):
    machines.sort()
    worst = machines[-1] * goal//len(machines)
    best = machines[0] * goal//len(machines)
    result = -1
    while worst>best+1:
        mid = best+(worst - best) // 2
        count = 0
        for machine in machines:
            count += mid//machine
        if count >=goal:
            worst = mid
            result = mid
        else:
            best = mid
    return result

long production(long days, const vector<long>& machines) {
    long sum = 0;
    for (long x : machines) sum = sum + floor(days / x);
    return sum;
}

long minTime(vector<long> machines, long goal) {
    long low = 0, high = *min_element(machines.begin(), machines.end()) * goal;
    while (low < high) {
        long mid = (low + high) / 2;
        if (production(mid, machines) < goal) low = mid + 1;
        else high = mid;
    }
    return low;
}

long minTime(vector<long> machines, long goal) {
    //binary search
    // check if sum of machines = goal or < or >
    
    int n = machines.size();
    long fastest = *min_element(machines.begin(), machines.end());
    
    long low = 0, high = goal*fastest;
    long mid = (low+high)/2;
    long sum = 0;
    while(high >= low)
    {
        sum = 0;
        for(int i=0; i<n; i++)
        {
            sum += (mid/machines[i]);
        }
        
        if(sum == goal) break;
        else if(sum > goal)
        {
            high = mid;
        }
        else {
            low = mid;
        }
        mid = (low+high)/2;
    }
    
    int num = mid;
    while(sum == goal)
    {
        num--;
        sum = 0;
        for(int i=0; i<n; i++)
        {
            sum += (num/machines[i]);
        }
        if(sum != goal)
        {
            num++;
            break;
        }
    }
    return num;
}

def min_time(machines, num_items_goal):
    fastest_machine = min(machines)
    slowest_machine = max(machines)
    fastest_production_num_days_per_item = fastest_machine // len(machines)
    slowest_production_num_days_per_item = slowest_machine // len(machines) + 1
    min_days, max_days = \
        fastest_production_num_days_per_item * num_items_goal, \
        slowest_production_num_days_per_item * num_items_goal
    while max_days - min_days > 1:
        mid = (max_days + min_days) // 2
        item_cnt = 0
        for m in machines:
            item_cnt += mid // m
        if item_cnt < num_items_goal:
            min_days = mid
        else:
            max_days = mid
    return max_days  # we return the bigger number