Test Programs

Test Programs

1. Calculate the sum of an integer array
2. Calculate the multiplication of two integers
3. Sort an integer array
4. Binary search
5. Check whether an integer array is a palindrome.

Test Program 1: Calculate the sum of aninteger array

##############

# Register map

##############

# $s0 --> Sum of the array

# $t0 --> Address of the integer array

##############

.data#following words in data segment

A: .word 1 2 3 4 5 6 7 8 9 10 0 #array of 10 words in location A

.globl main#define global label main

.text#text segment begins here

main:

la $t0, A#load address of A in $t0

add $s0, $zero, $zero#s0 = 0

loop:

lw $t2, 0($t0)#$t2 = Mem[$t0 + 0]

add $s0, $s0, $t2#$s0 = $s0 + $t2

addi $t0, $t0, 4#$t0 = $t0 + 4

bne $t2, $zero, loop#if ($t2 != 0) goto loop

nop#else do nothing

exit:beq $0, $0, exit#program stops here

nop

Instruction Segment

Address / Code / Basics / Sources
0x00400000 / 0x3c011001 / lui $1, 4097 / 15: lla $t0, A #load address of A in $t0
0x00400004 / 0x34280000 / ori $8, $1, 0
0x00400008 / 0x00008020 / add $16, $0, $0 / 16: add $s0, $zero, $zero #s0 = 0
0x0040000c / 0x8d0a0000 / lw $10, 0($8) / 19: lw $t2, 0($t0) #$t2 = Mem[$t0 + 0]
0x00400010 / 0x020a8020 / add $16, $16, $10 / 20: add $s0, $s0, $t2 #$s0 = $s0 + $t2
0x00400014 / 0x21080004 / addi $8, $8, 4 / 21: addi $t0, $t0, 4 #$t0 = $t0 + 4
0x00400018 / 0x1540fffd / bne $10, $0, -3 / 22: bne $t2, $zero, loop #if ($t2 != 0) goto loop
0x0040001c / 0x00000000 / nop / 23: nop
0x00400020 / 0x10000000 / beq $0, $0, 0 / 26: exit: beq $0, $0, exit #program stops here
0x00400024 / 0x00000000 / nop / 27: nop

Data Segment

Address / Value
0x10010000 / 0x00000001
0x10010004 / 0x00000002
0x10010008 / 0x00000003
0x1001000c / 0x00000004
0x10010010 / 0x00000005
0x10010014 / 0x00000006
0x10010018 / 0x00000007
0x1001001c / 0x00000008
0x10010020 / 0x00000009
0x10010024 / 0x0000000a
0x10010028 / 0x00000000

Test Program 2: Integer Multiplication

##############

# Register map

##############

# $t1 --> multiplicand

# $t2 --> multiplier

# $v0 --> product

# $v1 --> cycle counter

# $t4 --> temporary storage

# $t5 --> loop counter (counts to 16)

##############

.text

.globl main

main:

la $t0, para# load address of A in $t0

lw $t1, 0($t0)# multiplicand ->$t1

lw $t2, 4($t0)# multiplier->$t2

add $v0, $0, $0# Initialize the product to 0

add $t5, $0, $0# initialize loop counter

add $v1, $0, 4# initialize cycle counter, not contribute to multiply

Loop:

and $t4, $t2, 1# And operation, the least significant bit to $t4

beq $t4, 0, skip_add# check least significant bit

nop

addi $v1, $v1, 1

add $v0, $v0, $t1# add multiplicand

skip_add:

srl $t2, $t2, 1# shift multiplier right one bit

sll $t1, $t1, 1# shift multiplicand left one bit

addi $t5, $t5, 1# loop counter increment by 1

addi $v1, $v1, 8

bne $t5, 16, Loop# goto Loop

nop

addi $v1, $v1, 2

exit:beq $0, $0, exit#program stops here

nop

# Data segment

##############

.data

para:.word 4, 4

Instruction Segment

