sort.sg

proc bitxor(a: Int, b: Int) -> Int = core {
    bitwise-xor [SP], [SP - 1]
    pop
} in

proc bitor(a: Int, b: Int) -> Int = core {
    bitwise-or [SP], [SP - 1]
    pop
} in

proc bitnand(a: Int, b: Int) -> Int = core {
    bitwise-nand [SP], [SP - 1]
    pop
} in

proc bitand(a: Int, b: Int) -> Int = core {
    bitwise-and [SP], [SP - 1]
    pop
} in

proc bitnot(x: Int) -> Int = core {
    bitwise-not [SP]
} in

proc alloc(size: Int) -> &Cell = std {
    alloc [SP]
} in

proc free(ptr: &Int) = std {
    free [SP]
    pop
} in

proc puthex(n: Int, lower: Bool) -> None = {
    if (n < 16) {
        put (n + if (n < 10) {
            48
        } else if lower {
            87
        } else {
            55
        }) as Char
    } else {
        puthex(n / 16, lower);
        puthex(n % 16, lower)
    }
} in

proc putbyte(n: Int, lower: Bool) -> None = {
    puthex(n / 16, lower);
    puthex(n % 16, lower)
} in


proc ln() -> None = {
    put '\n'
} in

proc min(x: Int, y: Int) -> Int = {
    if (x < y) x else y
} in
proc max(x: Int, y: Int) -> Int = {
    if (x > y) x else y
} in


type List = struct { data: Int, next: &List } in

proc sort(node: &List) -> None = {
    if (node->next != Null) {
        sort(node->next);
        let a = min(node->data, node->next->data),
            b = max(node->data, node->next->data)
            in {
            if (b != node->data) {
                sort(node->next);
            };
            node->data = a;
            node->next->data = b;
        };
    }
} in

proc len(node: &List) -> Int = {
    if (node != Null) {
        len(node->next) + 1
    } else {
        0
    }
} in


proc index(node: &List, n: Int) -> &List = {
    while n {
        node = node->next;
        n -= 1;
    };
    node
} in

proc swapi(a: &Int, b: &Int) = {
    let tmp = (*a) in {
        (*a) = *b;
        (*b) = tmp;
    }
} in

proc partition_arr(arr: &Int, low: Int, high: Int) -> Int = {
    let pivot = arr[high],
        i = low - 1,
        j = low in {
        while j < high {
            if (arr[j] <= pivot) {
                i += 1;
                swapi(&arr[j], &arr[i]);
            };
            j += 1
        };
        swapi(&arr[i + 1], &arr[high]);
        i + 1
    }
} in

proc quicksort_arr(arr: &Int, low: Int, high: Int) = {
    if (low < high) {
        let pi = partition_arr(arr, low, high) in {
            quicksort_arr(arr, low, pi - 1);
            quicksort_arr(arr, pi + 1, high);
        }
    }
} in

proc get_int() -> Int = core {
    next SP
    get [SP], stdin.int
} in

proc get_list(size: Int) -> &Int = {
    let arr: &Int = alloc(size) as &Int, i = 0 in {
        while (i < size) {
            arr[i] = get_int();
            i += 1;
        };
        arr
    }
} in {
    let len = get_int(),
        list = get_list(len),
        i = 0 in {
        quicksort_arr(list, 0, len - 1);
        
        while i < len {
            put list[i];
            i += 1;
        };
    }
}