.global main, Stop, CodeEnd, DataStart, DataEnd

        .global x, y, z, i, j, k, head

	.global pause1, pause2, pause3, alert
	.text
main:
     /* ***********************************
        Get z[ x[k] ] in register r10
	*********************************** */
     // Get byte k
     movw   r0, #:lower16:k
     movt   r0, #:upper16:k       // r0 = addr(k)
     ldrsb  r0, [r0]              // r0 = k    

     // Get int x[k]
     movw   r1, #:lower16:x
     movt   r1, #:upper16:x       // r1 = base address of (int) array x

     add    r0, r0, r0            // r0 = 2k
     add    r0, r0, r0            // r0 = 4k (= offset to x[i])
     ldr    r0, [r1,r0]           // r0 = x[k]    

     // Get byte z[ x[k] ] = z[ r0 ]
     movw   r1, #:lower16:z
     movt   r1, #:upper16:z       // r1 = base address of (byte) array z

     ldrsb  r10, [r1,r0]          // r10 = z[ x[k] ]

pause1:

     /* ***********************************
        Get head.value1 in register r9
	*********************************** */
     // Get pointer head
     movw   r0, #:lower16:head
     movt   r0, #:upper16:head   // r0 = addr(head)
     ldr    r0, [r0]             // r0 = head

     // Get int head.value1
     ldr    r9, [r0, #0]         // r9 = head.value1

pause2:

     add    r10, r10, r9         // r10 = z[ x[ k ] ] + head.value1 

     /* *************************************
        Get head.next.value3 in register r9
	************************************* */
     // Get pointer head
     movw   r0, #:lower16:head
     movt   r0, #:upper16:head   // r0 = addr(head)
     ldr    r0, [r0]             // r0 = head

     // Get pointer head.next
     ldr    r0, [r0, #8]         // r0 = head.next

     // Get short head.next.value3
     ldrsh  r9, [r0, #6]         // r9 = head.next.value3

pause3:

     add    r10, r10, r9         // r10 = z[x[k]]+head.value1+head.next.value3     

     /* *************************************
        Store r10 in y[i + j]
	************************************* */
     // Get int i 
     movw   r0, #:lower16:i
     movt   r0, #:upper16:i      // r0 = addr(i)
     ldr    r0, [r0]             // r0 = i

     // Get short j 
     movw   r1, #:lower16:j
     movt   r1, #:upper16:j      // r1 = addr(j)
     ldrsh  r1, [r1]             // r1 = j

     // Compute i+j
     add    r0, r0, r1           // r0 = r0 + r1

     // Get address of short y[i + j]   (base = y, offset = 2*(i+j)
     movw   r1, #:lower16:y
     movt   r1, #:upper16:y      // r1 = base address of array y

     add    r0, r0, r0           // r0 = 2*(i+j)  (offset)
                                 // Address of short y[i+j] is ready !!!

alert:
     // Store r10 in y[i+j]
     strh   r10, [r1, r0]        // Stores r10 in base address + offset
				 // If you use "str", you will ALSO update
				 // y[4] !!! (y[4] will be 0, can you explain ?)

Stop:
	nop
CodeEnd:


/* **************************************************************
   Permanent variables
   ************************************************************** */

        .data
DataStart:

x:	.4byte       1, 5, 6, 8, 2, 7, 9, 3, 4, 0
y:	.2byte       3, 6, 9, 2, 4, 7, 8, 5, 0, 1
z:	.byte        5, 6, 8, 2, 0, 4, 1, 9, 7, 3

	.align 2

i:	.4byte 1
j:	.2byte 2
k:	.byte  3

	.align 2
head:   .word p0        // head contains the address of the first list elem
                        // head->[111,21,31]->[222,22,32]->[333,23,33]->
                        //     ->[444,24,34]->[555,25,35]

// list structure is: [int value1, short value2, short value3, next]

p0: .4byte  111         // p0 contains [111,21,31,p3]
    .2byte  21, 31
    .4byte  p1
p1: .4byte  333         // p1 contains [333,23,33,0]
    .2byte  23, 33
    .4byte  0

DataEnd:

	.end