Address / Code / Basics / Sources
0x00400000 / 0x3c011001 / lui $0,4097 / 16: la $t0, para # load address of A in $t0
0x00400004 / 0x34280000 / ori $8,$1,0
0x00400008 / 0x8d090000 / lw $9,0($8) / 17: lw $t1, 0($t0) # multiplicand ->$t1
0x0040000c / 0x8d0a0004 / lw,$10,4($8) / 18: lw $t2, 4($t0) # multiplier->$t2
0x00400010 / 0x00001020 / add $2,$0,$0 / 20: add $v0, $0, $0 # Initialize the product to 0
0x00400014 / 0x00006820 / add $13,$0,$0 / 21: add $t5, $0, $0 # initialize loop counter
0x00400018 / 0x20030004 / addi $3,$0,4 / 22: add $v1, $0, 4 # initialize cycle counter
0x0040001c / 0x314c0001 / andi $12,$10,1 / 24: and $t4, $t2, 1 # and operation
0x00400020 / 0x34010000 / ori $1,$0,0 / 25: beq $t4, 0, skip_add # check least significant bit
0x00400024 / 0x102c0004 / beq $1,$12,4
0x00400028 / 0x00000000 / nop / 26: nop
0x0040002c / 0x20630001 / addi $3,$3,1 / 27: addi $v1, $v1, 1 (Branch Delay Slot)
0x00400030 / 0x00491020 / add $2,$2,$9 / 28: add $v0, $v0, $t1 # add multiplicand
0x00400034 / 0x000a5042 / srl $10,$10,1 / 29: srl $t2, $t2, 1 # shift multiplier right one bit
0x00400038 / 0x00094840 / sll $9,$9,1 / 30: sll $t1, $t1, 1 # shift multiplicand left one bit
0x0040003c / 0x21ad0001 / addi $13,$13,1 / 31: addi $t5, $t5, 1 # loop counter increment by 1
0x00400040 / 0x20630008 / addi $3,$3,8 / 32: addi $v1, $v1, 8
0x00400044 / 0x34010010 / ori $1,$0,16 / 33: bne $t5, 16, Loop # goto Loop
0x00400048 / 0x142dfff5 / bne $1,$13,-11
0x0040004c / 0x00000000 / nop / 34: nop
0x00400050 / 0x20630002 / addi $3,$3,2 / 35: addi $v1, $v1, 2 (Branch Delay Slot)
0x00400054 / 0x10000000 / beq $0, $0, 0 / 39: exit: beq $0, $0, exit #program stops here
0x00400058 / 0x00000000 / noop / 40: nop

Data Segment

Address / Value
0x10010000 / 0x00000004
0x10010004 / 0x00000004

Test Program 3: Bubble Sort

##############

# Register map

##############

# $a1 --> Size of the array

# $a0 --> Address of the original array

# $t0 --> Address of sorted array

# bub_sort: Implement bubble sort

##############

.data#Data Section

iArray:.word 1 9 2 8 5 6 7

.text#Code Section

main:

addu $s0, $0, $ra#save return address

li $s1, 7#$s1 <-- array size to $s1

#Pass Parameters and Call Procedure

la $a0, iArray#load base address to $a0

addu $a1, $s1, $0#move size to $a1

jal bub_sort#Sorted array starts at $t0

exit:beq $0, $0, exit#program stops here

nop

bub_sort:

#begin your code

#$s0 and $s1 are forbidden to use.

addu $t4, $a1, $0#move $a1 to $t4

loop3:#outer loop

addu $t1, $t4, $0#Inner loop size

addu $t0, $a0, $0#move $a0 to $t0

loop4:

lw $t2, 0($t0)#$t2=A[i]

lw $t3, 4($t0)#$t3=A[i+1]

ble $t2, $t3, skip1#test for swapping memory elements

nop#delay slot

sw $t2, 4($t0)

sw $t3, 0($t0)#Completes Swap

skip1:

addi $t0, $t0, 4#update current address of A[i]

lw $t2, 0($t0)#update A[i]

addi $t1, $t1, -1#Size decremented by 1

bne $t1, 1, loop4#If not done, goto loop4

nop#delay slot

addi $t4, $t4, -1#outer loop size decreases

bne $t4, 1, loop3#test,if not goto loop3

nop

addu $t0, $a0, $0#Load base address

addu $t1, $a1, $0#load size of array

sll $t1, $t1, 2#size*4

add $t1, $t0, $t1#End address of the array

lw $v0, -4($t1)#Load Maximum to $v0

#Epilogue

jr $ra#Return to the caller

nop

Instruction Segment

