Okay, let's look at print. So print is again an idiomatic or conventional kind of operation, that occurs over and over in list processing. And it's when you want to do chaining throughout the list. Here are some of the things to keep in mind. The first thing you want to do is, this sets your chain to the beginning. So this is going to be an iteration. Iteration is going to start at the head, and then this is the critical idiom. And once again, I want to show it with what you might do with a C plus, plus 11 compiler. And as you chain, you're going to print out this value, a comma base. So if we do this thing we just had done, we would print 5 at this point with a comma. Then we'd advance the header to the next element. And we would print, I forget whether that was 3 or 7, but let's say it was 7. And then we go again. We test on seeing whether we had the null pointer, and finally 3. Then h equals h of next, that would hit the null pointer. We do the null pointer test then we'd be out of the loop. So you can see, by setting a loop, where you're using a null pointer as a sentinel. The null pointer being where you're at the end of the list. And the header as the beginning of the list. And then some processing. You can go through the list as a container. In order, end time for the zen elements of the list. And it's very efficient, so if you have to search a whole list and perform operations on a whole list, you don't lose anything over and above what would be indexing through an array. Now, what you should know how to do, not gonna show it here, is this kind of processing can also be done with a recursive routine. The idea on the recursion would be, the base case of the recursion, if you recall a recursion you need a base case. The base case would be, check for the null pointer. If it's a null pointer, you would exit, if it wasn't a null pointer, print whatever is being pointed at, and then advance the cursor, so the general case is print then advance. So you print and recur, advancing the cursor. And you also should know how to overload your bid shift operator to produce the expected output behavior when you call an ostream operation on the list. Those are things you can practice. Now that we have this list, let's just see a very simple use of it. Declaration default. As we know the default will make a and b, be a null pointer. So that's what's happening with these defaults. We're invoking the default constructures which basically are creation of null pointers. Now we do a prepend. Then we do a further prepend. And if we were to follow the logic. At the end of this prepend, we're gonna have 8 and 9. 9 is gonna be grounded and a, or the header of a, a dot h, is going to point at the first element, which is now the element storing 8. And we can go and do an additional, we could print that. Printing that we would see 8 comma 9. And then here we're doing a loop where we're doing a whole bunch of prepends. And here, we're prepending to b. And notice that we're doing the prepends of values that are squared, so we're getting from zero up to 39 squared. So we're going to see something that will end up looking like zero, 1 squared, two squared. So two squared is 4. And so on until we get to 39 squared. And that'll be, the header will be b, and that'll get printed. So if you wanted to try and figure out what gets printed, it should come out looking like that. Whoop. Well, I've given you pretty much the answer, but you should still do a little testing, and see how you could make sure what would be produced. And draw what would be produced in the previous code.