Algorithms: Sorting

    static int quick_sort(Span<int> a) {
        checked {
            int n = a.Length;
            alg_require(((n >= 0) && (n <= 1000000)));
            alg_require((a.Length == n));
            int[] lefts = new int[alg_size(64)];
            int[] rights = new int[alg_size(64)];
            int top = 0;
            int low = 0;
            int high = (n - 1);
            int left = 0;
            int right = 0;

int quick_sort(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));
    std::vector<int> lefts(alg_size(64), 0);
    std::vector<int> rights(alg_size(64), 0);
    int top = 0;
    int low = 0;
    int high = alg_sub(n, 1);
    int left = 0;
    int right = 0;

function bubble_sort(array &$a): int {
    alg_require(array_is_list($a));
    $n = count($a);
    alg_require((($n >= 0) && ($n <= 1000000)));
    alg_require((count($a) == $n));
    $end = alg_sub($n, 1);
    $i = 0;
    $swapped = 0;
    $temp = 0;
    while (($end > 0)) {
        $swapped = 0;
        $i = 0;

def quick_sort(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)
    lefts: list[int] = [0] * alg_size(64)
    rights: list[int] = [0] * alg_size(64)
    top: int = 0
    low: int = 0
    high: int = n - 1
    left: int = 0
    right: int = 0

function quick_sort(a) {
    alg_require(a instanceof Int32Array);
    let n = a.length;
    alg_require(((n >= 0) && (n <= 1000000)));
    alg_require((a.length == n));
    let lefts = new Int32Array(alg_size(64));
    let rights = new Int32Array(alg_size(64));
    let top = 0;
    let low = 0;
    let high = alg_sub(n, 1);
    let left = 0;
    let right = 0;