 This time we're going to be looking at dependencies. Dependencies are when one instruction uses the results of another instruction. We should expect to have lots and lots of dependencies in our code normally, since that's how we write code. We compute something so that we can use its results to compute something else, which we then take those results and use them to compute something else. So we generally have these really, really long strings of dependencies in our code. As an example with this piece of code, we've got two instructions that are subtract in our OR that want to use t0 as one of their input parameters. Since the add instruction is updating t0, the subtract and OR instructions are going to be dependent on its results. So this means that we really need to make sure that our add instruction has completed before we try using that information for our subtract instruction or the OR instruction. The reason why we're interested in dependencies is because they form the precursor of data hazards. When we have two instructions that are really close together that want to use the same piece of data, we need to make sure that piece of data is available for both instructions. So I really need to make sure that I've calculated what t0 is before I try running one of these other two instructions. We will look at a couple different ways to handle this issue, but we're primarily going to look at cases where the dependent instructions are close together. When they start getting farther apart, then we won't have to worry about them because we'll know that the results of this instruction have been committed back to the registers and that when some instruction down here tries to access t0 again, we know that we can just pull that data out of a register. We're really going to be worried about the ones which are close together where the potential exists for this instruction to have not written its results back to the registers before another instruction tries to pull them out.