Address / Code / Basics / Sources
0x00400000 / 0x001f8021 / addu $16, $0, $31 / 17: addu $s0, $0, $ra #save return address
0x00400004 / 0x3c010000 / lui $1,0 / 19: li $s1, 7 #$s1 <-- array size to $s1
0x00400008 / 0x34310007 / ori $17,$1,7
0x0040000c / 0x3c011001 / lui $1,4097 / 22: la $a0, iArray #load base address to $a0
0x00400010 / 0x34240000 / ori $4,$1,0
0x00400014 / 0x02202821 / addu $5,$17,$0 / 23: addu $a1, $s1, $0 #move size to $a1
0x00400018 / 0x0c10000b / jal 4194348 / 24: jal bub_sort #Sorted array starts at $t0
0x0040001c / 0x00000000 / nop / 25: nop
0x00400020 / 0x0200f821 / addu $31,$16,0 / 27: addu $ra, $s0, $0 #restore return address
0x00400024 / 0x10000000 / beq $0, $0, 0 / 28: exit: beq $0, $0, exit #program stops here
0x00400028 / 0x00000000 / nop / 29: nop
0x0040002c / 0x00a06021 / addu $12,$5,$0 / 35: addu $t4, $a1, $0 #move $a1 to $t4
0x00400030 / 0x01804821 / addu $9,$12,$0 / 36: addu $t1, $t4, $0 #Inner loop size
0x00400034 / 0x00804021 / addu $8,$4,$0 / 38: addu $t0, $a0, $0 #move $a0 to $t0
0x00400038 / 0x8d0a0000 / lw $10,0($8) / 40: lw $t2, 0($t0) #$t2=A[i]
0x0040003c / 0x8d0b0004 / lw,$11,4($8) / 41: lw $t3, 4($t0) #$t3=A[i+1]
0x00400040 / 0x016a082a / slt $1,$11,10 / 42: ble $t2, $t3, skip1 #test for swapping elements
0x00400044 / 0x10200004 / beq $1,$0,4
0x00400048 / 0x00000000 / nop / 43: nop #delay slot
0x0040004c / 0xad0a0004 / sw $10,4($8) / 44: sw $t2, 4($t0)
0x00400050 / 0xad0b0000 / sw $11,0($8) / 45: sw $t3, 0($t0) #Completes Swap
0x00400054 / 0x21080004 / addi $8,$8,4 / 47: addi $t0, $t0, 4 #update current address of A[i]
0x00400058 / 0x8d0a0000 / lw $10,0($8) / 48: lw $t2, 0($t0) #update A[i]
0x0040005c / 0x2129ffff / addi $9,$9,-1 / 49: addi $t1, $t1, -1 #Size decremented by 1
0x00400060 / 0x34010001 / ori $1,$0,1 / 50: bne $t1, 1, loop4 #If not done, goto loop4
0x00400064 / 0x1429fff5 / bne $1,$9,-11
0x00400068 / 0x00000000 / nop / 51: nop #delay slot
0x0040006c / 0x218cffff / addi $12,$12,-1 / 52: addi $t4, $t4, -1 #outer loop size decreases
0x00400070 / 0x34010001 / ori $1,$0,1 / 53: bne $t4, 1, loop3 #test,if not goto loop3
0x00400074 / 0x142cffef / bne $1,$12,-17
0x00400078 / 0x00000000 / nop / 54: nop #delay slot
0x0040007c / 0x00804021 / addu $8,$4,$0 / 56: addu $t0, $a0, $0 #Load base address
0x00400080 / 0x00a04821 / addu $9,$5,$0 / 57: addu $t1, $a1, $0 #load size of array
0x00400084 / 0x00094880 / sll $9,$9,2 / 58: sll $t1, $t1, 2 #size*4
0x00400088 / 0x01094820 / add $9,$8,$9 / 59: add $t1, $t0, $t1 #End address of the array
0x0040008c / 0x8d22fffc / lw $2,-4($9) / 60: lw $v0, -4($t1) #Load Maximum to $v0
0x00400090 / 0x03e00008 / jr $31 / 63: jr $ra #Return to the caller
0x00400094 / 0x00000000 / nop / 64: nop #delay slot

Data Segment

Address / Value
0x10010000 / 0x00000001
0x10010004 / 0x00000009
0x10010008 / 0x00000002
0x1001000c / 0x00000008
0x10010010 / 0x00000005
0x10010014 / 0x00000006
0x10010018 / 0x00000007
0x1001001c / 0x00000000

Test Program 4: Binary Search

.data

first: # sorted array of 32 bit words

.word 2, 3, 8, 10, 16, 21, 35, 42, 43, 50, 64, 69

