 So we have this component and UI wise, it looks great. As we pull our view this way, our show less button disappears as we cross that threshold. And then as we come back, it comes back and we can, you know, obscure stuff. It's great. But when you look at the console, we have this memory leak and every time we do that, we see more and more of these events logged. And it comes down to this at event listener. The way you use effect works is that it's actually creating this anonymous function and binding it to the window on this resize event. Every time this component re-renders. So every time we update this state, well, it just binds another one. Now binding a new function every time this component renders is just part of the way React works. But we need to clean up the old one when we bind the new one. First, we need to pull this anonymous function out into a named function so that we can reference it. Let's go with function handle resize. Put this in a cons so we can save that syntax. It literally doesn't matter what you choose. I just am lazy. Now in use effect, we just need to pass this named function handle resize. Now that's part one of the solution. The second part is that we need to return a cleanup function. This cleanup function will do the exact opposite of what we do in our setup. So we will return an anonymous function that will do this same thing, but remove event listener. Now we need it named so that we can refer to it in both the setup and the tear down. Let's try it and save that and see what happens. Let's refresh. We have our thing. It works. And then as we resize, we should still see dates, but we shouldn't see that number increase. It should be a stable amount of times. So now we're just seeing 2222222. It's not going up to three, four, five, six, 40, a hundred. So by pulling our anonymous function out into a named function, which we can reference for both setup and tear down, we've removed this memory leak. This is great, but we can do better. This is still firing an awful lot. And even though we're not adding a memory leak, we're still seeing it fire way more than we need to. I like for you to investigate debounce as a way to limit the number of times that this fires for any given event. So if I just move it one pixel, it should fire. If I swing it this way. It should also just fire like once or twice, maybe, depending on how long I take to do that. If I do like a really slow one, maybe it'll fire like three or four times to adjust. Now here we're not solving for a memory leak. We're just trying to limit the number of responses and re-renders that we do based on a singular intent. It all makes sense when you do it. Or tomorrow, when the video is right here and you can kind of actually see what we did and how, how much it's not logging. Or if you missed yesterday and you want to see how we got to this place at all, you can go up here. Yeah, that's it.