Algorithms: Array Techniques

    static int next_permutation(int[] a) {
        java.util.Objects.requireNonNull(a, "a");
        int n = a.length;
        alg_require(((n >= 0) && (n <= 1000000)));
        alg_require((a.length == n));
        int pivot = Math.subtractExact(n, 2);
        int right = Math.subtractExact(n, 1);
        int left = 0;
        int temp = 0;
        int advanced = 0;
        while (((pivot >= 0) && (a[pivot] >= a[Math.addExact(pivot, 1)]))) {
            pivot = Math.subtractExact(pivot, 1);

function next_permutation(a) {
    alg_require(a instanceof Int32Array);
    let n = a.length;
    alg_require(((n >= 0) && (n <= 1000000)));
    alg_require((a.length == n));
    let pivot = alg_sub(n, 2);
    let right = alg_sub(n, 1);
    let left = 0;
    let temp = 0;
    let advanced = 0;
    while (((pivot >= 0) && (a[pivot] >= a[alg_add(pivot, 1)]))) {
        pivot = alg_sub(pivot, 1);

def next_permutation(a: list[int]) -> int:
    alg_require(isinstance(a, list) and len(a) <= 1000000)
    n: int = len(a)
    alg_require(n >= 0 and n <= 1000000)
    alg_require(len(a) == n)
    pivot: int = n - 2
    right: int = n - 1
    left: int = 0
    temp: int = 0
    advanced: int = 0
    while pivot >= 0 and a[pivot] >= a[pivot + 1]:
        pivot -= 1

int next_permutation(int *a, size_t a_length) {
    int alg_error = 0;
    int alg_result = INT_MIN;
    errno = 0;
    if (a_length > 1000000 || (a_length && !a)) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    int n = (int)a_length;
    if (alg_error) { errno = ERANGE; alg_result = INT_MIN; goto alg_cleanup; }
    if (!(((n >= 0) && (n <= 1000000)))) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    if (alg_error) { errno = ERANGE; alg_result = INT_MIN; goto alg_cleanup; }
    if (!(((int)a_length == n))) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    if (alg_error) { errno = ERANGE; alg_result = INT_MIN; goto alg_cleanup; }
    int pivot = alg_sub(n, 2, &alg_error);

int next_permutation(std::vector<int>& a) {
    alg_require(a.size() <= 1000000);
    int n = (int)a.size();
    alg_require(((n >= 0) && (n <= 1000000)));
    alg_require(((int)a.size() == n));
    int pivot = alg_sub(n, 2);
    int right = alg_sub(n, 1);
    int left = 0;
    int temp = 0;
    int advanced = 0;
    while (((pivot >= 0) && (a[pivot] >= a[alg_add(pivot, 1)]))) {
        pivot = alg_sub(pivot, 1);