.word 70, 77, 82, 83, 84, 90, 96, 99, 100, 105, 111, 120

last: # address just after sorted array

.text

.globl main

main:

# binary search in sorted array

# input: search value (needle) in $a0

# base address of array in $a1

# last address of array in $a2

# output: address of needle in $v0 if found,

# 0 in $v0 otherwise

li $a0, 42 # needle value

la $a1, first # address of first array entry

la $a2, last# address of last array entry

addi $a2, $a2, -4

jal binsearch # perform binary search

nop

exit:beq $0, $0, exit#program stops here

nop

binsearch:

addi $sp, $sp, -4 # allocate 4 bytes on stack

sw $ra, 4($sp) # save return address on stack

subu $t0, $a2, $a1 # $t0 <- size of array

bnez $t0, search # if size > 0, continue search

nop

move $v0, $a1 # address of only entry in array

lw $t0, ($v0) # load the entry

beq $a0, $t0, return # equal to needle value? yes => return

nop

li $v0, 0 # no => needle not in array

j return # done, return

nop

search:

srl $t0, $t0, 3 # compute offset of middle entry m:

sll $t0, $t0, 2 # $t0 <- ($t0 / 8) * 4

addu $v0, $a1, $t0 # compute address of middle entry m

lw $t0, ($v0) # $t0 <- middle entry m

beq $a0, $t0, return # m = needle? yes => return

nop

blt $a0, $t0, go_left # needle less than m? yes =>

nop# search continues left of m

go_right:

addi $a1, $v0, 4 # search continues right of m

jal binsearch # recursive call

nop

j return # done, return

nop

go_left:

move $a2, $v0 # search continues left of m

jal binsearch # recursive call

nop

return:

lw $ra, 4($sp) # recover return address from stack

addi $sp, $sp, 4 # release 4 bytes on stack

#j $ra # return to caller

Instruction Segment

Address / Code / Basics / Sources
0x00400000 / 0x3c010000 / lui $1,0 / 18: li $a0, 42 # needle value
0x00400004 / 0x3424002a / ori $4,$1,42
0x00400008 / 0x3c011001 / lui $1,4097 / 19: la $a1, first # address of first array entry
0x0040000c / 0x34250000 / ori $5,$1,0
0x00400010 / 0x3c011001 / lui $1,4097 / 20: la $a2, last # address of last array entry
0x00400014 / 0x34260060 / ori $6,$1,96
0x00400018 / 0x20c6fffc / addi $6,$6,-4 / 21: addi $a2, $a2, -4
0x0040001c / 0x0c10000b / jal 4194348 / 22: jal binsearch# perform binary search
0x00400020 / 0x00000000 / nop / 23: nop
0x00400024 / 0x10000000 / beq $0, $0, 0 / 24: exit: beq $0, $0, exit #program stops here
0x00400028 / 0x00000000 / nop / 25: nop
0x0040002c / 0x23bdfffc / addi $29,$29,-4 / 28: addi $sp, $sp, -4 # allocate 4 bytes on stack
0x00400030 / 0xafbf0004 / sw $31,4($29) / 29: sw $ra, 4($sp) # save return address on stack
0x00400034 / 0x00c54023 / subu $8,$6,$5 / 31: subu $t0, $a2, $a1 # $t0 <- size of array
0x00400038 / 0x1500000a / bne $8,$0,10 / 32: bnez $t0, search # if size > 0, continue search
0x0040003c / 0x00000000 / nop / 33: nop
0x00400040 / 0x00051021 / addu $2,$0,$5 / 34: move $v0, $a1 # address of only entry in array
0x00400044 / 0x8c480000 / lw $8,0($2) / 35: lw $t0, ($v0) # load the entry
0x00400048 / 0x10880017 / beq $4,$8,23 / 36: beq $a0, $t0, return # equal to needle value?
0x0040004c / 0x00000000 / nop / 37: nop
0x00400050 / 0x3c010000 / lui $1,0 / 38: li $v0, 0 # no => needle not in array
0x00400054 / 0x34220000 / ori $2,$1,0
0x00400058 / 0x08100029 / j 4194468 / 39: j return # done, return
0x0040005c / 0x00000000 / nop / 40: nop
0x00400060 / 0x000840c2 / srl $8,$8,3 / 43: srl $t0, $t0, 3 # compute offset of middle entry m:
0x00400064 / 0x00084080 / sl1 $8,$8,2 / 44: sll $t0, $t0, 2 # $t0 <- ($t0 / 8) * 4
0x00400068 / 0x00a81021 / addu $2,$5,$8 / 45: addu $v0, $a1, $t0 # compute middle entry m
0x0040006c / 0x8c480000 / lw $8,0($2) / 46: lw $t0, ($v0) # $t0 <- middle entry m
0x00400070 / 0x1088000d / beq $4,$8,13 / 47: beq $a0, $t0, return # m = needle? yes => return
0x00400074 / 0x00000000 / nop / 48: nop
0x00400078 / 0x0088082a / slt $1,$4,$8 / 49: blt $a0, $t0, go_left # needle less than m?
0x0040007c / 0x14200007 / bne $1,$0,7
0x00400080 / 0x00000000 / nop / 50: nop
0x00400084 / 0x20450004 / addi $5,$2,4 / 53: addi $a1, $v0, 4 # search continues right of m
0x00400088 / 0x0c10000b / jal 4194338 / 54: jal binsearch # recursive call
0x0040008c / 0x00000000 / nop / 55: nop
0x00400090 / 0x08100029 / j 4194468 / 56: j return # done, return
0x00400094 / 0x00000000 / nop / 57: nop
0x00400098 / 0x00023021 / addu $6,$0,$2 / 60: move $a2, $v0 # search continues left of m
0x0040009c / 0x0c10000b / jal 4194348 / 61: jal binsearch # recursive call
0x004000a0 / 0x00000000 / nop / 62: nop
0x004000a4 / 0x8fbf0004 / lw $31,4($29) / 65: lw $ra, 4($sp) #recover return address from stack
0x004000a8 / 0x23bd0004 / addi $29,$29,4 / 66: addi $sp, $sp, 4 # release 4 bytes on stack

