.data
    .bss
    .globl n
    .p2align 2
n:
    .space 4
    .data

    .text
    .globl bubblesort
    .p2align 2
bubblesort:
.L.bubblesort.0:
    stp x29, x30, [sp, #-16]!
    mov x29, sp
    mov x11, x0
    mov w10, #0
    b .L.bubblesort.1
.L.bubblesort.8:
    mov w8, #1
    add w8, w15, #1
    mov w15, w8
    b .L.bubblesort.4
.L.bubblesort.4:
    adrp x13, n
    ldr w8, [x13, #:lo12:n]
    sub w8, w8, w12
    mov w9, #1
    sub w8, w8, #1
    cmp w15, w8
    b.ge .L.bubblesort.6
.L.bubblesort.5:
    ldr w9, [x11, w15, uxtw #2]
    mov w8, #1
    add w8, w15, #1
    ldr w8, [x11, w8, uxtw #2]
    cmp w9, w8
    b.le .L.bubblesort.8
.L.bubblesort.7:
    mov w8, #1
    add w10, w15, #1
    ldr w9, [x11, w10, uxtw #2]
    ldr w8, [x11, w15, uxtw #2]
    str w8, [x11, w10, uxtw #2]
    str w9, [x11, w15, uxtw #2]
    b .L.bubblesort.8
.L.bubblesort.6:
    mov w8, #1
    add w10, w12, #1
    b .L.bubblesort.1
.L.bubblesort.1:
    adrp x13, n
    ldr w9, [x13, #:lo12:n]
    mov w8, #1
    sub w8, w9, #1
    cmp w10, w8
    b.ge .L.bubblesort.3
.L.bubblesort.2:
    mov w15, #0
    mov w12, w10
    b .L.bubblesort.4
.L.bubblesort.3:
    mov w8, #0
    mov w0, w8
    ldp x29, x30, [sp], #16
    ret

    .text
    .globl insertsort
    .p2align 2
insertsort:
.L.insertsort.0:
    stp x29, x30, [sp, #-16]!
    mov x29, sp
    mov x15, x0
    mov w12, #1
    b .L.insertsort.1
.L.insertsort.5:
    mov w8, #1
    add w8, w11, #1
    ldr w12, [x15, w11, uxtw #2]
    str w12, [x15, w8, uxtw #2]
    sub w8, w11, #1
    mov w11, w8
    b .L.insertsort.4
.L.insertsort.4:
    mov w8, #-1
    cmp w11, w8
    b.le .L.insertsort.6
.L.insertsort.7:
    ldr w8, [x15, w11, uxtw #2]
    cmp w10, w8
    b.lt .L.insertsort.5
.L.insertsort.6:
    mov w8, #1
    add w8, w11, #1
    str w10, [x15, w8, uxtw #2]
    add w8, w9, #1
    mov w12, w8
    b .L.insertsort.1
.L.insertsort.1:
    adrp x13, n
    ldr w8, [x13, #:lo12:n]
    cmp w12, w8
    b.ge .L.insertsort.3
.L.insertsort.2:
    ldr w9, [x15, w12, uxtw #2]
    mov w8, #1
    sub w8, w12, #1
    mov w11, w8
    mov w10, w9
    mov w9, w12
    b .L.insertsort.4
.L.insertsort.3:
    mov w8, #0
    mov w0, w8
    ldp x29, x30, [sp], #16
    ret

    .text
    .globl QuickSort
    .p2align 2
QuickSort:
.L.QuickSort.0:
    stp x29, x30, [sp, #-16]!
    mov x29, sp
    sub sp, sp, #48
    str x21, [sp, #0]
    str x20, [sp, #8]
    str x19, [sp, #16]
    mov x20, x0
    mov w12, w1
    mov w19, w2
    cmp w12, w19
    b.lt .L.QuickSort.1
    b .L.QuickSort.2
.L.QuickSort.13:
    mov w11, #1
    add w8, w8, #1
    b .L.QuickSort.12
.L.QuickSort.12:
    cmp w8, w10
    b.ge .L.QuickSort.14
.L.QuickSort.15:
    ldr w11, [x20, w8, uxtw #2]
    cmp w11, w9
    b.lt .L.QuickSort.13
.L.QuickSort.14:
    cmp w8, w10
    b.lt .L.QuickSort.16
    mov w11, w10
    b .L.QuickSort.17
.L.QuickSort.16:
    ldr w11, [x20, w8, uxtw #2]
    str w11, [x20, w10, uxtw #2]
    mov w11, #1
    sub w10, w10, #1
    mov w11, w10
    b .L.QuickSort.17
.L.QuickSort.17:
    mov w10, w11
    mov w21, w8
    b .L.QuickSort.3
.L.QuickSort.3:
    cmp w21, w10
    b.ge .L.QuickSort.5
.L.QuickSort.4:
    mov w15, w9
    mov w11, w21
    b .L.QuickSort.6
.L.QuickSort.7:
    mov w8, #1
    sub w10, w10, #1
    b .L.QuickSort.6
.L.QuickSort.6:
    cmp w11, w10
    b.ge .L.QuickSort.8
.L.QuickSort.9:
    ldr w9, [x20, w10, uxtw #2]
    mov w8, #1
    sub w8, w15, #1
    cmp w9, w8
    b.gt .L.QuickSort.7
.L.QuickSort.8:
    cmp w11, w10
    b.lt .L.QuickSort.10
    mov w8, w11
    b .L.QuickSort.11
.L.QuickSort.10:
    ldr w8, [x20, w10, uxtw #2]
    str w8, [x20, w11, uxtw #2]
    mov w8, #1
    add w8, w11, #1
    b .L.QuickSort.11
.L.QuickSort.11:
    mov w9, w15
    b .L.QuickSort.12
.L.QuickSort.5:
    str w9, [x20, w21, uxtw #2]
    mov w8, #1
    sub w8, w21, #1
    mov x0, x20
    mov w1, w12
    mov w2, w8
    bl QuickSort
    mov w8, w0
    add w8, w21, #1
    mov x0, x20
    mov w1, w8
    mov w2, w19
    bl QuickSort
    mov w8, w0
    b .L.QuickSort.2
.L.QuickSort.2:
    mov w8, #0
    mov w0, w8
    ldr x21, [sp, #0]
    ldr x20, [sp, #8]
    ldr x19, [sp, #16]
    add sp, sp, #48
    ldp x29, x30, [sp], #16
    ret
.L.QuickSort.1:
    ldr w9, [x20, w12, uxtw #2]
    mov w10, w19
    mov w21, w12
    b .L.QuickSort.3

    .text
    .globl getMid
    .p2align 2
getMid:
.L.getMid.0:
    stp x29, x30, [sp, #-16]!
    mov x29, sp
    mov x11, x0
    adrp x13, n
    ldr w10, [x13, #:lo12:n]
    mov w8, #2
    and w9, w10, #1
    cmp w10, #0
    sub w8, w9, #2
    csel w8, w8, w9, lt
    cmp w9, #0
    csel w9, wzr, w8, eq
    mov w8, #0
    cmp w9, w8
    b.ne .L.getMid.2
.L.getMid.1:
    adrp x13, n
    ldr w9, [x13, #:lo12:n]
    mov w8, #2
    add w8, w9, #1
    cmp w9, #0
    csel w8, w8, w9, lt
    asr w8, w8, #1
    ldr w9, [x11, w8, uxtw #2]
    mov w10, #1
    sub w8, w8, #1
    ldr w8, [x11, w8, uxtw #2]
    add w9, w9, w8
    add w8, w9, #1
    cmp w9, #0
    csel w8, w8, w9, lt
    asr w8, w8, #1
    mov w0, w8
    ldp x29, x30, [sp], #16
    ret
.L.getMid.2:
    adrp x13, n
    ldr w9, [x13, #:lo12:n]
    mov w8, #2
    add w8, w9, #1
    cmp w9, #0
    csel w8, w8, w9, lt
    asr w8, w8, #1
    ldr w8, [x11, w8, uxtw #2]
    mov w0, w8
    ldp x29, x30, [sp], #16
    ret

    .text
    .globl getMost
    .p2align 2
getMost:
.L.getMost.0:
    stp x29, x30, [sp, #-16]!
    mov x29, sp
    sub sp, sp, #4032
    str x20, [sp, #0]
    str x19, [sp, #8]
    mov x12, x0
    mov w10, #0
    b .L.getMost.1
.L.getMost.8:
    mov w11, #1
    add w10, w10, #1
    b .L.getMost.4
.L.getMost.4:
    adrp x13, n
    ldr w11, [x13, #:lo12:n]
    cmp w10, w11
    b.ge .L.getMost.6
.L.getMost.5:
    ldr w20, [x12, w10, uxtw #2]
    mov x19, x29
    sub x19, x19, #4000
    ldr w15, [x19, w20, uxtw #2]
    mov w11, #1
    add w11, w15, #1
    str w11, [x19, w20, uxtw #2]
    ldr w11, [x19, w20, uxtw #2]
    cmp w11, w8
    b.le .L.getMost.8
.L.getMost.7:
    mov x8, x29
    sub x8, x8, #4000
    ldr w8, [x8, w20, uxtw #2]
    mov w9, w20
    b .L.getMost.8
.L.getMost.6:
    mov w0, w9
    ldr x20, [sp, #0]
    ldr x19, [sp, #8]
    add sp, sp, #4032
    ldp x29, x30, [sp], #16
    ret
.L.getMost.2:
    mov x9, x29
    sub x9, x9, #4000
    mov w8, #0
    str w8, [x9, w10, uxtw #2]
    mov w8, #1
    add w8, w10, #1
    mov w10, w8
    b .L.getMost.1
.L.getMost.1:
    mov w8, #1000
    cmp w10, w8
    b.lt .L.getMost.2
.L.getMost.3:
    mov w10, #0
    mov w9, w10
    mov w8, w10
    b .L.getMost.4

    .text
    .globl revert
    .p2align 2
revert:
.L.revert.0:
    stp x29, x30, [sp, #-16]!
    mov x29, sp
    mov x8, x0
    mov w10, #0
    mov w9, w10
    b .L.revert.1
.L.revert.2:
    ldr w11, [x8, w10, uxtw #2]
    ldr w12, [x8, w9, uxtw #2]
    str w12, [x8, w10, uxtw #2]
    str w11, [x8, w9, uxtw #2]
    mov w11, #1
    add w10, w10, #1
    sub w9, w9, #1
    b .L.revert.1
.L.revert.1:
    cmp w10, w9
    b.lt .L.revert.2
.L.revert.3:
    mov w8, #0
    mov w0, w8
    ldp x29, x30, [sp], #16
    ret

    .text
    .globl arrCopy
    .p2align 2
arrCopy:
.L.arrCopy.0:
    stp x29, x30, [sp, #-16]!
    mov x29, sp
    mov x8, x0
    mov x9, x1
    mov w10, #0
    b .L.arrCopy.1
.L.arrCopy.2:
    ldr w11, [x8, w10, uxtw #2]
    str w11, [x9, w10, uxtw #2]
    mov w11, #1
    add w10, w10, #1
    b .L.arrCopy.1
.L.arrCopy.1:
    adrp x13, n
    ldr w11, [x13, #:lo12:n]
    cmp w10, w11
    b.lt .L.arrCopy.2
.L.arrCopy.3:
    mov w8, #0
    mov w0, w8
    ldp x29, x30, [sp], #16
    ret

    .text
    .globl calSum
    .p2align 2
calSum:
.L.calSum.0:
    stp x29, x30, [sp, #-16]!
    mov x29, sp
    mov x12, x0
    mov w11, w1
    mov w8, #0
    mov w10, w8
    b .L.calSum.1
.L.calSum.5:
    str w15, [x12, w10, uxtw #2]
    mov w9, #0
    b .L.calSum.6
.L.calSum.6:
    mov w8, #1
    add w8, w10, #1
    mov w10, w8
    mov w8, w9
    b .L.calSum.1
.L.calSum.1:
    adrp x13, n
    ldr w9, [x13, #:lo12:n]
    cmp w10, w9
    b.ge .L.calSum.3
.L.calSum.2:
    ldr w9, [x12, w10, uxtw #2]
    add w15, w8, w9
    sdiv w14, w10, w11
    msub w9, w14, w11, w10
    mov w8, #1
    sub w8, w11, #1
    cmp w9, w8
    b.eq .L.calSum.5
.L.calSum.4:
    mov w8, #0
    str w8, [x12, w10, uxtw #2]
    mov w9, w15
    b .L.calSum.6
.L.calSum.3:
    mov w8, #0
    mov w0, w8
    ldp x29, x30, [sp], #16
    ret

    .text
    .globl avgPooling
    .p2align 2
avgPooling:
.L.avgPooling.0:
    stp x29, x30, [sp, #-16]!
    mov x29, sp
    sub sp, sp, #32
    str x19, [sp, #0]
    mov x11, x0
    mov w12, w1
    mov w10, #0
    mov w9, w10
    mov w15, w10
    b .L.avgPooling.1
.L.avgPooling.8:
    ldr w8, [x11, w15, uxtw #2]
    add w8, w10, w8
    sub w8, w8, w9
    sub w9, w15, w12
    mov w10, #1
    add w9, w9, #1
    ldr w10, [x11, w9, uxtw #2]
    sdiv w19, w8, w12
    str w19, [x11, w9, uxtw #2]
    mov w9, w10
    mov w10, w8
    b .L.avgPooling.9
.L.avgPooling.9:
    b .L.avgPooling.6
.L.avgPooling.6:
    mov w8, #1
    add w8, w15, #1
    mov w15, w8
    b .L.avgPooling.1
.L.avgPooling.1:
    adrp x13, n
    ldr w8, [x13, #:lo12:n]
    cmp w15, w8
    b.ge .L.avgPooling.3
.L.avgPooling.2:
    mov w8, #1
    sub w8, w12, #1
    cmp w15, w8
    b.ge .L.avgPooling.5
.L.avgPooling.4:
    ldr w8, [x11, w15, uxtw #2]
    add w8, w10, w8
    mov w10, w8
    b .L.avgPooling.6
.L.avgPooling.11:
    mov w8, #0
    str w8, [x11, w9, uxtw #2]
    mov w8, #1
    add w8, w9, #1
    mov w9, w8
    b .L.avgPooling.10
.L.avgPooling.10:
    adrp x13, n
    ldr w8, [x13, #:lo12:n]
    cmp w9, w8
    b.lt .L.avgPooling.11
.L.avgPooling.12:
    mov w8, #0
    mov w0, w8
    ldr x19, [sp, #0]
    add sp, sp, #32
    ldp x29, x30, [sp], #16
    ret
.L.avgPooling.5:
    mov w8, #1
    sub w8, w12, #1
    cmp w15, w8
    b.ne .L.avgPooling.8
.L.avgPooling.7:
    ldr w9, [x11]
    sdiv w8, w10, w12
    str w8, [x11]
    b .L.avgPooling.9
.L.avgPooling.3:
    adrp x13, n
    ldr w8, [x13, #:lo12:n]
    sub w8, w8, w12
    mov w9, #1
    add w9, w8, #1
    b .L.avgPooling.10

    .text
    .globl main
    .p2align 2
main:
.L.main.0:
    stp x29, x30, [sp, #-16]!
    mov x29, sp
    sub sp, sp, #288
    str x19, [sp, #0]
    mov w8, #32
    adrp x13, n
    str w8, [x13, #:lo12:n]
    mov x10, x29
    sub x10, x10, #128
    mov w8, #7
    str w8, [x10]
    mov x8, #4
    add x8, x10, x8
    mov w9, #23
    str w9, [x8]
    mov x8, #8
    add x8, x10, x8
    mov w9, #89
    str w9, [x8]
    mov x8, #12
    add x8, x10, x8
    mov w9, #26
    str w9, [x8]
    mov x8, #16
    add x8, x10, x8
    mov w9, #282
    str w9, [x8]
    mov x8, #20
    add x9, x10, x8
    mov w8, #254
    str w8, [x9]
    mov x8, #24
    add x9, x10, x8
    mov w8, #27
    str w8, [x9]
    mov x8, #28
    add x9, x10, x8
    mov w8, #5
    str w8, [x9]
    mov x8, #32
    add x9, x10, x8
    mov w8, #83
    str w8, [x9]
    mov x8, #36
    add x9, x10, x8
    mov w8, #273
    str w8, [x9]
    mov x8, #40
    add x8, x10, x8
    mov w9, #574
    str w9, [x8]
    mov x8, #44
    add x8, x10, x8
    mov w9, #905
    str w9, [x8]
    mov x8, #48
    add x8, x10, x8
    mov w9, #354
    str w9, [x8]
    mov x8, #52
    add x8, x10, x8
    mov w9, #657
    str w9, [x8]
    mov x8, #56
    add x8, x10, x8
    mov w9, #935
    str w9, [x8]
    mov x8, #60
    add x8, x10, x8
    mov w9, #264
    str w9, [x8]
    mov x8, #64
    add x8, x10, x8
    mov w9, #639
    str w9, [x8]
    mov x8, #68
    add x8, x10, x8
    mov w9, #459
    str w9, [x8]
    mov x8, #72
    add x8, x10, x8
    mov w9, #29
    str w9, [x8]
    mov x8, #76
    add x8, x10, x8
    mov w9, #68
    str w9, [x8]
    mov x8, #80
    add x8, x10, x8
    mov w9, #929
    str w9, [x8]
    mov x8, #84
    add x8, x10, x8
    mov w9, #756
    str w9, [x8]
    mov x8, #88
    add x8, x10, x8
    mov w9, #452
    str w9, [x8]
    mov x8, #92
    add x9, x10, x8
    mov w8, #279
    str w8, [x9]
    mov x8, #96
    add x9, x10, x8
    mov w8, #58
    str w8, [x9]
    mov x8, #100
    add x9, x10, x8
    mov w8, #87
    str w8, [x9]
    mov x8, #104
    add x9, x10, x8
    mov w8, #96
    str w8, [x9]
    mov x8, #108
    add x9, x10, x8
    mov w8, #36
    str w8, [x9]
    mov x8, #112
    add x9, x10, x8
    mov w8, #39
    str w8, [x9]
    mov x8, #116
    add x9, x10, x8
    mov w8, #28
    str w8, [x9]
    mov x8, #120
    add x9, x10, x8
    mov w8, #1
    str w8, [x9]
    mov x8, #124
    add x9, x10, x8
    mov w8, #290
    str w8, [x9]
    mov x0, x10
    mov x19, x29
    sub x19, x19, #256
    mov x1, x19
    bl arrCopy
    mov w8, w0
    mov x0, x19
    bl revert
    mov w8, w0
    mov w19, #0
    b .L.main.1
.L.main.20:
    mov x8, x29
    sub x8, x8, #256
    ldr w8, [x8, w19, uxtw #2]
    mov w0, w8
    bl putint
    mov w8, #1
    add w19, w19, #1
    b .L.main.19
.L.main.19:
    mov w8, #32
    cmp w19, w8
    b.lt .L.main.20
.L.main.21:
    mov w8, #0
    mov w0, w8
    ldr x19, [sp, #0]
    add sp, sp, #288
    ldp x29, x30, [sp], #16
    ret
.L.main.17:
    mov x8, x29
    sub x8, x8, #256
    ldr w8, [x8, w19, uxtw #2]
    mov w0, w8
    bl putint
    mov w8, #1
    add w19, w19, #1
    b .L.main.16
.L.main.16:
    mov w8, #32
    cmp w19, w8
    b.lt .L.main.17
.L.main.18:
    mov x8, x29
    sub x8, x8, #128
    mov x0, x8
    mov x19, x29
    sub x19, x19, #256
    mov x1, x19
    bl arrCopy
    mov w8, w0
    mov x0, x19
    mov w8, #3
    mov w1, w8
    bl avgPooling
    mov w8, w0
    mov w19, #0
    b .L.main.19
.L.main.14:
    mov x8, x29
    sub x8, x8, #256
    ldr w8, [x8, w19, uxtw #2]
    mov w0, w8
    bl putint
    mov w8, #1
    add w19, w19, #1
    b .L.main.13
.L.main.13:
    mov w8, #32
    cmp w19, w8
    b.lt .L.main.14
.L.main.15:
    mov x8, x29
    sub x8, x8, #128
    mov x0, x8
    mov x19, x29
    sub x19, x19, #256
    mov x1, x19
    bl arrCopy
    mov w8, w0
    mov x0, x19
    mov w8, #4
    mov w1, w8
    bl calSum
    mov w8, w0
    mov w19, #0
    b .L.main.16
.L.main.11:
    mov x8, x29
    sub x8, x8, #256
    ldr w8, [x8, w19, uxtw #2]
    mov w0, w8
    bl putint
    mov w8, #1
    add w19, w19, #1
    b .L.main.10
.L.main.10:
    mov w8, #32
    cmp w19, w8
    b.lt .L.main.11
.L.main.12:
    mov x8, x29
    sub x8, x8, #128
    mov x0, x8
    mov x19, x29
    sub x19, x19, #256
    mov x1, x19
    bl arrCopy
    mov w8, w0
    mov x0, x19
    mov w19, #0
    mov w1, w19
    mov w8, #31
    mov w2, w8
    bl QuickSort
    mov w8, w0
    b .L.main.13
.L.main.8:
    mov x8, x29
    sub x8, x8, #256
    ldr w8, [x8, w19, uxtw #2]
    mov w0, w8
    bl putint
    mov w8, #1
    add w19, w19, #1
    b .L.main.7
.L.main.7:
    mov w8, #32
    cmp w19, w8
    b.lt .L.main.8
.L.main.9:
    mov x8, x29
    sub x8, x8, #128
    mov x0, x8
    mov x19, x29
    sub x19, x19, #256
    mov x1, x19
    bl arrCopy
    mov w8, w0
    mov x0, x19
    bl insertsort
    mov w8, w0
    mov w19, #0
    b .L.main.10
.L.main.5:
    mov x8, x29
    sub x8, x8, #256
    ldr w8, [x8, w19, uxtw #2]
    mov w0, w8
    bl putint
    mov w8, #1
    add w8, w19, #1
    mov w19, w8
    b .L.main.4
.L.main.4:
    mov w8, #32
    cmp w19, w8
    b.lt .L.main.5
.L.main.6:
    mov x19, x29
    sub x19, x19, #256
    mov x0, x19
    bl getMid
    mov w8, w0
    mov w0, w8
    bl putint
    mov x0, x19
    bl getMost
    mov w8, w0
    mov w0, w8
    bl putint
    mov x8, x29
    sub x8, x8, #128
    mov x0, x8
    mov x1, x19
    bl arrCopy
    mov w8, w0
    mov x0, x19
    bl bubblesort
    mov w8, w0
    mov w19, #0
    b .L.main.7
.L.main.2:
    mov x8, x29
    sub x8, x8, #256
    ldr w8, [x8, w19, uxtw #2]
    mov w0, w8
    bl putint
    mov w8, #1
    add w8, w19, #1
    mov w19, w8
    b .L.main.1
.L.main.1:
    mov w8, #32
    cmp w19, w8
    b.lt .L.main.2
.L.main.3:
    mov x8, x29
    sub x8, x8, #256
    mov x0, x8
    bl bubblesort
    mov w8, w0
    mov w19, #0
    b .L.main.4