# C code:

# main () {
#    inorder(rooti,&printInt)
#    inorder(rootf,&printFloat)
# }
#
# printInt (a) {
#    print a; 
# }
#
# printFloat (a) {
#    print a; 
# }
#
# void inorder(n,print) {
#    if (n != null) then {
#       inorder(n.left); 
#       print(n.value); 
#       inorder(n.right);
#    }
# }

# Tree nodes:
# struct Node {
#    int/float value,
#    Node* left,
#    Node* right,
# }
	
# Tree:	
# A (100)
# |   	
# | --------- B (50)
# |   	      |
# |   	      |------- D (20)
# |   	      |
# |   	      |--------E (61)
# |
# | --------- C (120)
# |   	      |
# |   	      |------- F (111)
#
#
	        .data
Ai:		.word 100
		.word Bi
		.word Ci
Bi:		.word 50
		.word Di
		.word Ei
Ci:		.word 120
		.word Fi
		.word 0
Di:		.word 20
		.word 0
		.word 0
Ei:		.word 61
		.word 0
		.word 0
Fi:		.word 111
		.word 0
		.word 0

rooti:		.word Ai
		
Af:		.float 100.0
		.word Bf
		.word Cf
Bf:		.float 50.0
		.word Df
		.word Ef
Cf:		.float 120.0
		.word Ff
		.word 0
Df:		.float 20.0
		.word 0
		.word 0
Ef:		.float 61.0
		.word 0
		.word 0
Ff:		.float 111.0
		.word 0
		.word 0

rootf:		.word Af
		
nl:            .asciiz "\n"
	
                .text
                .globl main
main:           # BEGIN main prologue
                subu       $sp,$sp, 24           # Allocate stack frame
                sw         $fp, 0($sp)           # Save $fp in frame
                addu       $fp, $sp, 24          # Set up $fp
                sw         $ra, -20($fp)         # Save $ra
                # END main prologue
	
                # CALL inorder(rooti)
                lw         $a0, rooti             
                la         $a1, printInt
                jal        inorder
	
                # CALL inorder(rootf)
                lw         $a0, rootf             
                la         $a1, printFloat
                jal        inorder
	
                # BEGIN main epilogue
                lw         $ra, -20($fp)         # Restore $ra
                lw         $fp, -24($fp)         # Restore $fp
                addu       $sp, $sp, 24          # Pop stack frame
                jr         $ra
                # END main epilogue

printInt:	       
                subu       $sp, $sp, 24          # Allocate stack frame
                sw         $fp, 0($sp)           # Save $fp
                addu       $fp, $sp, 24          # Set up $fp
                sw         $ra, -20($fp)         # Save return address

		li         $v0,1                 # value to be printed is already
		syscall                          # in $a0
		li         $v0,4                 # print nl
		la         $a0,nl
		syscall

                lw         $ra, -20($fp)         # Restore $ra
                lw         $fp, -24($fp)         # Restore $fp
                addu       $sp, $sp, 24          # Pop stack frame
                jr         $ra

printFloat:	       
                subu       $sp, $sp, 24          # Allocate stack frame
                sw         $fp, 0($sp)           # Save $fp
                addu       $fp, $sp, 24          # Set up $fp
                sw         $ra, -20($fp)         # Save return address
                sw         $a0, -16($fp)         # Store $a0 so that we
	                                         # can read it later into a
	                                         # a floating point register.
	
		la         $a0, -16($fp)      
		l.s        $f12,($a0)            # n = n.value
		li         $v0,2                 # print n
		syscall
		li         $v0,4                 # print nl
		la         $a0,nl
		syscall

                lw         $ra, -20($fp)         # Restore $ra
                lw         $fp, -24($fp)         # Restore $fp
                addu       $sp, $sp, 24          # Pop stack frame
                jr         $ra

inorder:	# BEGIN fact prologue
                subu       $sp, $sp, 24          # Allocate stack frame
                sw         $fp, 0($sp)           # Save $fp
                addu       $fp, $sp, 24          # Set up $fp
                sw         $ra, -20($fp)         # Save return address
                sw         $a0, -16($fp)         # Save arg 0 (n, the node address)
                sw         $a1, -12($fp)         # Save arg 1 (address of print)
                # END fact prologue

		beqz       $a0, done             # if n==null goto done
	
		lw         $a0, 4($a0)           # n = n.left
		lw         $a1, -12($fp)         # pass "print"
		jal        inorder               # call inorder(n.left)
	
		lw         $a0, -16($fp)         # reload n
		lw         $a0, 0($a0)           # pass the value to be printed 
                jalr       $a1                   # call printInt/printFloat

		lw         $a0, -16($fp)         # reload n
		lw         $a0, 8($a0)           # n = n.right
		lw         $a1, -12($fp)         # pass "print"
		jal        inorder               # inorder(n.right)
	
done:	        # BEGIN fact epilogue
                lw         $ra, -20($fp)         # restore $ra
                lw         $fp, -24($fp)         # restore $fp
                addu       $sp, $sp, 24          # pop stack frame
                jr         $ra
                # END fact epilogue