Data Segment

Address / Value
0x10010000 / 0x00000002
0x10010004 / 0x00000003
0x10010008 / 0x00000008
0x1001000c / 0x0000000a
0x10010010 / 0x00000010
0x10010014 / 0x00000015
0x10010018 / 0x00000023
0x1001001c / 0x0000002a
0x10010020 / 0x0000002b
0x10010024 / 0x00000032
0x10010028 / 0x00000040
0x1001002c / 0x00000045
0x10010030 / 0x00000046
0x10010034 / 0x0000004d
0x10010038 / 0x00000052
0x1001003c / 0x00000053
0x10010040 / 0x00000054
0x10010044 / 0x0000005a
0x10010048 / 0x00000060
0x1001004c / 0x00000063
0x10010050 / 0x00000064
0x10010054 / 0x00000069
0x10010058 / 0x0000006f
0x1001005c / 0x00000078

Test Program 5: Check whether an integer array is palindrome.

## A palindrome is a string that is exactly the same when read backwards

## as when it is read forward (e.g. anna).

## In this example, we work on integer arrays. The integer array must end with zero

## which indicates the end of this array. This ending zero is not counted used in paralindrome

## checking

.text

main:

## Read the number

la $a1, first # address of first array entry

la $a2, last# address of last array entry

addi $s1, $0, 0# reset the flag

addi $s2, $0, 0# reset the flag

or $t1, $a1, $0

or $t2, $t1, $0

length_loop:# length of the string

lw $t3, 0($t2)# load the byte at addr B into $t3.

beq $t3, $0, end_length_loop # if $t3 == 0, branch out of loop.

nop

addi $t2, $t2, 4# otherwise, increment B,

j length_loop# and repeat the loop.

nop

end_length_loop:

addi $t2, $t2, -4# subtract 2 to move back past

test_loop:

blt $t2, $t1, is_palin# if A >= B, it's a palindrome.

nop

lw $t3, 0($t1)# load the byte at addr A into $t3,

lw $t4, 0($t2)# load the byte at addr B into $t4.

bne $t3, $t4, not_palin # if $t3 != $t4, not a palindrome.

nop

addi $t1, $t1, 4# Otherwise, increment A,

addi $t2, $t2, -4# and, decrement B,

j test_loop# and repeat the loop.

nop

is_palin:# print the is_palin_msg, and exit.

addi $s1, $0, 1

j exit

nop

not_palin:

addi $s1, $0, -1

j exit

nop

exit:# exit the program

addi $s2, $0, 1

dead:beq $0, $0, dead# program stops here

nop

.data

first: # integer array

