Q1:

QuickSort:

	push	{lr}
	push	{fp}
	mov	fp, sp
	sub	sp, sp, #12

	// n1 < n2
	ldr	r0, [fp,#12] 
	ldr	r1, [fp,#16] 
	cmp	r0, r1
	bge	ifEnd

	// pivot = X[n2]
	ldr     r0, [fp,#8]
	ldr	r1, [fp,#16] 
	add	r1, r1, r1
	add	r1, r1, r1
	ldr     r0, [r0,r1]
	str	r0, [fp,#-12]

	// right_array_spot = n2;
	ldr     r1, [fp,#16]
	str	r1, [fp,#-4]

	// curr = n1
	ldr     r1, [fp,#12]
	str	r1, [fp,#-8]

while:
	// curr != right_array_spot
	ldr     r0, [fp,#-8]
	ldr     r1, [fp,#-4]
	cmp	r0, r1
	beq 	whileEnd

	// if (X[curr] <= pivot)
	ldr     r0, [fp,#8]
        ldr     r1, [fp,#-8]
        add     r1, r1, r1
        add     r1, r1, r1
	ldr     r0, [r0,r1]
	ldr	r1, [fp,#-12]
	cmp	r0, r1
	bgt	else

	// curr++
        ldr     r1, [fp,#-8]
	add	r1, r1, #1
        str     r1, [fp,#-8]

	b	ifEnd2

else:
	// X[right_array_spot] = X[curr];
	ldr     r0, [fp,#8]

	ldr     r1, [fp,#-8]
        add     r1, r1, r1
        add     r1, r1, r1
        ldr     r1, [r0,r1]

        ldr     r2, [fp,#-4]
        add     r2, r2, r2
        add     r2, r2, r2
        str     r1, [r0,r2]

        // X[curr] = X[right_array_spot-1];
        ldr     r0, [fp,#8]

        ldr     r1, [fp,#-4]
	sub	r1, r1, #1
        add     r1, r1, r1
        add     r1, r1, r1
        ldr     r1, [r0,r1]

        ldr     r2, [fp,#-8]
        add     r2, r2, r2
        add     r2, r2, r2
        str     r1, [r0,r2]

	// right_array_spot--;
        ldr     r1, [fp,#-4]
	sub	r1, r1, #1
        str     r1, [fp,#-4]

ifEnd2:
	b	while

whileEnd:
	// X[curr] = pivot;
	ldr     r0, [fp,#-12]

        ldr     r1, [fp,#8]
        ldr     r2, [fp,#-8]
        add     r2, r2, r2
        add     r2, r2, r2
	str	r0, [r1, r2]

	// QuickSort(X, n1, curr-1);
	ldr     r0, [fp,#-8]
	sub	r0, r0, #1
	push	{r0}
	ldr     r0, [fp,#12]
	push	{r0}
	ldr     r0, [fp,#8]
	push	{r0}
	bl	QuickSort
	add	sp, sp, #12

        // QuickSort(X, curr+1, n2);
        ldr     r0, [fp,#16]
        push    {r0}
        ldr     r0, [fp,#-8]
        add	r0, r0, #1
        push    {r0}
        ldr     r0, [fp,#8]
        push    {r0}
        bl      QuickSort
        add     sp, sp, #12

ifEnd:
	mov     sp, fp
	pop	{fp}
	pop	{pc}

===============================================================

Q2:

	// sum = 0
	mov	r0, #0
	movw	r1, #:lower16:sum
	movt	r1, #:upper16:sum
	str	r0, [r1]

	// ptr = head
	movw	r0, #:lower16:head
	movt	r0, #:upper16:head
	ldr	r0, [r0]
	movw	r1, #:lower16:ptr
	movt	r1, #:upper16:ptr
	str	r0, [r1]

while:
	// if (ptr != null)
	movw	r0, #:lower16:ptr
	movt	r0, #:upper16:ptr
	ldr	r0, [r0]
	cmp	r0, #0
	beq	whileEnd

	// sum = sum + ptr.v1 + ptr.v2;
        movw    r0, #:lower16:sum
        movt    r0, #:upper16:sum
        ldr     r0, [r0]

	movw    r1, #:lower16:ptr
        movt    r1, #:upper16:ptr
        ldr     r1, [r1]
        ldr     r1, [r1,#4]
	add	r0, r0, r1

        movw    r1, #:lower16:ptr
        movt    r1, #:upper16:ptr
        ldr     r1, [r1]
        ldr     r1, [r1,#8]
        add     r0, r0, r1

        movw    r1, #:lower16:sum
        movt    r1, #:upper16:sum
        str     r0, [r1]

	// ptr = ptr.next
        movw    r0, #:lower16:ptr
        movt    r0, #:upper16:ptr  
        ldr     r1, [r0]
	ldr	r1, [r1, #0]
        str     r1, [r0]

	b	while

whileEnd:

=====================================================================

Q3:

GCD:
        push    {lr}
        push    {fp}
        mov     fp, sp
        sub     sp, sp, #0

	// if (y==x)
	ldr	r0, [fp, #12]
	ldr	r1, [fp, #8]
	cmp	r0, r1
	bne	else

	// return(x)
	ldr	r0, [fp, #8]
	b	postLude

else:
while:
	// if (x > y)
	ldr	r0, [fp, #8]
	ldr	r1, [fp, #12]
	cmp	r0, r1 
	ble	whileEnd

	// x = x - y
	ldr     r0, [fp, #8]
	ldr     r1, [fp, #12]
	sub	r0, r0, r1
	str     r0, [fp, #8]

	b	while

whileEnd:
	// return GCD(y, x)
        ldr     r0, [fp, #8]
	push	{r0}
        ldr     r0, [fp, #12]
	push	{r0}
	bl	GCD
	add	sp, sp, #8

postLude:
        mov     sp, fp
        pop     {fp}
        pop     {pc}

========================================================

Q4:
	(1) no error
	(2) no error
	(3) no error
	(4) error, a defined multiple times
	(5) no error
	(6) error, b is static global
	(7) error, a not declared

=========================================================

Q5:

   struct List *insertList( struct List *head, struct List *elem )
   {
      if ( head == NULL )
      {
         elem->next = NULL;     // Mark elem as the last list elem
         return(elem);          // elem is the first list elem !
      }
      else if ( elem->value <= head->value )
      {
         elem->next = head;
         return(elem);          // elem is the first list elem !
      }
      else
      {
         head->next = insertList( head->next, elem ); 
         return head;
      }
   }