### A good answer might be:

Of course!

# Complete Program

Here is a complete version of the program. It creates and initializes a struct. Then it creates a second struct and copies the first struct's data to it. Finally it prints out the data in both structs using a subroutine.

    # StructPrint.asm
    #
    # Allocate memory for a stuct and then initialize it.
    # Allocate memory for a second strct and copy data
    # from the first into it. Print both structs

            .text
            .globl  main

    main:
            # create the first stuct
            li      $v0,9             # allocate memory
            li      $a0,12            # 4 bytes
            syscall                   # $v0 <-- address
            move    $s1,$v0           # $s1 first struct

            # initialize the first stuct
            li      $t0,34            # store 34
            sw      $t0,0($s1)        # in age
            lw      $t0,pay           # store 24000
            sw      $t0,4($s1)        # in pay
            li      $t0,12            # store 12
            sw      $t0,8($s1)        # in class

            # create the second stuct
            li      $v0,9             # allocate memory
            li      $a0,12            # 4 bytes
            syscall                   # $v0 <-- address
            move    $s2,$v0           # $s2 second struct

            # copy data from first struct to second
            lw      $t0,0($s1)        # copy age from first
            sw      $t0,0($s2)        # to second struct
            lw      $t0,4($s1)        # copy pay from first
            sw      $t0,4($s2)        # to second struct
            lw      $t0,8($s1)        # copy class from first
            sw      $t0,8($s2)        # to second struct

            # write out the first struct
            move    $a0,$s1
            jal     PStruct

            # write out the second struct
            move    $a0,$s2
            jal     PStruct

            li      $v0,10            # return to OS
            syscall

            .data
    pay:    .word   24000             # rate of pay, in static memory

            .text
    # Subroutine PStruct: print a struct
    #
    # Registers: $a0 --- address of the struct
    #            $ra --- return address
    PStruct:
            sub     $sp,$sp,4         # push $s0
            sw      $s0,($sp)         # onto the stack

            move    $s0,$a0           # safe copy of struct address

            la      $a0,agest         # print "age:"
            li      $v0,4
            syscall
            lw      $a0,0($s0)        # print age
            li      $v0,1
            syscall

            la      $a0,payst         # print " pay: "
            li      $v0,4
            syscall
            lw      $a0,4($s0)        # print pay
            li      $v0,1
            syscall

            la      $a0,classt         # print " class: "
            li      $v0,4
            syscall
            lw      $a0,8($s0)        # print class
            li      $v0,1
            syscall

            la      $a0,lf            # end the line
            li      $v0,4
            syscall

            add     $sp,$sp,4         # restore $s0 of caller
            lw      $s0,($sp)
            jr      $ra               # return to caller

            .data
    agest:  .asciiz "age:   "
    payst:  .asciiz "  pay:   "
    classt: .asciiz "  class: "
    lf:     .asciiz "\n"

    ## end of file

The subroutine has been extended so that all fields are printed. The argument remains as the address of a struct.

### QUESTION 14:

Think of three interesting things to do with this program.