.word 2, 3, 8, 10, 16, 21, 35, 36, 39, 51, 1, 256, 1024, 43, 1024, 256, 1, 51, 39, 36, 35, 21, 16, 10, 8, 3, 2, 0

last:

Instruction Segment

0x00400000 / 0x3c011001 / lui $1,4097 / 15: la $a1, first
0x00400004 / 0x34250000 / ori $5,$1,0
0x00400008 / 0x3c011001 / lui $1,4097 / 16: la $a2, last
0x0040000c / 0x34260070 / ori $6,$1,112
0x00400010 / 0x20110000 / addi $17,$0,0 / 18: addi $s1, $0, 0
0x00400014 / 0x20120000 / addi $18,$0,0 / 19: addi $s2, $0, 0
0x00400018 / 0x00a04825 / or $9,$5,$0 / 21: or $t1, $a1, $0
0x0040001c / 0x01205025 / or $10,$9,$0 / 22: or $t2, $t1, $0
0x00400020 / 0x8d4b0000 / lw $11,0($10) / 25: lw $t3, 0($t2)
0x00400024 / 0x11600005 / beq $11,$0,5 / 26: beq $t3,$0,end_length_loop length_loop
0x00400028 / 0x00000000 / nop / 27: nop
0x0040002c / 0x214a0004 / addi $10,$10,4 / 28: addi $t2, $t2, 4
0x00400030 / 0x08100008 / j 4194336 / 29: j length_loop
0x00400034 / 0x00000000 / nop / 30: nop
0x00400038 / 0x214afffc / addi $10,$10,-4 / 33: addi $t2, $t2, -4
0x0040003c / 0x0149082a / slt $1,$10,$9 / 36: blt $t2, $t1, is_palin
0x00400040 / 0x1420000a / bne $1,$0,10
0x00400044 / 0x00000000 / nop / 37: nop
0x00400048 / 0x8d2b0000 / lw $11,0($9) / 38: lw $t3, 0($t1)
0x0040004c / 0x8d4c0000 / lw $12,0($10) / 39: lw $t4, 0($t2)
0x00400050 / 0x156c0009 / bne $11,$12,9 / 40: bne $t3, $t4, not_palin
0x00400054 / 0x00000000 / nop / 41: nop
0x00400058 / 0x21290004 / addi $9, $9, 4 / 42: addi $t1, $t1, 4
0x0040005c / 0x214afffc / addi $10,$10,-4 / 43: addi $t2, $t2,-4
0x00400060 / 0x0810000f / j 4194364 / 44: j test_loop
0x00400064 / 0x00000000 / nop / 41: nop
0x00400068 / 0x20110001 / addi $17, $0, 1 / 48: addi $s1, $0, 1
0x0040006c / 0x08100020 / j 4194432 / 49: j exit
0x00400070 / 0x00000000 / nop / 50: nop
0x00400074 / 0x2011ffff / addi $17, $0, -1 / 53: addi $s1, $0, -1
0x00400078 / 0x08100020 / j 4194432 / 54: j exit
0x0040007c / 0x00000000 / nop / 55: nop
0x00400080 / 0x20120001 / addi $18, $0, 1 / 58: addi $s2, $0, 1
0x00400084 / 0x10000000 / beq $0, $0, 0 / 59: dead: beq $0, $0, dead #program stops here
0x00400088 / 0x00000000 / nop / 60: nop

Data Segment

Address / Value
0x10010000 / 0x00000002
0x10010004 / 0x00000003
0x10010008 / 0x00000008
0x1001000c / 0x0000000a
0x10010010 / 0x00000010
0x10010014 / 0x00000015
0x10010018 / 0x00000023
0x1001001c / 0x00000024
0x10010020 / 0x00000027
0x10010024 / 0x00000033
0x10010028 / 0x00000001
0x1001002c / 0x00000100
0x10010030 / 0x00000400
0x10010034 / 0x0000002d
0x10010038 / 0x00000400
0x1001003c / 0x00000100
0x10010040 / 0x00000001
0x10010044 / 0x00000033
0x10010048 / 0x00000027
0x1001004c / 0x00000024
0x10010050 / 0x00000023
0x10010054 / 0x00000015
0x10010058 / 0x00000010
0x1001005c / 0x0000000a
0x10010060 / 0x00000008
0x10010064 / 0x00000003
0x10010068 / 0x00000002
0x1001006c / 0x00000000

1