 Next we're going to look at how we can address these data hazards. We're going to look at two different ways of doing this. The first is to use no-ops. Second method, which we'll start looking at in the next video, is on forwarding. No-ops are really simple. We know we have to have the results of the add instruction available before we can run the subtract instruction, so we could just wait. We can throw in two no-ops, or no operations. These instructions don't actually do anything. They just sit there, they fill up their pipeline, but that will be enough to make it so that our add instruction can write its results back to T0 before our subtract instruction tries to read them out. If we're going to use no-ops, then we're basically just always going to stick in two no-ops any time we have a dependency. We need to have two instructions between where the data is generated and where the data is being consumed. If we've got another instruction that's unrelated, we could put that in there instead of one of those no-ops. If we have a good compiler, it will find a way to stick some other instructions into that slot instead of having to put in no-ops, but no-ops will work in a pinch. They just serve the purpose of making sure that our previous operations have completed, produced their results, before another instruction tries to rely on those results.