 The R-type format is used when we have a lot of registers. In this case, we'll have three register fields that we can use to access any of our 32 registers. This will be useful for a lot of our arithmetic instructions. We will frequently have two inputs coming from registers and a third one as a destination. So this is the only format that can handle having three registers. But our R-type format will pretty much end up being a catch-all format for any of the odd instructions as well. For the other two types, it's pretty obvious when you need them. We'll only use the J-type format for jump instructions. We'll only use the immediate type instructions for operations that require an immediate. So everything else can pretty much be an R-type instruction. Our format has six parts to it. We'll have the opcode, which is common to all instructions. We follow that up with three register fields. Each one of these is capable of addressing any of the 32 registers that we've got. The fifth element that we've got is a shift amount. We'll really only use this field for shift instructions, otherwise we'd set it to zero. This will allow us to shift the result up to 32 bits, either left or right, as required for our instruction. The vast majority of our R-type instructions actually have an opcode of zero. These will end up being a lot of arithmetic instructions, and we won't actually need to worry about how a lot of the hardware is working. Most of our R-type instructions get processed exactly the same way. The difference is in what the ALU will do. So we've got a function code instead. The function code gives us a way to control what the ALU is doing even though the rest of the hardware is going to be doing the same thing for all of our R-type instructions.