 This time we're going to be working with a multiply, a divide, and a move from low instruction. These are a little different in that they don't have three registers, so it may not be immediately obvious how we use them in an R-type format. All three of these are standard R-type instructions, so they will all have zero for their opcode. The multiply and divide instructions both have two source registers, but no destination register. In contrast, the move from low instruction has a destination register, but no source registers. So, I'm going to go ahead and add in the source and destination registers. For our multiply, we have A0 times V0. Our divide instruction has $ta divided by $t9, but neither of these have a destination register. So we're not going to put anything in the destination register field. We'll just put zeros. None of these are shift instructions, so I can easily fill that one in. Now I have the move from low instruction. This instruction doesn't have any source registers. Its source register is technically the low register, but we can't access that with one of the standard register fields. Instead, I will put in zero for both of those. And then I have the RD field. The RD field will tell me where my destination is, where the processor should put the information that it pulls out of the low register. In this case, I want it to go into V0. In this case, I have two instructions that have two source registers, but no destination register. And a third instruction that has a destination register, but no source registers. So for both of these, I'm just going to put the information I have in the fields where it's relevant. Source registers go in the source register fields. Destination registers go in the destination register fields. We aren't going to mix those up just because we have some empty fields around. The last thing we've got is the function field. And those will be 18, 1A, and 12 for those operations. I'll go ahead and convert those into binary. For all three instructions, we have six bits of zeros for the opcode. A0 is register 4, so I will write down 4 in binary. V0 is register 2. T8 is register number 24. So that's 16 plus 8. Then T9 is register 25, which is 16 plus 8 plus 1. And then V0 is register 2 again. For these other fields, I'm going to fill in five bits of zeros. And then I have the six bits for our function codes. 18 will give me 0, 1, 1, 0, 0, 0. 1A is 0, 1, 1, 0, 1, 0. 12 is 0, 1, 0, 0, 1, 0. Now the last step is just to convert these into hexadecimal values. So that's what those three instructions look like in hexadecimal. In this case, we had a number of fields that went empty because they weren't being used by those instructions. In that case, we just got to put zeros in those fields, which made these instructions work out pretty easily. One nice thing to notice about our type instructions is that quite often the last two hexadecimal digits correspond to the function count. Unless we've got something in our shift amount field, we'll really just end up copying in these six bits as the last two digits of our instruction. This can make it pretty easy to see quickly what type of instruction we've got here. Our first digit is a zero, so the first four bits are obviously zeros. And then we have two digits at the end which give us some idea of what operation we've got. This won't work if we actually have a shift instruction, but we won't see too many of those, and those can be easy to detect as well.