 When we go to write out the values for our convolution result, we can do this pairwise multiplication and summation explicitly. We can write it out the long way. So let's start by jumping kind of into the middle. We'll look at y of p. So our result at the position p. This means that our kernel fully overlaps the signal x. So it goes from minus p to plus p, and each one of those aligns with one element of the signal. And in addition, we know that the very tail end, after we've flipped it, the very left hand side of that flipped kernel, is w sub p. We know that lines up exactly with the first value of our signal, x sub 0. And we know that because we're calculating y sub p, the convolution at position p. So by counting down from p to 0, we're counting our weights from 0 up to p. And so we know that our first element is x sub 0 y sub p. And then we just step counting up on our x's and down on our w's because our w has been reversed, our kernel has been reversed. So we have x sub 1 times w of p minus 1. And we keep going until we get to the center of our kernel, which is x sub p times w sub 0. And then we keep going until we get to the far end of our kernel, which is x sub 2 times p w sub minus p. You can see there's a little typo here where I repeat the x sub p w sub 0. That shouldn't be there. I'll change that. But this shows going all the way from, counting from w p to w minus p, and from x sub 0 to x sub 2 p. So this is a full, fully overlapped, a fully valid convolution. As we step backward from here toward y sub p minus 1, y sub p minus 2, all the way back to y sub 2, y sub 1, y sub 0, we get to a condition where our kernel does not completely overlap our signal. Some of it's dangling off to the side. The way we handle that mathematically is we pretend that our signal extends out further, but that all of those values are 0. But what that means is that we can safely ignore them in our equations because 0 times each of the weights in our kernel is going to be 0. And so we can always start with, for y sub 0, we can just start right in the middle of our kernel and say it's x sub 0 times w sub 0. And we can count up on our x index, down on our w index, because our kernel has been flipped, x sub 1 times w minus 1, x sub 2 times w sub minus 2, all the way out to x sub p times w sub minus p. Then when we go to our next position, y sub 1, our next output value, we just shift all of our weights by 1. But now we can include the w sub 1 times x sub 0 and then move to x sub 1 times w sub 0 and count all the way up to x sub p plus 1 and w sub minus p. And we step through until we're completely overlapped at y sub p. And then we keep going. We just increment our x index by 1 every time we increment our y index by 1 and run that sliding dot product step by step all the way across. And when we get to the far end, we do the same thing that we did at the beginning. Any portion of the kernel that extends past the end of the signal just gets treated like it's lined up with zeros. So each of those kernel elements get multiplied by zero, so we can ignore them. And then we keep going until that center element on the kernel is lined up with the last element in our output array, y sub m. And then that's our last value.