patch this code :
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define MOD 1000000007LL

typedef long long ll;

typedef struct {
    ll value; // The value of nums[i]
    int index; // The index i in nums
} Element;

int compareElements(const void* a, const void* b) {
    Element* ea = (Element*)a;
    Element* eb = (Element*)b;
    if (ea->value != eb->value)
        return (ea->value < eb->value) ? -1 : 1;
    else
        return (ea->index < eb->index) ? -1 : 1;
}

// Fast exponentiation modulo MOD
ll mod_pow(ll base, ll exp, ll mod) {
    ll result = 1;
    base %= mod;
    while (exp > 0) {
        if (exp & 1LL)
            result = (result * base) % mod;
        base = (base * base) % mod;
        exp >>= 1LL;
    }
    return result;
}

// Function to find minimal t such that x_j * multiplier^t >= x_{j+1}
ll find_min_t(ll xj, ll xj1, ll multiplier) {
    if (multiplier == 1) {
        // Cannot reach xj1 if multiplier is 1 unless xj >= xj1
        if (xj >= xj1)
            return 0;
        else
            return LLONG_MAX;
    }
    ll t = 0;
    ll left = 0, right = 60; // 60 should be enough as multiplier^60 is huge
    while (left <= right) {
        ll mid = left + (right - left) / 2;
        // Check if xj * multiplier^mid >= xj1
        // Avoid overflow by taking logarithms
        double logResult = log(xj) + mid * log(multiplier);
        double logXj1 = log(xj1);
        if (logResult >= logXj1) {
            t = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return t;
}

int* getFinalState(int* nums, int numsSize, int k, int multiplier, int* returnSize) {
    int n = numsSize;
    returnSize = n;
    int result = (int*)malloc(n * sizeof(int));
    ll* exponents = (ll*)calloc(n, sizeof(ll)); // To keep track of multiplications

    // Create and sort elements
    Element* elements = (Element*)malloc(n * sizeof(Element));
    for (int i = 0; i < n; i++) {
        elements[i].value = nums[i];
        elements[i].index = i;
    }
    qsort(elements, n, sizeof(Element), compareElements);

    ll k_remaining = k;
    ll multiplier_ll = multiplier;
    ll count = 0;
    int pos = 0;

    while (pos < n && k_remaining > 0) {
        ll current_value = elements[pos].value;
        ll next_value = current_value;
        int start = pos;
        // Count how many times the current value occurs
        while (pos < n && elements[pos].value == current_value) {
            pos++;
        }
        int count_current = pos - start;

        // Find the next distinct value
        if (pos < n) {
            next_value = elements[pos].value;
        } else {
            // No next value, we can perform as many multiplications as we have operations left
            next_value = LLONG_MAX;
        }

        ll t = find_min_t(current_value, next_value, multiplier_ll);

        // If t is too large, adjust to k_remaining / count_current
        if (t * count_current > k_remaining) {
            // Distribute the remaining operations
            ll t_increment = k_remaining / count_current;
            ll extra = k_remaining % count_current;

            // Update exponents for current elements
            for (int i = start; i < pos; i++) {
                exponents[elements[i].index] += t_increment;
            }
            for (int i = start; i < start + extra; i++) {
                exponents[elements[i].index] += 1;
            }
            k_remaining = 0;
        } else {
            // We can increase current elements to reach next_value
            for (int i = start; i < pos; i++) {
                exponents[elements[i].index] += t;
            }
            k_remaining -= t * count_current;
        }

        if (multiplier_ll == 1) {
            // Cannot increase further
            break;
        }
    }

    // Compute the final values
    for (int i = 0; i < n; i++) {
        ll final_value = nums[i];
        if (exponents[i] > 0) {
            final_value = (final_value * mod_pow(multiplier_ll, exponents[i], MOD)) % MOD;
        } else {
            final_value = final_value % MOD;
        }
        result[i] = (int)final_value;
    }

    free(elements);
    free(exponents);

    return result;
}