 This time we're going to combining all of the data paths that we've created so far into a single data path that can handle all of the instructions we're interested in. I've gone through and cleaned up the six data paths that we've generated so far. So you can see we've got an data path for an add instruction, add immediate, branch equals, load word, store word, and a jump instruction as well. And we're going to be looking for all of the similarities between these. You could notice that a lot of them look pretty similar already. For example, all of our instructions have a program counter and an instruction memory. This should make sense. We want to get instructions out to run and if we're going to use a program counter to index our instruction memory, then we need that as well. So if we want to begin building a data path for everything, we might as well just start with the program counter and instruction memory. So I've grabbed those and put them over there. Now, for everything except the jump instruction, we end up using the registers in the ALU. Sometimes we use the data memory as well. So I'm going to go ahead and grab those three elements. The other thing we really have in here is all of this branch hardware. So I'm going to go ahead and grab the branch hardware as well while I'm here. And nicely enough, the branch hardware comes with a bunch of its connections. And now our big task is going to be how do we connect all of this? How do we make it do what we want? Well, some of the things are simple. I can connect the branch hardware backup so it can update the program counter when it needs to, or we can just take the next instruction. For our add instruction, we need to be able to read two values from our registers. And we also need to be able to write to another register. So we need to know what those three registers are. We need to be able to pass that information to our ALU. Then when we're done there, we'd want to be able to store that information back into a register. For our add immediate instruction, we do something pretty similar, but instead of taking a second value from a register, we're going to take a value directly from our instruction. So I'll add in a connection for that. So that's everything we need for an add instruction and add immediate instruction. Our branch equals is almost done. We need to notice that we want to do our branch if the results of our subtraction are one. Otherwise, we'd just take the address of the next instruction. So our load word and our store word instructions also require accessing memory. And if we're doing a load word instruction, well, we pass the address of the piece of data that we want from our ALU to our data memory, then we take the results and we pass it back to the register. For our store word instruction, we still calculate an address with our ALU, but we also need this piece of data to pass to memory. So I'll get that piece of data out of our registers and pass it over to our store data slot in memory. One other thing we might need to do is implement this jump instruction. And the jump instruction really just takes whatever comes out of instruction memory. And passes it back to the program counter. So there we go. There is a combined data path for all six of those instructions. Now, chances are this still looks a little odd. We've got a number of points where we've got lots of wires running into each other, lots of wires separating. It probably seems a little odd that this hardware is really capable of doing all six different instructions at once. It turns out it has all the functional pieces that we need, but we're going to need to add some extra hardware to control how these pieces work. Which operations do they run? Does it run an ad instruction? Does it run a store word? We're going to need to be sure that it gets the right pieces of information. It does the right things with it. We don't want to take both the immediate from our instruction. And the second source from our register as the second input for our ALU. We only want one of those two. So next time we're going to be looking at what do we need to add to this so that we can control it? How do we actually manipulate this piece of hardware?