- 2 days ago
Want to nail down stacks? This beginner-friendly video breaks down the stack data structure with clear diagrams and a laid-back vibe. We?ll walk you through how stacks work, why they reverse data (hello, LIFO - Last In, First Out), and how they?re used in real-world stuff like browser history, undo features in editors, and even the call stack in your code. Whether you?re just starting out or brushing up on data structures, we keep it simple with hands-on demos of pushing, popping, and checking stack size?no boring jargon here! Subscribe for more coding tutorials to level up your skills, and let us know in the comments what you want to learn next. Check out our site via the QR code in the video for more coding goodness!
Introduction to Stack 00:00:00
Explaining Stack Concept 00:00:06
Drawing Stack Diagram 00:00:30
Adding Elements to Stack 00:00:53
Stack Rules and Operations 00:01:16
Pop Operation and Interface 00:06:09
Stack Size and Empty Check 00:07:59
Tracing Stack Operations 00:11:46
Stack as Data Reverser 00:17:44
LIFO/FILO Explanation 00:21:13
Stack Use Cases 00:24:10
Call Stack Mention 00:26:18
Conclusion and Subscribe Request 00:27:21
Outro and Website Promotion 00:28:34
Thanks for watching!
Find us on other social media here:
- https://www.NeuralLantern.com/social
Please help support us!
- Subscribing + Sharing on Social Media
- Leaving a comment or suggestion
- Subscribing to our Blog
- Watching the main "pinned" video of this channel for offers and extras
Introduction to Stack 00:00:00
Explaining Stack Concept 00:00:06
Drawing Stack Diagram 00:00:30
Adding Elements to Stack 00:00:53
Stack Rules and Operations 00:01:16
Pop Operation and Interface 00:06:09
Stack Size and Empty Check 00:07:59
Tracing Stack Operations 00:11:46
Stack as Data Reverser 00:17:44
LIFO/FILO Explanation 00:21:13
Stack Use Cases 00:24:10
Call Stack Mention 00:26:18
Conclusion and Subscribe Request 00:27:21
Outro and Website Promotion 00:28:34
Thanks for watching!
Find us on other social media here:
- https://www.NeuralLantern.com/social
Please help support us!
- Subscribing + Sharing on Social Media
- Leaving a comment or suggestion
- Subscribing to our Blog
- Watching the main "pinned" video of this channel for offers and extras
Category
🤖
TechTranscript
00:00hello there in this video i'm going to show you a data structure called a stack we're going to
00:07make a diagram of it we're going to explain how it works we're going to look at its typical
00:11interface and we're just going to kind of work through the concept of what is a stack and what
00:15does it do and all that stuff where's your daddy and what does he do um so for starters
00:28what am i talking about let me open up a little notepad here and i'm going to start drawing the
00:33stack is pretty simple when you first think about it it just takes a little bit more work to
00:37to really get all the details down imagine i have a data structure and maybe like at the bottom here
00:43there's like some grass and so we can say that the data structure is empty when we first start okay so
00:48there's there's kind of a stack here but it's empty so there's there's nothing really on screen imagine
00:53then i wanted to add integers into this stack so i'm going to say let's add the integers eight and
00:58then two and then three and then four for some reason okay so how do we do this the first thing
01:04we do is we take the eight and we just put it on top of the stack you can imagine this as a stack of
01:10boxes or a stack of books or a stack of whatever when we add items we're always going to add to the
01:15top of the stack when the stack is empty we're obviously just going to add like at the very bottom
01:20you know at the ground floor but that's sort of the top uh when we add the two here the next thing
01:25that happens is we just put the two on top of the eight and the next thing that we do is we uh put
01:32the three on top of the two and so forth right so it's important to understand a few a few rules about
01:39stacks let me add that four real fast in stacks you're only allowed to add to the top or remove from
01:46the top you're not allowed to add or remove from anywhere else let me put a t for top right here
01:52so basically you're allowed to add and remove from the top so if i wanted to add let's say a 12
01:57the 12 would have to go on top of the four it couldn't go anywhere else in this data structure
02:02and if i wanted to remove data from this stack i could only remove the four i could not remove the
02:07three or two or the eight or anything you're also not allowed to look at the middle of the stack
02:12you're not allowed to look anywhere but the top so if i wanted to look at the three the two or the
02:17eight i wouldn't be allowed to do it i can only look at the four and if i want to see that three
02:23i have to pop the four off first in order to just see what's under it and technically unless you have
02:28the data you added memorized somewhere else you probably shouldn't know what's under the four until
02:33you actually remove it okay so we can add and remove from the top we can't look in the middle we
02:39can't look at the bottom or anything like that and um let's do a little uh let's do a little
02:45sequence of pops let me show you what the interface is really for this stack so first off we uh we i
02:51mean you can imagine a stack is sort of like a vector or a list with less functionality or more
02:56restrictions it's useful to to add restrictions on top of more robust data structures for the purposes of
03:02uh i don't know kindling your imagination or uh allowing yourself to use easier implementations
03:09or whatever if you're a musician or artist probably at some point you've been stumped
03:13and uh and you've had writer's block and you you can't figure out what to create
03:18so uh you know i know sometimes musicians when they get writer's block they'll they'll go to the
03:22swap meet and they'll buy like an old dusty dirty uh casio keyboard from 1985 and then they'll write a
03:28full song just with that one piece of equipment and it really stirs through their creativity or it
03:33sparks their creativity uh and then when they're done then they'll probably upgrade to better equipment
03:38but anyway so there's there's a bunch of different reasons to use you know lesser data structures
03:42although this is not really lesser it's very useful um in its own right so let's see uh the interface
03:48so what can we do in a stack i'm going to put s for stack actually i'm just going to type this up as
03:54code no no no no need to use the pen the whole entire time let's see so i'm going to put s for
03:59stack maybe i'll say uh you know stack that holds integers uh and i'll just put an s here if you don't
04:05know how to code right now uh at this point in your career just uh bear with me this is a uh declaration
04:11of a variable of type stack and in c plus plus uh these stacks you know stacks are a templated data
04:18structure which means the integers that we are holding inside of the stack they could be any other data
04:22type that we wanted to including custom classes so in c plus plus we would use these angle brackets
04:28to say i want my stack to hold integers and then i'm going to say s is the variable that i'll use for
04:33the stack so but this is not really a programming video this is just about stacks so if i wanted to
04:39tell the stack to push something like onto the top of the stack i would use uh the the method push
04:45push the method push usually has this prototype let's see i'll do stack uh push and it usually takes
04:54in a t type element and again the t type it's a templated uh data type which means right now if i
05:02just declared a stack that was of type integer it holds integers then the t would actually expand under
05:07the hood in c plus plus anyway at compile time to be an integer so it would be like typing int e right so
05:13whenever i type t just understand that that means one instance of a thing that you could put into
05:19the stack so we've got a push here and um usually the return type is void and it takes in one element
05:26to push and that means if i'm going to actually call let me put some comments here if i'm going to
05:31actually call push on the stack i've got to give it something to push and the data type of the thing
05:36that i'm pushing has to match what the stack was declared to hold so in this case it's integers so i'm
05:41going to put eight to match the diagram up above and then after that maybe i wanted to push another
05:47number so it's going to be a two and i'm just going to match what the diagram has up above so
05:52eight two three four so that's the interface for pushing usually in c plus plus and other languages
06:00should be similar the other thing you can do with stacks is you can pop we haven't done that yet but
06:04let me show it to you first um pop usually comes in two forms depending on what implementation you're
06:10looking at so uh sometimes pop returns nothing it simply removes an item from the top of the stack
06:18and sometimes it returns a copy of the item that you're actually removing so i'm going to put like
06:23stack here and then like stack just to show you that it's inside of the name space oh i don't know
06:28maybe that's too c plus plusy i'll get rid of that stuff hold on so we'll maybe do this just to show
06:36you that we have three separate parts uh to this little code snip so um sometimes pop doesn't give
06:43you a copy of the thing it removes sometimes it gives you a copy of the thing it removes in cases
06:47where pop does not give you a copy of the thing it removes then you would probably want to call top
06:53right before you popped and uh top will return a copy of the thing that is sitting at the top so
06:59just to clarify uh if i wanted to uh remove something and get a copy of it and i had this uh line 13
07:07form of pop from whatever implementation i was using then uh well i would just call pop and i would do
07:14something like this you know auto element equals you know the stack dot pop and what would happen is under
07:20the hood it removes the item and then it also returns a copy to me sorry for being too c plus
07:25plus c in this video on the other hand if i have the form that uh has void for pop then i would have
07:33to do something like this i'd have to say auto element equals stack dot top just to get a copy first
07:39get a copy of that four before i remove it and then when i'm finished then i can say s dot pop just to
07:46grab a copy of it and then remove it so for now we're just going to use the form that gives you
07:52a copy of the data at the same time that you're removing it another thing to keep in mind let's
07:57see there are two other functions i wanted to mention mention real fast so for now i'm going
08:01to say that we only have the t pop type you can also check to see if a stack is uh is empty and you
08:08can also check its size usually those are functions that have those names but i'm going to do let's see
08:14boolean empty and then i'm going to say size type size again sorry for being c plus plus c but
08:21basically in c plus plus a size type means an unsigned 64-bit integer so just like a count
08:28or a size something that's just going to be a whole number and never negative so uh we have this little
08:34interface uh that this data structure has and we have been calling push so far so let's go ahead
08:40and do some pops i'm going to say auto auto elements equals s dot pop maybe i'll do two of
08:47those in a in a row maybe instead of calling that element i'll just say a and b just so that we can
08:54have different variables to put our pops in and then maybe after that i'll do some more pushes i'll
08:59say let's push like a 15 and let's push like a 25 and then i think that means it's probably time to erase
09:05that uh the top part of the diagram with the eight two three four in favor of just whatever pushes and
09:10pops we're doing so let me just do this real fast
09:18okay so we did our pushes we pushed eight two three four and then i'm going to try to grab a
09:23couple pieces of data with these pops and for pop all you have to do is just uh well i should have
09:29mentioned this before but first check to make sure that there is something to pop
09:34for example if i had a blank stack let's say i had a blank stack right here there's just like
09:38nothing on it and and this green line is non-standard i'm just drawing it for fun but imagine i had a
09:42blank stack with no items and i decided to call pop on it well you're not allowed to pop from an empty
09:48stack there's nothing there to pop which means that's a really really naughty thing in c plus plus
09:52and other languages we would say that something exceptionally bad has happened the user tried to pop
09:57something that wasn't there and so then we would do something called throwing an exception at the user
10:02again this is not really a code video but if you know a little code hopefully you understand try
10:07catch blocks and throwing exceptions when bad things happen so we would just throw an exception at the
10:12user if you don't know how to code at this point then just keep in mind we would refuse to do it we
10:17would say something bad has happened we can't do that and then when you're doing your pushes
10:24sometimes depending on what uh what you're using to implement the stack under the hood
10:29inside of your code you might decide that you're using let's say you're using an array under the
10:36hood which has a fixed capacity uh if you run out of capacity and you can't actually hold any more
10:42data inside of the stack then you would throw if the user tried to push something into a full stack
10:48we would call that a stack overflow and then when we tried to pop from an empty stack we would call
10:53that stack under flow but for the purposes of this video just assume that the stack is just a diagram
10:59and it has no capacity so we can just add as many things as we want on it or maybe we're using a linked
11:03list under the hood which would have an unlimited capacity or limited only by the machine's available
11:09ram i guess or the program's available ram but anyway so let's go ahead and try to do this pop
11:15so let's do a pop here um well in the pop we just look at the top only right so we say well you know
11:23what let's make this more interesting hang on a second let's make this more interesting let's do this
11:30i'm going to do auto a equals s dot top so i'm going to grab a value without actually removing it
11:37okay so more interesting so we push the eight and we push the two so at that point in time actually
11:44let's let's trace this from scratch so we have like an empty stack here there's nothing there
11:50and um we're going to push the eight so the eight goes on the very top just like we did last time
11:55i'm going to put an eight there and then um we're going to push the two next so the two just kind of
12:01goes on top and then uh the next line line 12 we're just checking the top remember we're allowed
12:08to actually look at the top if we want to so since two is at the top that means a is equal
12:13to two i'm going to put a two here to remind ourselves that a is now equal to two then we're
12:18going to do a push three so i'm just going to stick a three on top of the stack and then we're going
12:23to push a four four is on top of the stack now again we're not allowed to look at anything in the
12:30middle anything anything but the top so for example uh when the three was on top we could look at it
12:36and remove it but now that we have a four on top we can no longer even see the three it's not
12:41available to us anymore so then we're going to pop and put that value into b so um you know what's at
12:48the very top it's a four so that means we're going to actually remove the four and stick that into b so
12:54i'm going to put four right here to remind ourselves that b is now equal to four and uh for the purposes
13:00of this video you can just imagine that this you know the top of the stack is just totally gone
13:05deallocated depending on what implementation you use you might want to think about crossing it out
13:10maybe there's like some junk data there now but for the purposes of this video in this diagram we're
13:14just saying it's gone so it's just totally gone okay then let's do another pop so we're going to pop
13:22and that's going to become c so obviously the top is uh is now the three so that means the three
13:31is going to go into the c variable so here's a three right there then the three gets deallocated
13:41and now the top is the two so then we'll push a 15 and we'll push a 25 so again we just put those
13:49new items on top of the stack even if there was stuff uh there before it's gone now so we're just
13:54going to stick the 15 and then whoops my pinmanship sucks now it's going to be a 15 and a 25 on top of
14:02the stack so we got this
14:07and then 25
14:12and then we're done adding our stuff so uh the other functions that we talked about are empty and size
14:18uh at the very beginning when we had just an empty stack like that if we were to call on the empty
14:22function it would tell us true the stack is empty and then every step after that where we had some
14:27data in the stack like as soon as we even added that eight at the very beginning from that point
14:32forward then empty would have returned false to us saying no the stack is uh it's not empty the size
14:38would have changed uh during every step of the way so you know at line 10 the size would have been one
14:45after we're finished with line 10 after line 11 the size would have been two uh 12 wouldn't have changed
14:50the size so it still would have been two uh 13 would have upgraded the size to three and then 14 would
14:56have upgraded the size to four once we popped after that pop was finished it would have been three again
15:01then the second pop would have brought it back down to two and then those two pushes would have put it
15:05back up to three and then four and so then the final size whoops that was horrible the final size of
15:11the stack is four and you can tell that there's just four items another way to double check yourself if
15:16you're kind of trying to trace this on your own is just count the number of pushes and subtract the
15:21number of pops so how many pushes do we have one two three four five six so that's like six minus
15:29however many pops we saw we see uh two pops so six minus two is equal to four so uh you know when
15:36you're writing this sort of thing down on you know like as a diagram to practice then you know it's a
15:41four just by looking but what if you did something wrong it's a great idea to double check yourself
15:46at all times so six minus two is four so we know that the size of the stack is four
15:51looks pretty good and we know the values of a b and c and um you know one of those was top two of
15:57those were pops and yeah okay so notice something though uh that's that's kind of peculiar about the
16:04data that came out uh if we added the data like i guess while we were adding the data we added first
16:10an eight and then a two and then a three and then a four i'm just looking at the pushes right now
16:15and then a 15 and then a 25 right so we added the data in that order but then when we grabbed
16:21the data out let me put this in uh but maybe like a red bracket or something when we grab data out of
16:29it uh the pops and the tops gave us uh two and then a uh okay never mind that was not a pop um
16:43it gave us a four and then a three if we're just talking about the pops but um
16:50look at the uh look at the first two items
16:54sorry sorry sorry look at the last two items right before and i didn't draw this very well
17:00imagine that we had just pushed the eight and the two and the three and the four only forget about
17:04these other uh pieces of data so at this point when we start calling our pops we have only an eight
17:11two three four stack right so the data that comes out then notice how it comes out as a four
17:17and then a three if we're removing data from the stack so notice how the four and the three are backwards
17:25notice also like if we kept popping out uh data you know we got the four and then we got the three
17:33the next what's the next thing that would come out it would be the uh the 25 right and then it would be
17:38the 15 and then it would be the two and then it would be the eight so if you really think about it the
17:45stack is reversing our input data we added a three and then a four but we received a four and then a three
17:51and of course it's a little bit muddled because we have some uh some pushes in between some tops and
17:58pops and stuff but just looking at what goes into the stack it's backwards right eight two fifteen
18:03twenty five let me finish this uh this push sequence up here so we added three and four and then we added
18:09a 15 and then my penmanship dude 15 and then we added a 25.
18:15so if you look at the data that comes out this is like a 15 and a 25 backwards and then the three
18:24and the four are backwards and then the two and the eight are also backwards and so one thing that
18:30a stack does is it reverses data let me give you a cleaner example uh with no uh pops in between the
18:36pushes just to show you uh what we're talking about a little bit more clearly okay so i'm gonna do
18:42maybe like another code page here whoops do that and then i'm going to say got our stack
18:50and we're just going to push in some data
18:54and then we'll just say s.pop and maybe i'll just do that however many times six two three four five six
19:02so now just a very quick trace because this is basically the same data that we had last time just
19:06uh not as intermixed so i'm going to do like the bottom of the stack here and then uh well i mean
19:13like an empty stack that's not really a bottom of a stack so we're going to push an eight
19:19and then we're going to push a two and then we're going to push a three and then we're going to push
19:25a four then a 15. gotta work on my fives dude okay and then 25 okay one more time oh yeah i guess i
19:41gotta slow down so what's going to come out remember the top is the only place that will give us data so
19:47if we start popping all these one by one we're going to end up with a 25 for that first pop oh maybe i
19:53should write it down over here do like a 25 and maybe i'll add some line breaks in the code here
19:59so that it's easier for me to write with a pen do this and that okay so the 25 i'm just going to do
20:06a red line through it to just to designate to or to denote deallocation or just like gone-ness
20:13then the top is at the 15. we do another pop it's going to be 15. oh i did my first perfect five today
20:20and then the top of the stack is now at the four so then the four is going to pop out next
20:27and then the three is going to pop out next the top is now at the three so the three is coming out
20:34for that pop we deallocate the three the top goes down one and then we pop it becomes the two
20:42that's deallocated now and then we grab the eight because that's where the top is
20:48so now we've grabbed all of our data out and i just want you to look at this one more time
20:52notice the data is uh eight that the data that went in was eight two three four 15 25
20:59the data that came out was backwards 25 15 4 3 2 8 or 8 2 3 4 15 25 if you kind of like look up
21:10so a stack is a data reverser the stack is also uh known as something called a let's see
21:17last in first out data structure LIFO or first in last out phylo data structure
21:27uh what that basically means is just it's reversing the data or priority goes to the item that is the
21:33youngest so if you looked at the stack at the point where we were about to remove the 25
21:3825 was the most recently added or the youngest item or the item with i guess the timestamp the
21:43furthest in the future however you want to look at it and that's the item that came out so if you
21:47think about it it was the last item in and therefore when we did another pop it was the first item out
21:54so LIFO or phylo and uh you know this eight down here that was obviously the last item that we were
22:01able to grab out of it so when we said you know hop our final pop before the stack became empty
22:08uh the eight was definitely the first item in so first in was the last out if you really want to you
22:14can kind of like jumble these uh these acronyms uh i think most like people just use LIFO or phylo
22:21um for me personally in my personal life if you say something to me that i understand
22:26i i think it's probably fine but it's it's non-standard i like to say uh you know foley
22:32first out last in that definitely makes sense it's just not very common another thing that i like to do
22:38for fun is also i'll mix up the phylo and i'll say lo-fi because last out is first in and now i'm
22:45cooler than other computer people because i use the word lo-fi i've now got like a giant mustache
22:50and like a little uh like swap meat shirt and i have craft beers and i have work boots on and i
22:56roll up my jeans and uh my my wife my sleeves are rolled up and all that stuff you know what i'm
23:02saying i'm cooler than everybody else now because i used lo-fi anyway so uh we used integers it's just
23:09important to understand that uh in modern uh coding uh i think i might have mentioned this before with the
23:15t's uh these stacks are templated data structures which basically means we can hold another data
23:22type besides integers as long as we declare what the stack will hold in advance so instead of integers
23:28you could imagine there's like a custom class like my class uh every single you know item in the stack
23:36is actually a full instance of a my class object or uh you know floats or strings or just you know
23:42any data structure you want you could put another data structure inside of a stack people do that
23:48sometimes just for fun you could take a vector and stick it inside of a stack a list put it inside of
23:52a stack you know whatever you want to do just to show that you understand everything um so again by
23:58the way the stack is empty if we tried to pop from it at this point uh this would be called a stack
24:02flow we would probably want to throw an exception at the user or just say we're not allowed to do it
24:07let's see um so i guess now i should tell you some common uses for stacks i'm looking at my notes
24:13right here uh obviously our stack has reversed the data so stacks are kind of good for data reversing
24:20imagine if you had like a a word and you wanted to detect if the word was a palindrome or not you
24:26would just like put all the letters of the word into your stack and then grab them back out and see if
24:31uh the word was still in the same order if it was then your word was probably a palindrome
24:36if you don't remember what a palindrome is i'm going to write down the word radar in reverse
24:41from backwards uh from back to front right it's the same word so that's a palindrome
24:46you could also use stacks kind of as a trail of breadcrumbs like you could imagine that early
24:51implementations of browsers uh had your browsing history in a stack somewhere so that
24:58every time you visited a web page then some kind of block of information maybe like a custom class
25:02instance was put onto a stack somewhere and it contained information about like when you visited
25:09the web page what the url was and just like whatever it is that the browser wants to remember
25:14and then later when you hit the back button then you can imagine the browser is popping from the stack
25:18in order to go backwards in your history or your spotify playlist or whatever it is you're doing
25:22uh honestly you know these systems are much more advanced than just using you know vanilla stacks
25:27now but you could imagine doing something on your own for fun or just what it might have been like
25:32in the very beginning i'm going to erase fully because that's just that's just that's just cringe
25:37lo-fi i think is way cooler um so trail of breadcrumbs uh like you know browser history you could
25:44all also imagine undo history like if you had a uh i don't know like a text editor of some sort or
25:50or like a image editor of some sort every major change that you did to it maybe the program under
25:56the hood is adding your change to the stack and that makes it easier to sort of reverse your changes
26:02as those changes are popped and uh there's like a source assorted mathematical uses like balancing
26:08parentheses and things but i'm not going to talk about that too much um and uh one of the most
26:14important uses for stacks inside of your computer is actually the call stack i'm going to talk about
26:19that in a future video but again remember each you know little item on the stack it could be a
26:24different data structure on its own it doesn't have to be an integer so imagine that i bundled up a
26:30bunch of information about a function call and i called it a call frame and every time i called a function
26:36i just stuck a call frame on the stack that's basically the call stack um but that's for another
26:41video anyway so let's see is there anything else that i wanted to show you i think we're actually done
26:47just talking about the basics of stacks i'm not talking about time complexities or anything like
26:51that in this video um check us check a future for video check a future video if you're interested in
26:57time complexities uh per certain implementations and so forth but for now this is how a stack works
27:03it's a philo or lifo or lo-fi data structure nobody's going to say lo-fi but me just fyi but um
27:10maybe everybody will start doing it now i don't know if if it becomes a trend okay you heard it here first
27:16give everybody this link um all right i hope you feel like an expert on stacks at this point i hope
27:22you had a little bit of fun and learned a little bit of something some stuffs i'll see you in the next
27:27video hey everybody thanks for watching this video again from the bottom of my heart i really appreciate
27:39it i do hope you did learn something and have some fun uh if you could do me a please a small little
27:44favor could you please subscribe and follow this channel or these videos or whatever it is you do
27:50on the current social media website that you're looking at right now um it would really mean the
27:55world to me and it'll help make more videos and grow this community so we'll be able to do more videos
28:00longer videos better videos or just i'll be able to keep making videos in general so please do do me a
28:06kindness and uh and subscribe you know sometimes i'm sleeping in the middle of the night and
28:11i just wake up because i know somebody subscribed or followed it just wakes me up and i get filled
28:15with joy that's exactly what happens every single time so you could do it as a nice favor to me or
28:20you could you could troll me if you want to just wake me up in the middle of the night just subscribe
28:24and then i'll i'll just wake up i promise that's what will happen also uh if you look at the middle of
28:30the screen right now you should see a qr code which you can scan in order to go to the website which i think
28:35is also named somewhere at the bottom of this video and it'll take you to my main website where
28:39you can just kind of like see all the videos i published and the services and tutorials and things
28:44that i offer and all that good stuff and uh if you have a suggestion for uh uh clarifications or errata or
28:54just future videos that you want to see please leave a comment or if you just want to say hey what's up
28:58what's going on you know just send me a comment whatever i also wake up for those in the middle of the
29:03the night i get i wake up in a cold sweat and i'm like it would really it really mean the world to me
29:08i would really appreciate it so again thank you so much for watching this video and um enjoy the
29:15cool music as as i fade into the darkness which is coming for us all
29:33so
29:38so
29:40so
29:42so
29:46so
29:48so
Recommended
0:15
|
Up next
1:29:31
1:28:48
23:47
0:15
2:27