 In this example, we're going to be looking at how forwarding can improve our performance on this block of code. We saw this block of code earlier, where we saw that we had this set of dependencies, and we saw how we can add no ops to avoid the data hazards. But this time, we're going to be using forwarding to get around as many of those data hazards as possible. So, our first instruction is a load word instruction, so it won't have any dependencies. Our second instruction is dependent on the first one. Now, our load word instruction will get these results out in the fourth stage. But our next load word instruction would like to use those in the third stage, so that it can add zero to them. Admittedly, that's not a terribly interesting operation, but it does need to do that in the third stage. So I'm going to need to wait one cycle after this load word completes before I can run my second load word instruction. Since I don't have anything else to fill that, I'm going to have to put a no op instruction in there. Then I can run load word number two. Our third load word is dependent on the results of my second load word. As before, load word number two is going to get its results in the fourth stage. But since load word number three would like to use those results in its third stage, we're going to have to wait one cycle. Now, we have an add immediate instruction. Since our add immediate instruction is dependent on the results of our previous load word, we're then going to have to wait one cycle. Our load word number three is not going to produce its results until the end of its fourth stage, where the add immediate would like to consume those results in its third stage. So we'll have to delay our add immediate instruction by one cycle. And again, we'll do that using no op instruction. Next, we have a store word operation. This depends both on the results of the add immediate instruction before it, as well as the results of load word number two. So we need to make sure that load word number two has completed its results. Maybe committed them back to a register before we run our store word instruction. But we also need to make sure that we have the results of our add immediate instruction available. We've had four clock cycles since load word number two ran. So that data should be available in a register for us. T1 should be available to us. But T2 comes from our add immediate instruction. In this case, our add immediate instruction computes its results in its third stage. So those will be available for the third stage of the store word. Now realistically, our store word instruction won't use those until its fourth stage. So they're certainly going to be ready for our store word in time. So our store word instruction will be able to run immediately after our add immediate instruction. After this, we have an add immediate and an add instruction, neither of which are dependent on any of these instructions that we've got already. So we won't have to worry about any dependencies or data hazards there. So those can both run immediately afterwards. So in this case forwarding wasn't able to get rid of all of the no op instructions in this code, but it was able to reduce a lot of them. I now have three no op instructions that I'm using to add bubbles into my pipeline so that some of these load word instructions can complete before I use their results.