 So one of the things that we want to think about, even before we start doing analysis of our our programs, is we want to think about something we like to call the random access model, RAM, if you want to think of it like that. But the idea is that here we've got some memory. And here we've got our CPU, our processor. And from a computer science perspective, these are really the only two things that we absolutely care about in computer science. Because we've all learned that, you know, the CPU that contains something we refer to as the ALU, the Arithmetic Logic Unit. And memory stores sort of the values, the instructions of our program. And one of the things that we want to kind of keep in consideration is, like I said, this thing has instructions to my entire program in it. So right here, this little blue dot, we can imagine that right now my program, whatever it is, it's just sitting there in memory. The reason why this is sort of important is because I have to access that. Anytime I have to access sort of my memory, just because I need a value because I wanted to get the next instruction, those are things that we start to look at when we start dealing with something we refer to as running time. Because we don't look at sort of analyzing a program based on how big it is and how many instructions. We actually care about how many times we have to visit memory, how many times do we have to go into memory and take something from there. And what we like to do with this kind of big fancy word is we reduce it down to something we like to call t of n. So let's say, for example, I had a basic line of code. Let's say, for example, int test equals five. Nothing terribly crazy, nothing terribly going on here. If I asked you, then, given this line of code, what is its running time? What is its t of n? We'd start to look at some of the different operations that are going on here. So if we look at this, we're creating tests, and we're not doing terribly much, we're just kind of saying five, and we can generate five because we all happen to know sort of binary, hopefully. If not, watch a video on it. This happens to sort of look like that if we went to all eight bits. So that doesn't take too much time. This we would actually classify as taking only one action, one primitive step. However, let's actually kind of look at another one. If instead I said test, and let me actually change the color to make it different than that one. If I said, for example, let's create that same variable, I know Java would freak out, but work with me here. If I said five plus 10, five plus 10, now we've got actually the same kind of needing to create allocate memory for tests. That still is a one interaction. However, by me doing this addition sign, what's actually happening is I'm having to produce another primitive operation. And so as a result, this also takes a step. And so as a result, our t of n here would be two. Now, one thing to think about is any arithmetic operation, so addition, subtraction, even multiplication and division. I know that might sound a little odd because something like multiplication division, that's a repeated step. But most processors these days are okay with handling that and they've already got it kind of built in. So even if I change this to five times 10, we would actually still classify that as one operation, a t two. So let's kind of expand on this a little bit. Let's take it and let's create maybe two, two instructions. So I'll create first an int val, and we'll say that equals five. Again, just like before, its t of n is one. But then let's come in and let's make our test again. And this time let's say value times 10. Now just like we said that multiplication, that's still going to get classified as a one. This operation, this creating of test is still allocating one operation in memory. This multiplication, this arithmetic operation, we'll say, is creating one as well. However, if I came in here and I said that t of n was actually three, that's interesting. So where could that final thing be? Well, that's actually where this value comes from. You see, I have to access this. If I go all the way back, remember anytime I have to access anything in memory, including a variable, that means it takes another step. So me going into memory, solely for value, is going to create another operation. So what we would do is if this was my entire program, I see that I have a t of n of one for line one, plus a t of n of three for line two, I'd add those together and I'd get now an operation, a t of n of four.