This is aarch64 assembly language program. Write sum_array function recursively.
Here is the code:
.section .rodata
    getnstr: .string "Enter a value of n: "
    .align 3
    origstr: .string "The original array is:\n"
    .align 3
    dupstr: .string "\n\nThe sorted duplicate array is:\n"
    .align 3
    dupstr2: .string "\n\nThe average of the duplicate array is: "
    intstr: .string "%d"
    .align 3
    tab10dintstr: .string "%5d"
    .align 3
    nlstr: .string "\n"
    .align 3


.section .bss
	n: .skip 4
	n16: .skip 4

.section .text
.global main
.type main, @function

main:
	stp x29, x30, [sp, #-16]! // main prolog
	
	// Generate a seed to be used by srand and set the seed for the random number generator
	mov x0, 0
	bl time
	bl srand
	
	// prompt the user to enter their TCU id number
	ldr x0, =getnstr
	bl printf
	ldr x0, =intstr
	ldr x1, =n
	bl scanf
	
	// Check if the TCU id number is even
	ldr x0, =n
	and x0, x0, #1
	cmp x0, #0
	beq even
	
	mov x0, #33
	ldr x1, =n
	str x0, [x1]
	b endgetnstr

even:
	mov x0, #42
	ldr x1, =n
	str x0, [x1]
	
endgetnstr:
	// compute next highest multiple of 16 that is bigger or equal to n
	adr x1, n
	ldr w1, [x1]
	sbfiz x1, x1, #2, #20
	add x1, x1, #0xf
	and x1, x1, #0xfffffffffffffff0
	adr x2, n16
	str w1, [x2]
	
	// create the storage for “n” integers (namely orig array) on stack pointer
	sub sp, sp, x1
	
	// call init_array
	mov x0, sp // move address of orig array to x0
	bl init_array
	
	// print orig array
	ldr x0, =origstr
	bl printf
	mov x0, sp
	bl print_array
	
	// create the storage for “n” integers (namely dup array) on stack pointer
	adr x2, n16
	ldr w2, [x2]
	sub sp, sp, x2
	
	// call copy_array
	mov x0, sp // address of dup array
	add x1, sp, x2 // address of orig array
	bl copy_array
	
	// call insertion_sort
	mov x0, sp // address of dup array
	bl insertion_sort
	
	// print dup array
	ldr x0, =dupstr
	bl printf
	mov x0, sp
	bl print_array
	ldr x0, =nlstr
	bl printf
	
	// call compute_average
	ldr x0, =dupstr2
	bl printf
	mov x0, sp // address of dup array
	bl compute_average
	
	// print out the average to standard output
	ldr x0, =intstr
	bl printf

	// restore storage for “n” integers (namely dup array) on stack pointer
	adr x1, n16
	ldr x1, [x1]
	add sp, sp, x1
	
	// restore storage for “n” integers (namely orig array) on stack pointer
	adr x1, n16
	ldr x1, [x1]
	add sp, sp, x1
	
	ldp x29, x30, [sp], #16 // main epilog
	mov x0, #0
	ret

.type init_array, @function
init_array:
	stp x29, x30, [sp, #-16]! //function prolog
	
	mov x19, #0 // loop counter
	ldr x20, =n
	ldr w20, [x20]
	mov x21, x0
	
loop1:
	cmp x19, x20
	bge endloop1
	
	// save random value to sp array
	bl rand
	and w0, w0, #255
	str w0, [x21, x19, lsl 2]
	
	add x19, x19, #1
	b loop1

endloop1:
	ldp x29, x30, [sp], #16 //function epilog
	ret

.type print_array, @function
print_array:
	stp x29, x30, [sp, #-16]! //function prolog
	
	mov x19, #0 // loop counter
	ldr x20, =n
	ldr w20, [x20]
	mov x21, x0
	
loop2:
	// restore x1, x2 from sp
	cmp x19, x20
	bge endloop2
	
	ldr x0, =tab10dintstr
	ldr w1, [x21, x19, lsl 2]
	bl printf
	
	add x19, x19, #1
	
	// check if x19 is multiple of 5, if yes print nlstr
	mov x22, #5
	sdiv x23, x19, x22
	mul x24, x23, x22
	cmp x24, x19
	bne continue_loop2
	ldr x0, =nlstr
	bl printf

continue_loop2:
	b loop2

endloop2:
	ldp x29, x30, [sp], #16 //function epilog
	ret


.type copy_array, @function
copy_array:
	stp x29, x30, [sp, #-16]! //function prolog
	
	mov x19, #0 // loop counter
	ldr x20, =n
	ldr w20, [x20]
	    mov x21, x1 // address of orig array
    mov x22, x0 // address of dup array
    
loop3:
    cmp x19, x20
    bge endloop3
    
    ldr w23, [x21, x19, lsl 2] // load value from orig array
    str w23, [x22, x19, lsl 2] // store value to dup array
    
    add x19, x19, #1
    b loop3
    
endloop3:
	ldp x29, x30, [sp], #16 //function epilog
	ret

.type compute_average, @function
compute_average:
	stp x29, x30, [sp, #-16]! //function prolog
	
	mov x19, #0 // loop counter
	ldr x20, =n
	ldr w20, [x20]
	mov x21, x0 // address of dup array
	
	mov x1, #0 // startidx = 0
	mov x2, x20 // stopidx = n
	bl sum_array
	mov x22, x0 // put result of sum_array

endloop4:
	udiv x1, x22, x20
	ldp x29, x30, [sp], #16 //function epilog
	ret

.type sum_array, @function
sum_array:
stp x29, x30, [sp, #-16]! //function prolog

// x0 has address of dup array
// x1 has startidx
// x2 has stopidx

ldp x29, x30, [sp], #16 //function epilog
ret

.type insertion_sort, @function
insertion_sort:
stp x29, x30, [sp, #-16]! // function prolog
mov x29, sp

ldr x20, =n
ldr w20, [x20] // n

// for i = 1 to n-1
mov x19, #1
outer_loop:

cmp x19, x20
bge end_outer_loop

mov x23, x19
ldr w22, [x0, x23, lsl 2] // key = array[i]

// for j = i-1; j >= 0 and array[j] > key
sub x24, x19, #1
inner_loop:
cmp x24, #0
blt end_inner_loop

ldr w25, [x0, x24, lsl 2] // array[j]
cmp w25, w22
bls end_inner_loop

// array[j+1] = array[j]
add x26, x24, #1
str w25, [x0, x26, lsl 2]
sub x24, x24, #1
b inner_loop

end_inner_loop:
add x27, x24, #1
str w22, [x0, x27, lsl 2] // array[j+1] = key

add x19, x19, #1
b outer_loop

end_outer_loop:
ldp x29, x30, [sp], #16 // function epilog
ret