 The JType format is the last of our three instruction formats. This one looks deceptively simple. We only have two fields. We have our opcode and an address field. The opcode will turn out to be pretty simple because we only have a couple of instructions that use this format to begin with, but we will have to fill in our address. Our opcode takes up six bits of our instruction, which will leave us 26 bits for an address. Unfortunately, all of the addresses in the MIPS architecture are 32 bits long. So we will take that 32-bit address and we're going to chop off some of the bits until it fits into that 26-bit field. Since all of our addresses are 32 bits long, or four bytes, this means that they're word aligned. Since they're word aligned, the address is always going to be a multiple of four, so zero, four, eight, or C, which means the last two bits of our address are always going to be zeros. So I don't actually need to include those two bits in my address field. I can always just add two zeros to the end of this address field whenever I want to reconstitute this. But that still leaves me with 30 potentially useful bits. Fortunately, we rarely go extremely far from where we currently are in our program. That means that our most significant bits are really unlikely to differ between our current instruction and any instruction that we want to branch or jump to. So we'll take advantage of this by simply dropping the upper four bits of our address. These are the most significant four bits and the four bits that are least likely to change. Then when we actually want to process this instruction, we will take the data in the address field, add two zeros to the end of it, because we know that every instruction must end with two zeros, and we will copy the upper four bits from our current program counter. That will give us a 32-bit address that we can feed back into our program counter.