 similar to what we saw with nested conditional statements, we're able to take loops and put them into additional loops, sort of what we saw with our Monte Carlo simulations. The entire idea is again once we think about a conditional statement that may have a true or false sort of separation, well there's nothing stopping us from putting in another conditional statement. Similarly, we're able to do the same thing with loops. Let's imagine I had some kind of condition where I wanted to sort of, and I'll sort of draw this out just very roughly, where I have a loop, but I happen to want to have some loop inside of that loop. So just like we can imagine I could have some condition running, and let me just kind of draw it out like this, I can have some iteration happening where this sort of comes in, and let's say it draws itself, but this makes its own little loop before moving back. And again, so that's just a nested loop. I have my main program running and then when I step into my loop, oh well I'm just going to go through this entire process over and over again before coming back, and then guess what? I might happen to do it again, and again, and again, and it's just one giant loop. And I know I've drawn a hideous circle, so let's kind of think about this for a moment and then we'll see a pretty visualization. But the entire idea is we have something known as an outer loop, sort of keeping control, and then the inner loop, which is operating sort of in again, just sort of running through our process. So visually, let's imagine that we had two variables, an x and a y, and our first loop is effectively just saying, well what's going on with that x? If x is zero, or if x is less than three, I want you to loop through this just giant loop. So run and do this entire process, and then repeat it. So you see that we're incrementing x, so repeat this, roughly speaking, repeat this entire loop three times. But then we also have this inner loop, where we control y, and y is just, or the conditional here is simply asking, well is y less than four? We're starting with zero, so y is in fact less than four. So that first iteration, you can imagine, as I step down, and let me actually change colors here, so I'm not making the hideous mess I did before, as I step down, right, as I step down, I am now brought to sort of a conditional statement crossroad. Do I move on with my code, or do I run this inner loop? And so the question is, well, let's check y. y is currently zero. Zero is less than four, so step into this second loop, this inner loop, and go through its process. So y just became one. All right, well, we continue with this loop, is one less than four, yes. So we run through that inner loop a second time, y becomes two, two is still less than four, we run through it again, we run through it again, and as you can imagine, now what we would do is we exit out of our while loop, x gets incremented to one, so x is no longer zero, it's become one. We're not done, we don't just reset, then we move on again because we're following things, in this case, sequentially, y gets reset. So in our design, x is going to run three times, y runs four times each time, so in this case you can see it'll go back. A great way to think about this would be if we were to just fully expand this out, and just to see that in our case, you can see y goes from zero to four, because again we hit four, we make y equal four, we see that y is not less than four, so then we move on, we change x to one, and we reset y, and that's when we get into our second iteration, because we jumped back up here, we see that x is still less than three, y is back to zero, and it does its process again, and then we once again, where are you, there we are, we increment x, x becomes two, we reset y, and we repeat the process, and we would do it, you know, we would see the print out again, it's short, it's cut off because space, but we would see x would eventually hit three, and then our loop would jump down, so a great question, and you'll see on your homeworks and whatnot, is let's look at something like this statement, taking the nested loop structure, but then asking a simple question, how many times does a print statement or something happen, so in our case, how many times does print hello occur, how many times is hello being executed, well it is not, and this is a very common mistake, it is not 24, no, modify the, so you get the the scary looking red, no, that is incorrect, because remember our inner loop has to run every single time before it's done, so in theory you could imagine, since this is going to run four times, that's hello, hello, hello, hello, then what happens, well that loop is done, we go down, x is incremented by one, so x is now one, y gets reset, and we come back and we repeat that entire process, so this occurs in our case, not 24, 20 times, hello is printed four times, 20 times, so if we're answering sort of this question, 20 times four, it would equal 80 printouts.