Watch me build an AVL tree step by step with linear data that would normally create a terrible unbalanced BST. See insertions, balance factor calculations, and rotations in action.

Perfect follow-up to my BST and AVL intro videos.

00:00 Introduction to AVL Tree with Bad Data
00:14 Previous Videos on BST and AVL Trees
00:28 Practice Example Building Step by Step
00:50 Adding First Node 12
01:11 Adding Node 21
02:10 Adding Node 30 and First Rotation
04:03 Recomputing Balance Factors
05:08 Adding Node 38
08:03 Adding Node 42 and Second Rotation
12:51 Recomputing Balance After Rotation
14:09 Adding Node 55 and Third Rotation
18:55 Placing Unaccounted Nodes
19:21 Final Tree and Balance Factors
20:07 Conclusion and Thanks

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to the Blog: https://www.NeuralLantern.com
• Watch the main “pinned” video of this channel for offers and extras

Hey there! Let’s build an AVL self-balancing binary search tree with some really bad data.

It’s all going to work out, trust me.

Okay, so hopefully by now you’ve seen my other videos where we talked about how to define binary

search trees, how to build them, search through them, add, delete, all that stuff. And also AVL

trees. What are rotations? Why do we rotate? How does the AVL tree maintain itself? And so forth.

just going to be a practice example. In the previous video that I that I

recorded regarding AVL trees, I started off with a really long and gnarly linear

tree and then I suddenly turned on AVLness and we rotated the crap out of

it for about 30 minutes until it was really really good. So now I’m just

going to build a tree one step at a time. Suppose for the sake of argument that

you have some really bad data. You know a long time ago, I love telling this story.

time ago you know my grandma before she passed on she was kind of bitter and she had some enemies in

the neighborhood she used to call the cops on her neighbors for gossip um she had a neighbor who

kind of feuded with her and at one point according to my grandma anyway uh my neighbor like didn’t

like my grandma’s tree and so one day when my grandma was looking out into the backyard

through the back window because she likes to yell at ducks who are swimming in her pool

notice that the other little old lady’s arm just kind of went over my grandma’s fence

with a spray bottle and then sprayed her tree. And then my grandma’s tree died. So this kind of

thing I like to call, you know, tree poisoning or data poisoning or bad data, it can affect a binary

search tree and make it really, really, really slow. But in AVL trees, if we have bad data,

it should actually end up being fine. So I’m just going to say we’re poisoning our grandma’s tree

grandma’s tree with some bad data. I’ll just do maybe maybe five pieces of data. We could go

further than that but it’s it’s going to be a super long video if we do. So we’re going to add

these pieces of data one by one. So that means the first thing I’m going to do remember we are kind

of just regularly you know building a regular binary search tree. It’s just that the differences

after we modify the topology in some way we’ll just check to see that it satisfies the rules of

then we’re going to start performing rotations to make sure that it’s self-balancing.

So we’ll add the 12 first.

So let me see if I can draw a little arrow just indicating,

yeah, we’re going to add this number right now.

I’m going to do an ellipse for a node.

And you know, like for binary, what is that?

Flying saucer for binary search trees.

It’s like, well, if there is no data already, if the tree is empty,

first piece of data you add is going to end up being the root node. So that’s it. We have our

root node here. See my other videos if you want more practice on building trees. So we’re just

going to call that the root node. And then we’re going to compute its balance factor, which is

obviously just going to be a zero. So that was super easy. Now we’re going to move on to adding

the next piece of data. Things are getting a little bit worse. This is going to be a linear tree.

tree if it weren’t for our trusty I guess AVL functionality so the 21 I’m

gonna maybe just duplicate this node right now and set that to a 21 and then

we’ll figure out where does the 21 go well it can’t be the root because the

root is already occupied 21 is larger than 12 so it’s got to be on the right

side so the 21 is going to be the right child of the root node so I’m just going

Connecting line right here.

And then we have to recompute balance factors.

So the 21 is the thing we just added.

We have to compute that.

Then we have to work our way up the tree until we hit root.

So we see the root node.

It now has a balance factor of 1.

So it got a little bit worse.

But we don’t see 2 or worse.

So that means this is currently a valid AVL tree.

And we don’t have to do any rotations.

So now it’s time to add the 30.

just realized I could just upload like a hundred videos like this and I think you’d all be pretty

happy or some people would be pretty happy um I don’t know if I want to do that to myself maybe

I will so we’re going to add the 30 node uh so first I’m just going to duplicate some node

and I’m going to call it 30 then we have to figure out where the 30 node belongs uh it’s not going

to be the root node that’s already occupied 30 belongs on the right side of 12 but we can’t use

of 12 but we can’t use that right child it’s occupied 30 belongs on the right side of 21

so you know it makes sense we called this linear data that would make a linear tree so everything

ended up being on the right side so far it’s just getting worse and worse but now the ablness is

going to kind of come to the rescue we have to recompute the balance factors so the 30 has a 0

the 21 ends up having a 1 again if you want practice computing balance factors see my other

The 12 has a balance factor of 2 and now we know right away this is not a valid ABL tree anymore

because we have a balance factor that is bad. It’s too bad.

So we have to now select an XYZ trinode subtree so we can perform a rotation.

I’m sure you can imagine it’s just going to end up being three nodes that are perfectly balanced like that.

But let’s do it one step at a time.

So the Z node is going to be the 12.

That was the first node that we noticed that was out of whack or like I guess the highest node.

or like I guess the highest node of the lowest nodes.

And then we have to find Y by taking a child of Z.

There’s only one possible child we could choose, so that’s going to be Y.

And then we find X by taking a child of Y.

There’s only one choice again, so it’s just going to be there.

Now we have X, Y, and Z, and I’m going to write it down real fast.

Let me just put this in black ink.

So X is 30, and Y is 21, and Z is 12.

12. Then we’re going to do A and B and C, which are going to be just in order representations of

XYZ. So again, think in your code, you would be doing pointers, you’d probably want to make three

more pointers, call them ABC. If you had a rotation function, the rotation function,

after you selected three nodes to rotate, it would receive XYZ. And then you say, let’s reorder,

you know, XYZ and call them ABC. So A is going to be 12, and B is going to be 21,

it should you know ascend from left to right if we’re not supporting duplicates in our tree

and then i’m going to um just you know make some make some nodes for our target pattern here

our output pattern so i’m going to like make some nodes here kind of place them uh in the perfect

avl tree output pattern a perfectly balanced trinode subtree i’m just going to reconnect this

The output pattern is always the same.

You know, it always starts this way because this is better

than the linear pattern that we have above.

And then I just have to update the numbers.

So the left child is going to be 12.

The right child is going to be 21.

Sorry, the center is going to be 21, the new parent.

And the right child is going to be 30.

Okay, now we look for any nodes that are children of the input nodes

that have been unaccounted for.

You can tell easily that all nodes are being used.

So we don’t even have to worry about that step.

So now that we have our trinode subtree which is perfectly balanced, we are ready to just sort of override it into the diagram.

And since the diagram only has the three nodes to begin with, I could pretty much just like erase everything, call it a day, and say this is the new tree, the new rotated tree.

So I’m just going to maybe put this in the middle I guess.

I’m going to delete this over here and recompute the balance factors.

a zero, get zeros, and this 21 also gets a zero because it’s perfectly balanced.

Next thing is let’s move on to adding the number 38. So we’ll add the 38 here and

same thing that we do before. Let’s make a copy of one of the nodes for our diagram.

Let’s call it the 38 and then let’s figure out where it belongs. It’s not going to be the new

root node because that’s occupied. It belongs on the right side. It’s not going to be the right

It’s not going to be the right child because that’s occupied.

It belongs on the right side of the 30.

It couldn’t go on the left.

That would be an invalid binary search tree.

So I’m just going to stick it right there and do a connection.

And then we’re going to update the balance factors.

So the 38 is a leaf.

It gets 0.

The 30 gets a 1.

And the 21 also gets a 1 because its left subtree is a 1 and its right subtree is 2,

or height, and the difference is just 1.

is just one. Remember we don’t really need to update the 12 or any nodes that are not

directly above the node that we just added or removed. So if you look at this tree there’s

a little bit of imbalance but nothing is two or worse so we don’t actually need to perform a

rotation. This is already a valid AVL tree. So I’m going to move on to adding the next number.

Let’s add a 42. Same thing we’re going to duplicate a node for our diagram and we’re going to call it

going to call it the 42 where does it belong well we start by looking at root that’s occupied 42

belongs on the right side of 21 the right child is occupied 42 belongs on the right side belongs on

the right side i mean it’s always going to be on the very right of the of the diagram because that’s

the poison data that we received uh so i’m going to put it over there and then connect um the child

child relationship and then let’s update the the balance factor so 42 gets a 0

38 gets a 1 and 30 gets a 2 now because it’s got 2 height of subtree on its

right side and no subtree on its left side the 21 we should update left subtree

is a 1 right subtree is a 3 oh it’s still gonna it’s actually gonna be 2 so

we have two instances of the number 2 and again which one do we actually want

by the way here’s here’s how I like to eyeball it you can kind of see oh there’s two levels of

difference in terms of the root node which one do we rotate first well as low as possible because

if we rotate the 30 it might end up fixing the 21 so we don’t want to do any more more work than we

have to so I’m just going to maybe move this over here a little bit and select our xyz um hang on

a second I think I just like didn’t do a snap to grid when I was doing that okay hang on

doing that okay hang on okay so we got to choose our x y and z uh we’re going to say that the 30

is z the lowest node possible that is out of whack and then we hop down to a child of z to find y

we hop down to a child of y to find x and so now we have our xyz i’m just going to write them down

I’m going to change the ink real fast and then we have to get ABC so A is the least value B is the

one that belongs in the middle and C is 42 now we have our ABC we’re ready to draw our output pattern

or target pattern so I’m just going to put like some nodes up here duplicate that a couple times

all right not the prettiest but I’ll take it I’m gonna do my connecting lines

and then I have to update the numbers so a is 30 and then b is 38 and c is 42 still so we’ll just

leave that as is now we have to look for children of any of the output pattern nodes that are

for so we’ll first look at the z node here the 30 it had a right child of 38 that’s already handled

as the y node so we don’t need to worry about the 38 okay next we look at the uh y node it had a

right child of 42 that’s also handled in the output pattern so we don’t have to worry about that uh

then the 42 had no children so we don’t need to really do anything this is going to be super easy

Just as a reminder, the Z could have had a left child, the Y could have had a left child,

and the X could have had two children, at least in this particular pattern.

Oh, I think in my previous video, I didn’t name off all the rotation types.

Whoops.

Okay.

So now I’m ready to just kind of like move this into the diagram.

So the 30 and 38 and 42, we can just kind of get rid of that

move the rotated output pattern into the diagram like this.

We’ll make the 38 the right child of 21.

I want to make it go a little bit more to the right

so that we have a nicely drawn diagram

so that all the nodes have space so it’s easy to debug visually.

It’s easy to just kind of eyeball it.

Then I’m going to update the balance factors.

So the 42 has 0, the 30 has 0, the 38 has 0.

Nice.

The 21, hopefully that improved.

The left subtree has a height of 1, the right subtree has a height of 2.

of one the right subtree has a height of two so actually the balance factor of the 21 node improved

to one we are now done uh rotating and we have a valid avl tree and uh we could have had you know

a tree that was just totally linear all the way down to the right it could have worked out that

way if we weren’t using avl trees uh and we would have had a really slow binary search tree but with

avl trees this is like you know a lot a lot faster reasonably and you can imagine if i added some

And you can imagine if I added some more data, let’s see, how long is this video?

Oh, it’s this video.

It’s already 15 minutes.

Let’s add one more piece of data just for fun, Zars.

I’m going to add 55.

Anybody remember that old song, I Can’t Drive, 55?

So we’re going to add the 55.

I’m going to say, here it is.

And then I’m going to do just like a new node duplicate.

node duplicate. I’m going to stick a 55 in there. And then where does the 55 belong? Well,

it’s not going to go with the root node belongs on the right side. Not going to go there belongs

on the right side, not going to go there belongs on the right side, we just end up going all the

way to the right. Pretty much. Okay, so I’m going to say it belongs there. And I’m going to connect

it. And then we update the balance factors. So zero here, and then the 42 becomes a one and the

42 becomes a 1 and the 38 becomes a 1 and the 21 becomes a 1 on the left and 3 on the right

which means we have a balance factor of 2 so now the 21 node is imbalanced this is no longer a

valid abl tree we got to rotate to make it better so once again we look at the first node that’s out

of whack or the lowest node that’s out of whack it’s going to be the 21 we call it our z and then

we find a child of z with the tallest subtree so it you know is it going to be the 12 or the 38

the 12 or the 38 it’s definitely going to be the 38 because 38 is the taller subtree same thing to

find x it’s got to be a child of y should we go left or should we go right we have to go right

because that’s the taller subtree so now we have our x y and z um i think i’ve been forgetting to

is 38, Z is 21, X, Y, and Z, and then we do A and B and C. So A is the least value, 21, B is the one

that belongs in the middle, C is the one that belongs on the right side. Now we’re ready to

draw our target output pattern. So I’m going to do this, a little duplication.

Do you like when I say, oh, we’re going to do this, we’re going to do this, we’re going to do this?

Because sometimes I just go, I don’t like it.

And I don’t think people like it when I say that.

Okay.

I’m going to connect these real fast and then change the numbers to match.

I think I made that one.

I think it’s okay.

I can never tell if it’s perfectly symmetrical.

I can’t do it.

It’s perfectly symmetric.

All right.

So A is going to be on the left.

Alright, so A is going to be on the left, that’s 21.

B is in the middle, that’s 38.

C is on the right, that’s 42.

Then we have to look for children of the output pattern that are unaccounted for.

So we’re going to do, look at the Z node.

The Z node had 12, which is unaccounted for as a left child.

So I’m going to copy the 12 somewhere.

We’ll deal with it in a second.

Then we look for the right child of 21, that’s a 38.

that’s a 38 that’s already in the output pattern so we don’t have to worry about that anymore

and then we look at the y node so y had left child was 30 that’s not accounted for so i’m

going to copy that put it somewhere else and then its right child was 42 that’s already

handled in the output pattern so we’re done there i’m going to duplicate this and then we look at

the uh we look at the x node the 42 it had a right child of 55 that also was not accounted for so i’m

for so I’m gonna just copy it over here and we’ll do something with it okay we’re done looking for

unaccounted for children again if you are just rearranging pointers you don’t really have to

worry about this in your code but since we’re doing a diagram we have to double check that

none of these nodes at the bottom here the unaccounted for children have children of their

own if they did the children would have to come with them so 55 uh no children 12 no children 30

So those are fine. If there were any children underneath, they would just stay on those nodes.

So now we have to figure out who goes where. So the 12 is the least value. That means it’s going

to go probably in the leftmost position compared to the other ones. But if we figure out like,

where does this belong in the binary search tree? It belongs right here as the left child of 21.

The 30 node, same thing. Where does it belong? It belongs between the 21 and 38. That’s the only

And then the 55, it belongs on the right side of 42 for the same reason.

Okay, I’m going to do my connecting lines real fast.

If I don’t do my connecting lines, then I don’t like it.

So now we have how many nodes in the output pattern?

We have one, two, three, four, five, six.

there’s also just six which means the final tree after rotation is just everything that we’ve

written on the right side so i’m just going to erase all of this stuff get rid of that too

and then move all these nodes over to the left call that the tree this is now the tree and then

i just have to recompute the balance factors to make sure that everything is okay so the leaves

0, 0, the 42 gets a 1, the 21 is perfectly balanced so that gets a 0.

The 38 is also perfectly balanced.

Again, it’s not about weight or mass even though there are more nodes on the left subtree,

it’s all about the height.

The height of the left subtree is 2, the height of the right subtree is 2, so 38 is actually

perfectly balanced.

Because there are no nodes that have a balance factor of 2 or worse, we are done rotating

this tree.

This is a valid AVL tree and it’s pretty fast.

So I think that’s pretty much it.

That’s all I wanted to go through today for this video.

Thank you so much for following along.

I hope you learned a little bit of stuff and had a little bit of fun.

And I will see you in the next video.

Have a great night and or day and or week and or weekend.

Hey everybody.

Thanks for watching this video again from the bottom of my heart.

I really appreciate it.

of my heart I really appreciate it I do hope you did learn something and have

some fun if you could do me a please a small little favor could you please

subscribe and follow this channel or these videos or whatever it is you do on

the current social media website that you’re looking at right now it would

really mean the world to me and it’ll help make more videos and grow this

community so we’ll be able to do more videos longer videos better videos or

just I’ll be able to keep making videos in general so please do do me a

do me a kindness and uh and subscribe you know sometimes i’m sleeping in the middle of the night

and i just wake up because i know somebody subscribed or followed it just wakes me up and

i get filled with joy that’s exactly what happens every single time so you could do it as a nice

favor to me or you could you could troll me if you want to just wake me up in the middle of the

night just subscribe and then i’ll i’ll just wake up i promise that’s what will happen also uh if

you look at the middle of the screen right now you should see a qr code which you can scan

to go to the website which i think is also named somewhere at the bottom of this video

and it’ll take you to my main website where you can just kind of like see all the videos i published

and the services and tutorials and things that i offer and all that good stuff and uh

if you have a suggestion for uh uh clarifications or errata or just future videos that you want to

see please leave a comment or if you just want to say hey what’s up what’s going on you know just

wake up for those in the middle of the night i get i wake up in a cold sweat and i’m like

it would really it really mean the world to me i would really appreciate it so again thank you so

much for watching this video and um enjoy the cool music as as i fade into the darkness which is

coming for us all

Thank you.

It should all work out according to plan, trust me.

Anyway, um, so…

The post AVL Trees: Adding Linear Data and Performing Rotations appeared first on NeuralLantern.com.

Learn AVL trees in this beginner-friendly introduction. We cover balance factors, why regular BSTs get slow, and how AVL trees stay balanced with rotations. Great for coding interviews and data structure understanding.

00:00 AVL Trees Introduction
00:00:28 Problems with Regular BSTs
00:00:56 AVL Tree Balance Rule
00:02:10 Balance Factor Explained
00:02:48 Computing Balance Factors
00:03:11 Example Tree Analysis
00:04:40 Imbalance at 65 Node
00:05:08 Invalid AVL Tree
00:06:18 Linear Tree Problem
00:06:50 Trinode Subtree
00:07:40 Selecting Z Y X Nodes
00:09:20 Rotation Overview
00:10:03 Next Videos Preview
00:11:09 Thank You and Subscribe

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to the Blog: https://www.NeuralLantern.com
• Watch the main “pinned” video of this channel for offers and extras

Hello there. Let’s talk about a type of self-balancing binary search tree called an AVL tree.

Okay, so by now I hope you’ve seen my other videos that I’ve posted

previously where we talked about binary search trees, how to define them,

terminology, how to know you’re actually looking at one, how to build them, insert,

If you finish those videos already with me, then you know that binary search trees can actually get slow sometimes because if we have bad data, regular binary search trees don’t really know how to rearrange themselves.

They just might become slow depending on how good or bad the data is.

The data is totally random.

Then on average, it’ll, you know, the trees will be log time, but that’s not always the case.

Maybe sometimes you have bad data, sorted data, poison data, whatever kind of data.

The secret to AVL trees is we’re going to start with the binary search tree.

And so first it has to satisfy all the rules of the binary search tree.

And then we add on another rule.

The rule is going to be that we don’t have a valid AVL tree.

If the balance factor for any of the nodes, we’ll talk about balance factors in a second.

If the balance factor for any node is two or worse.

Meaning if we think the tree is too imbalanced at any node, it’s not a valid AVL tree.

and therefore we must rebalance the tree with something called a rotation.

After we do enough rotations and we see that the tree is balanced again, then it’ll be valid.

And so AVL trees sometimes are invalid in some intermediate state.

Like if you have an AVL tree and you add some data into it,

for a moment it might be an invalid AVL tree and then internally it’s sort of just like rotating itself and rebalancing itself.

Then when the tree is done, you’ll have a valid AVL tree again, if that makes sense.

AVL tree again if that makes sense. So suppose this tree here we can tell this is a valid binary

search tree because it follows all the rules that we talked about before. So let’s start implementing

the first rule of an AVL tree which is let’s compute the balance factors for every single node.

How do we compute balance factors? The basic idea is I want to say BF for balance factor

the left subtree height minus the right subtree height.

If you don’t know what a subtree or height is,

you should probably check out my other videos right now.

But basically, we’re just going to take the absolute value

just to get the difference in the height of the left

and the height of the right.

So if you know binary search trees already,

then you know that the leaves, they don’t have any subtrees.

So their balance factor is going to be pretty easy to compute.

It’s just going to be a zero.

I should also point out that some other tutorials out there use positive and negative numbers

for the balance factor.

That’s okay.

I’m just going to use absolute values here because it’s a little bit more simple.

So all the leaves get a balance factor of zero, which is fine.

We’re looking to see if we can find a balance factor of two or worse to indicate to us that

we have an invalid AVL tree.

So far, so good.

Let’s look at the 22 node.

we’ll compute the height of the left subtree versus the height of the right subtree.

So, you know, I’m going to highlight its left subtree.

That’s just the 14 node that has a height of 1.

And then its right subtree is just the 36 node that also has a height of 1,

which means the balance factor for the 22 node is the absolute value of 1 minus 1 is 0.

So actually the 22 node is perfectly balanced.

If you think about it, that makes sense.

Left and right subtrees have the same height.

No problem.

have the same height no problem so I’m going to move on let’s compute the balance factor for the

48 node this is a little trickier notice how the right subtree has a height of one and there is no

left subtree which means its height is zero so for the 48 node it’s actually going to be

the absolute value of zero minus one or just one so we find our first node that’s a little bit out

imbalance here but avl trees tolerate imbalances of one they don’t really care we sort of try to

make a trade-off between constantly always rotating every single time anything happens

which would perhaps burn a little too much cpu versus letting the tree just be imbalanced to a

reasonable amount so we could still call this a log tree in the end so we consider this to be okay

65 node and compute the balance factor so 65 node has no right subtree so the height is zero there

and its left subtree is those two nodes on the left so that has a height of two which means the

balance factor for the 65 node is going to be the absolute value of two minus zero is two at this

point we are already certain that this is not a valid avl tree and it would need to be rebalanced

you know, consider it a valid AVL tree in the future.

So invalid AVL tree, still a valid binary search tree.

Something has to be done.

Normally what I would say is if you find some nodes

way down lower in the tree that are imbalanced,

then just go ahead and perform a rebalancing

or a rotation immediately,

because sometimes when you rotate lower in the tree,

you’ll end up fixing nodes that are a little higher.

But since we started with this tree

and we’re not kind of, you know,

building a tree step-by-step,

I just want to compute the balance factor for all of the nodes at the same time.

So we’ll do the same thing for the 41 node, the root node.

Its left subtree has a height of two and its right subtree has a height of three.

So its balance factor is the absolute value of two minus three is one.

So actually the root node is okay.

If it was only up to the root node, we would say this is a valid AVL tree

and we don’t really need to do anything.

need to do anything however we’ve already seen that the 65 node is invalid so again uh we we

need to do something here’s another quick example before we move on to actually identifying which

nodes to to modify and rotate just real fast i want to show you you know that a binary search

tree could actually end up being a linear tree if you had really really really bad data the binary

This is slow because this is a linear tree.

The time complexity of searching through this tree is linear time.

It scales linearly with the number of nodes in your data set.

That’s really far away from log time, which is supposed to be lightning fast.

So an AVL tree will fix this kind of bad data.

Let’s take a step back here and focus your attention for a second on these three nodes.

We noticed that there is one node that’s actually out of whack.

It’s the 65 node, right?

What we’re going to do is we’re going to find a trinode subtree that starts with the first node or the lowest node we can find that’s out of whack.

It’s the 65 node.

And you can tell that if we just kind of go down a level and down another level to select the other two nodes,

it’s just going to be this little, you know, subtree of three nodes or otherwise known as a trinode subtree.

So here’s kind of a diagram for that.

Whoops, forgot to delete that earlier.

Let me get rid of that.

So this is the trinode subtree that we selected, right?

So we’ve got the 65 and the 48 and the 55.

How did we actually select this?

So what you kind of want to do is the first node that is out of whack,

you want to call that Z.

So I’m going to write a Z here.

What we’re looking for is a trinode subtree,

which we’ll first call X and Y and Z.

And then we’ll end up reordering the nodes

and then rearranging all the pointers to the nodes

so that the trinode subtree is a little bit more in balance.

more in balance. So we see the Z node. We have to find the Y node next. To find the Y node,

what’s going on with my computer? Oh, there we go. We have the Z node. To find the Y node,

really, we’re just going to take the child of the 65 node that has the taller subtree. So

there’s only one subtree, you know, on the left, there’s no subtree on the right of the 65 node.

So the choice is obvious. But just so you know, if there was, you know, another, you know, child

another you know child hanging off of the right for some reason we would still choose the number

48 node as the y node because it has the taller subtree notice how the subtree on the left is two

and the subtree on the right has a height of one so always take the taller subtree when you’re

looking for uh y and then x so then we do the same thing we go down to the grandchild of the z node

and if we had a choice to go left or right again we would always choose the taller subtree in this

taller subtree in this case there’s only one choice so that x node is going to be the 55

now in this next slide i’ve kind of redrawn this in a little bit different of a way

notice the trinode subtree that we just selected here the 65 48 55 subtree it has a height of three

i mean that should be obvious right it’s just got a height of three

or height. Notice on the left, these are the same three nodes. Exactly. 48, 55, and 65. That’s the

same three nodes that we originally had. But notice how the height is too. So the basic idea for ABL

trees is, you know, compute the balance factors. And as soon as you identify a node that’s out of

whack, you grab a tri-node sub-tree starting at the node that’s out of whack, the Z node.

And then we’ll perform, quote unquote, a rotation where we just kind of smoosh it to be a little

be a little bit more balanced and a little bit more a little bit shorter so the height goes from

three to two once we do that the rest of the tree it’s going to get a little bit better you’ll notice

that this will end up sometimes completely but sometimes partially fixing bad balance factors

in the tree so um this is the end of the intro i only wanted to spend a little time just kind of

like warming you up to the idea in the next videos uh we’re going to actually look at performing

identifying the four different types of rotations that you could see and like how to do them.

We’ll talk more about the idea that we’re really just rearranging pointers here.

If you’re thinking about code, you’re thinking about, oh, I’ve got some pointers between these

nodes. We’re not going to delete any nodes or add any nodes. We’re just going to like

rearrange who is a parent of who, who is a child of who. And then eventually we’ll deal with some

really bad trees and we’ll become experts at just like maintaining ABL trees.

talk about ways to visualize the rotations, which makes it a little bit easier to remember these

patterns and stuff. Okay, so thank you for watching this video. I hope you learned a little bit of

stuff and had a little bit of fun. In the next one, we’re going to get started. We’re going to

go deep. I’m going to get my gear. Sorry.

Hey, everybody. Thanks for watching this video again from the bottom of my heart. I really

from the bottom of my heart. I really appreciate it. I do hope you did learn something and have

some fun. If you could do me a please, a small little favor, could you please subscribe and

follow this channel or these videos or whatever it is you do on the current social media website

that you’re looking at right now? It would really mean the world to me and it’ll help make more

videos and grow this community. So we’ll be able to do more videos, longer videos, better videos,

Do me a kindness and subscribe.

You know, sometimes I’m sleeping in the middle of the night and I just wake up because I know somebody subscribed or followed.

It just wakes me up and I get filled with joy.

That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could troll me if you want to just wake me up in the middle of the night.

Just subscribe and then I’ll just wake up.

I promise that’s what will happen.

Also, if you look at the middle of the screen right now, you should see a QR code which you can scan in order to go to the website.

in order to go to the website which i think is also named somewhere at the bottom of this video

and it’ll take you to my main website where you can just kind of like see all the videos i published

and the services and tutorials and things that i offer and all that good stuff and uh

if you have a suggestion for uh uh clarifications or errata or just future videos that you want to

see please leave a comment or if you just want to say hey what’s up what’s going on you know

I also wake up for those in the middle of the night. I get I wake up in a cold sweat and I’m like

it would really it really mean the world to me. I would really appreciate it. So again thank you

so much for watching this video and enjoy the cool music as I fade into the darkness

which is coming for us all.

Thank you.

The post AVL Tree Tutorial: Balance Factors and Why They Fix Slow BSTs appeared first on NeuralLantern.com.

In this video we walk through how to perform searches in a Binary Search Tree. Starting with a perfectly balanced BST, we cover the search process step by step, including finding existing nodes like 73 and determining that numbers like 44 do not exist in the tree.

We discuss time complexity for searches in BSTs – O(log n) on average for balanced trees and O(n) in the worst case when the tree becomes skewed like a linked list due to sorted or bad data. Learn why each comparison eliminates half the remaining data and how height affects performance.

Perfect for students learning data structures and algorithms. If you’re studying BSTs, this clear explanation will help you understand searching, insertion paths, and why self-balancing trees matter.

Thanks for watching!

00:00 Introduction to BST Search
00:31 BST Not Self-Balancing
00:40 Average Case Log Time
00:53 Linear Time in Worst Case
01:13 How BST Search Works
01:18 Search Path Example
02:08 Searching for Existing Node
02:35 Searching for Non-Existent Node
03:19 Tree Size and Height
03:30 Time Complexity O(h)
05:40 Bad Data Example
08:23 Skewed Tree Like Linked List
09:53 Linear Time in Worst Case
11:58 Why Log Time
12:36 Halving the Search Space
14:14 O(log n) Summary
14:28 Conclusion

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to the Blog: https://www.NeuralLantern.com
• Watch the main “pinned” video of this channel for offers and extras

hey there let’s perform searches in a binary search tree

okay if you watch my previous videos you know how to define a binary search tree by now

you know some terminology you know how to construct a tree and so now let’s just take

a tree that’s already been constructed and let’s search through it first thing i want to say is

first thing I want to say is this is a binary search tree this is not a self

balancing tree so in the future this tree could get lopsided and messed up

depending on what kind of data we add we can always expect that binary search

trees have a search time or an insert time or removal time of log log base 2

of n on average assuming that the data is random or in the worst possible case

scenario linear time so these could get slower right now you can see this tree

Right now you can see this tree is perfectly balanced.

So if we say that our tree is currently perfectly balanced and it’s always going to be perfectly balanced,

which is a fantasy, but let’s just say that it is,

then we could just say it’s a log tree.

It’s going to take log time to search through.

So how do we perform searches?

Again, if you saw my previous videos, you should know that it’s really easy to find out where a node belongs.

Like for example, if I was going to add the number 14,

I would first look at the root node and I’d say, okay, the root node is occupied.

and I’d say, okay, the root node is occupied.

And so where would 14 belong?

Well, it would belong on the left of 37

because it’s less than 37.

It would belong on the left of 16

because it’s less than 16.

It would belong on the right of 9

because it’s greater than 9.

It would belong on the right of 11

because it’s greater than 11.

And so the 14 node that we just wanted to add,

is that what I just said, 14?

Would end up going there.

So when you’re searching through a binary search tree,

you really just have to go find

have to go find where the node would belong as if you’re performing insert or you could think of it

the other way around like insert is really thinking of a search first but basically we’re just going

to start by saying you know pick a number and we’ll see if it exists so uh let’s pick the number

67 or actually let’s pick the number 73 just to see if it exists in the tree so 73 i’m going to

do like you know seven three with like a question mark we check the root node 73 belongs on the

side we look at the 59 it belongs on the right side and we found our 73 so 73 exists in the tree

and it only took us three examinations only three examinations let’s look for a number that doesn’t

actually exist in the tree so maybe oh my thing is freezing what’s going on okay so maybe uh let’s

The 37 here, 44 belongs on the right of 37.

We look at the 59, it belongs on the left.

We look at the 48, it belongs on the left.

We look at the 43, it belongs on the right.

The 44 would have been there, but it’s not because that right child pointer off the 43

is null.

So we only had to really examine one, two, three, four nodes in order to determine that

our number 44 didn’t exist in the tree.

Notice how we’re not doing a lot of examinations compared to the total size of the tree.

compared to the total size of the tree.

So let me just write this up here.

How many nodes do we have?

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15.

We got 15 nodes up here.

Someone say N is equal to 15.

And what’s the height of the tree?

Remember, the height of the tree is the number of nodes you must touch

as you make your way down towards the deepest node.

Or if you’ve already found the deepest node,

you take its depth and you just add 1, assuming that depths start at 0.

start at zero. So I’ll just say that the depth of the root node is zero and the 59 and the 16 are

one. And then that third row is two. And that last row is three. And then I just add one to the

deepest node that I can find, which is just going to have a depth of three. All of these on the

bottom row have a depth of three. So the height of this tree is actually four, because we would

so like 37 59 48 43 that’s four touches um or the or the depth of the deepest node plus one okay um

all trees all binary search trees whether they’re actually avl trees or regular binary search trees

or whether they’re balanced or imbalanced they’re always going to have a time complexity to search

through of o of h meaning in the worst case scenario you’ll have to touch h number of nodes

order to find a node by search query or to add a new node or even to delete a new node.

So how does that compare to this tree in reality?

Let me just open up a little calculator real fast.

I just want to show you.

So if we do log base two, because we have a binary search tree, not a trinary search

nodes 15 it tells us that it should take us no more than four examinations to find the node that

we’re looking for if the tree was perfectly balanced and if you if you if you notice that’s

exactly what the height is telling us here if the tree was more imbalanced the height would get

really bad compared to the number of nodes and it would no longer be considered a log tree it would

just be you know somewhere in between linear time and log time um let’s see what else can i show you

let’s do well we did that computation let’s do a search through the tree that

through a tree that’s actually really really bad let’s pretend that we have a

bunch of nodes here and you know I’ve got an old story that I love to tell

about this when like when my grandma was alive she was kind of bitter towards the

end you know I loved her but she used to call the cops on her neighbors for

gossip and at some point in time she got into a feud with her neighbor who was

with her neighbor who was also a bitter old lady.

You know, towards the end, it kind of happens sometimes.

It sucks, but it happened.

And I guess the neighbor didn’t like my grandma’s tree

that she had in her backyard.

So they fought over it, they argued over it,

and then one day my grandma said

she was looking out the backyard window

to yell at ducks who were jumping into her pool

because she just hated when the ducks went into her pool.

She was waiting for them to show up.

She wasn’t even looking at ducks.

even looking at ducks she was just waiting and she saw the other little old lady reach her arm over

the fence and spray my grandma’s tree with some sort of poison then my grandma’s tree died and uh

i guess you know my grandma never never got over it i always thought it was like a funny story it

was a little sad but um she poisoned my grandma’s tree so we can kind of do the same thing with the

binary search tree we can give bad data let me show you what happens here if i use this data set

search tree. So we’re going to add this node right here. It’s going to be the 14.

And then when we add the 19 node, I’m just going to duplicate it. The 19 is supposed to be on the

right side of 14 because it’s greater than 14. So I’m just going to like, you know, draw a 19 right

here and a little connecting line. Okay. Then when we add the 24, I’m going to duplicate this node

the 24 go belongs on the right side of the 14 and also belongs on the right side of the 19

because it’s greater than 19 so again we have a node that shows up on the right side let me

remember to actually fix the 19 so it looks like 24. then when we add the uh 29 it’s gonna end up

being the same thing right the 29 is gonna end up showing on the right the right the right it’s

If we have bad data, we can end up with a tree that kind of looks like a straight line.

And if you are watching this video from the future,

after I’ve posted all of my data structures videos that I have,

you might notice that this looks like another data structure.

If you’re watching this right away, I haven’t posted those videos just yet.

But just tilt your head to the right a little bit

and tell me if that looks like something that you recognize.

It looks like a linked list.

looks like a linked list just like a straight line or even i guess you could kind of say maybe an array

um just like a straight line of data there’s no uh you know there’s no splitting of the data

so we have the 29 and then the 35 and then uh maybe i’ll just do one more node only and i’ll

get rid of that 54 because that’s too many nodes so what happens is if you have you know bad data

tree doesn’t actually search or add insert or remove or anything like that in log time anymore

instead it operates in linear time just like a linked list would meaning we would have to scan

through every single node in the entire tree to be sure that some value did not exist well

not exactly but in the worst case scenario we’d have to scan through the whole entire tree

for example let’s just look at the the number of nodes real fast we’ll say the

number of nodes here is one two three four oh I put two 24s in there oh dearie

let me get that says 14 19 24 29 and then I guess I got to make that a 35 oh

okay and then there’s a 49 I guess I did add every single node okay so we added

so there’s like seven uh items in the tree so i’m going to say n is equal to seven the height also

is seven though so the height is seven notice how if we say that it’s always true that a binary

search tree has a time complexity in the worst case of o of h meaning you’d have to go down

in the worst case the number of levels that is equal to the whole entire height of the entire

tree that’s also the number of nodes in the tree which means uh if i wanted to add let’s say the

I don’t know, if you wanted to add the number 60,

60 would end up going down here.

And in order to find where 60 would go,

we’d have to look at the 14, that’s 1, 19, 24.

We’d have to look at all these nodes.

That is seven nodes.

We’d have to examine seven nodes

just to figure out where the 60 would go.

Or if we were searching for 60,

then we’d have to go down that far

to find out that 60 didn’t exist.

So this is nowhere near a log tree.

This is a linear tree, a linear time tree.

year time tree and just to drive the point further if we did log base two of the number of nodes in

this case seven notice how it’s telling us that we should if it was a log tree if it was perfectly

balanced or a self-balancing tree we should have to touch no more than three nodes in order to find

what we’re looking for to search through the tree or to insert a new node or even to delete a node

but that’s not the case here because the tree is really really slow compared to a perfectly balanced

slow compared to a perfectly balanced tree.

So we call this a linear tree.

It sucks.

You want to try to avoid that.

You don’t want your data to be poisoned.

On average, your trees won’t really look like this if you just have totally

random data, but if you think there’s a chance that your data might be skewed

in some way, it’s probably a good idea to upgrade to a self-balancing tree,

which we’re going to talk about later.

Okay.

What else can I tell you real fast?

So we talked about searching.

why are these trees considered log time? I mean, they’re really, really fast, but why?

Let’s just duplicate this slide here and I’ll move it down one level. I just want to kind of

show you why this ends up being a log time tree. Okay. So why, why is this a log time tree?

Suppose for the sake of argument, we’re searching for the number 52. So if we’re searching for the

node the root node and decide where would the 52 belong let me actually write that down so i don’t

forget 52 question mark where would the 52 belong it would belong on the right side of the 37 because

it’s greater than 37 right which means it’s actually impossible that the 52 would be in any

of these other nodes on the left side there’s no need to check them we’re not going to scan the

whole tree we’re just going to go left or right and ignore the whole other side of the tree

we just did is with one examination we eliminated half of the remaining data set or i guess of the

initial data set if we’re looking at the root node so then the next thing that we do is we just kind

of say okay it belongs on the right side so we look at the 59 node and we do the same thing we

say where would 52 be would it be on the left side or the right side of the 59 node it would be on

the left side which means we’re going to eliminate from consideration the entire right subtree of the

So again, we’re eliminating half of the remaining data set.

Then we kind of go down here and we look at the 48.

We do the same thing.

52 belongs on the right side.

So we eliminate half of the remaining data set, you know, and then eventually we do find

the 52 and then that’s it.

So if we’re eliminating half of the data set with every single, just one examination at

a time, that’s why it ends up being log base two.

getting twice as close to your destination at every step you took if you’re like in a car like

running maybe you’re on the moon or something then it would be a log time you know uh progress

towards your goal or eliminating half of the data set at every single step sometimes people see

for loops on exams and stuff when we talk about this um like for i equals zero uh i is less than

it would be like i times equals two.

So i’s jumping twice as far each time.

That’s the sort of thing that makes it log.

So I’m just going to write down log here real fast

to drive the point home a little bit more.

O of log base two of n.

Yeah, so I guess that’s all I wanted to tell you in this video.

Hopefully you feel like an expert in searching now.

If you want to see more searching videos,

leave a comment or something like that.

leave a comment or something like that. But yeah, thank you for watching. And I hope you

learned a little bit of stuff and had a little bit of fun. I’ll see you in the next video.

I’m going to go find a blueberry muffin.

Hey, everybody. Thanks for watching this video again from the bottom of my heart. I really

appreciate it. I do hope you did learn something and have some fun. If you could do me a please,

subscribe and follow this channel or these videos or whatever it is you do on the current social

media website that you’re looking at right now it would really mean the world to me and it’ll

help make more videos and grow this community so we’ll be able to do more videos longer videos

better videos or just i’ll be able to keep making videos in general so please do do me a kindness

and uh and subscribe you know sometimes i’m sleeping in the middle of the night and i just

It just wakes me up and I get filled with joy. That’s exactly what happens every single time

So you could do it as a nice favor to me or you could you control me if you want to just wake me up in the middle

And I just subscribe and then I’ll just wake up. I promise that’s what will happen

Also, if you look at the middle of the screen right now

You should see a QR code which you can scan in order to go to the website

Which I think is also named somewhere at the bottom of this video and it’ll take you to my main website where you can just kind of like

and the services and tutorials and things that I offer and all that good stuff and

if you have a suggestion for

Clarifications or errata or just future videos that you want to see please leave a comment or if you just want to say hey

What’s up? What’s going on? You know, just send me a comment, whatever

I also wake up for those in the middle of the night. I get I wake up in a cold sweat. I’m like this

It would really it really mean the world to me. I would really appreciate it. So

So again, thank you so much for watching this video and enjoy the cool music as I fade into the darkness, which is coming for us all.

Thank you.

The post How to Search in a Binary Search Tree (BST) – Step by Step Explanation with Examples appeared first on NeuralLantern.com.

Join me as I break down a simple yet powerful x86-64 YASM assembly program to copy files using system calls! Learn how to open input files, create output files, and use a looping buffer for efficient data transfer. I’ll demo the code, explain file handles, permissions, and error handling, and even verify the copy with MD5 checksums. Perfect for intermediate assembly programmers or anyone curious about low-level file operations. Check out my other videos for more assembly tips, and don’t forget to subscribe!

Introduction to File Copy Program 00:00:00
System Calls in YASM Assembly 00:00:06
Opening Input File 00:00:17
Creating Output File 00:00:22
Using Looping Buffer 00:00:28
Assembly Program Prerequisites 00:00:37
Overview of Source File 00:00:53
Data Section and Strings 00:01:06
Copy Buffer Length 00:01:21
File Permissions Explanation 00:02:05
System Call Codes 00:02:57
File Descriptors and Exit Codes 00:03:24
Text Section and Entry Point 00:03:45
Welcome Message Function 00:04:01
Print Null Terminated String 00:04:16
Running Initial Program 00:06:26
MD5 Checksum Explanation 00:07:00
File Tests Function Introduction 00:07:28
Open File Read Function 00:09:52
Checking File Handle 00:14:00
File Handle Concept 00:14:25
Error Handling Importance 00:15:24
Testing File Open 00:23:00
Create File Function 00:31:16
Testing File Creation 00:32:36
Copy File Function 00:36:14
Stack Buffer Creation 00:38:16
While Loop for Copying 00:40:14
Read System Call 00:40:47
Write System Call 00:45:03
Checking Read/Write Operations 00:46:51
Final Program Run 00:49:00
Verifying File Copy with MD5 00:49:22
Testing with Larger Input 00:51:20
Optimizing Buffer Size 00:53:41
Conclusion and Call to Subscribe 00:54:41

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

Hey everybody in this video i’m going to show and explain a simple program that copies a file

using system calls in an x8664 yasm assembly program

we’re going to use the system calls to open an input file and read characters from it we’re

going to use another system call to create a destination file and write characters to it

we’re going to use a looping buffer,

which should be kind of fun in the middle.

And I’m just going to do my best to explain as much as I can.

I should say though that before you can watch this video,

you probably already need to know how to program an assembly,

at least in a basic level, Yasm assembly.

And so if you don’t know how to do that yet,

this video is probably going to be confusing for you.

You probably need to look at my other videos dealing with Yasm assembly and

system calls and so forth.

So I’m just going to show you real fast what’s actually going on in this source

actually going on in this source file so far.

So this is my assembly program.

It’s not finished.

I’m going to write it on screen for you.

For the most part, you can see I’ve got a data section here and then I just have a

bunch of null terminated strings.

So I’ve got a string saying, hey, the module started.

We’re about to open the file.

We’re about to create the file.

We failed to do something.

We’re done copying.

You know, we terminated the program, you know, whatever.

Right. So I just have some strings.

No big deal.

Down here, I have something called the copy buffer length, which is which is just

length with just which is just the size of the buffer that I’m going to use

between the input file and the output file so a two byte buffer is really

inefficient it’s too small but I made it two bytes just to show to you that are

looping you know a read area is going to actually work because if I make a buffer

that’s too big if it’s bigger than the file then we won’t actually know if the

if the buffer loop works or not so I’m just gonna put two here could change

that later if we wanted to we’re gonna be reading from a file called input and

called input and writing to a file called output so that’s no big deal in order to open a file with

a system call for read mode we’re just going to use a zero as the flags that just means read mode

and then for the creation of the file we’re going to use some standard permissions this is not a

permissions video I’m going to probably release a permissions video at some later point in time

not too important right now but basically this 640 is the heart of what permissions we’re actually

what permissions we’re actually looking at.

Q is quad word.

And six just means that the owner can read

and write to the file.

Four means that anyone who is in the same group

as the file has been assigned to,

which is usually the owner,

can just read it but not write to it.

And then everybody else,

people who are not the owner

and who are not in the right group,

they have no access to it.

Just a simple security feature of Linux

for file permissions.

You can go a lot further than this in the terminal,

in the terminal, but for this assembly program,

we’re just gonna use basics.

We’re not gonna use ACLs.

I don’t even know how to do that in assembly.

System call codes.

So again, if you don’t understand system calls,

you gotta watch my other videos first,

but we have a code of zero to read from a file,

one to write to a file, two to open a file,

three to close and open file.

Probably should have put that one before create,

but I don’t really care.

85 is the code to create a file for writing,

to create a file for writing and then 60 is the code to exit from the program.

So then we have file descriptors.

Descriptor number one is a standard output.

Descriptor number two is standard error.

And it’s always one and two, no matter what program you’re dealing with.

Unless you have some kind of really crazy non-standard thing going on.

And then for the exit codes, we’re just going to say exit zero for success and exit one

for failure.

Now to the actual tech section where our instructions are in the assembly program.

in the assembly program.

So you can see section text here.

We’ve got a global entry point called underscore start.

So this is not a GCC program that requires a main entry point.

This is a pure assembly program that requires

an underscore start entry point.

Again, see my other videos for more assembly explanation.

I’m gonna call on a method,

well, not a method of regular function called welcome.

Just to print a little welcome message,

you can see right here, that’s all that’s doing.

It’s just loading, you know, a string,

sending it to standard output, and calling on a helper function that I made called print null

terminated string. When it’s done with that, it just uses the call code to exit the program.

No big deal. Nothing too advanced so far. I have the tests function commented out because I want

to write that in front of you. And if you look at what I have inside of print null terminated string,

this is not the point of the video, so I’m just going to skim it. It’s not super important.

called print null terminated string that takes in a pointer to a character array

and a file handle for where you want to print it and what it’ll do is it’ll come

in grab the incoming arguments it’s only got two arguments so it uses r12 and r13

to store those arguments and then r14 is the result of calling another helper

called string length you can imagine my string length function just kind of

scans the string until it finds a null terminator aka the number zero not the

zero but actually a zero in order to figure out how long the string is and then it can use a

regular system call to print the string to the right file descriptor so we’re going to be doing

most mostly this kind of this exact same thing when we copy the file so I’m just definitely not

going to explain it if you don’t know pushes and pops and epilogues and prologues see my other

videos crlf is just going to print a carriage return new line so it or sorry carriage return

sorry, carriage return line feed.

So that’s just like making the cursor go to the next line.

Not a big deal.

We just print a string basically.

And then I have a custom die function

that allows us to die with a failure code of one.

Oh, I forgot to mark that.

Let’s see, 206 exit fail.

I’m just gonna put that down here.

Yeah, instead of hard coding values,

it’s a lot better to use variables if you can or defines.

So all that’s gonna do is just kind of print

an error message and then exit

then exit with the you know the appropriate

Exit code which is just going to be one because this is a simple program

So CRLF print an alternated string dying string length a welcome message all this fun pretty stuff

That doesn’t really do anything except make the program more fun to look at so I’m going to run it here and make sure that actually works

Okay

Nice, okay, so if I run it you can see that the the make file system again

file system again this is not a make file video so I’m not going to show you

my make file see my other videos if you want to learn more about make files but

you can see that the assembly program says that it started and then it just

exited then the make file continues to run these extra commands that I have

set up so this is not part of the assembly program this is just taking a

checksum an MD5 checksum of the input file and then an MD5 checksum of the

what empty five checksums are i’ll probably release a video sometime in the future if you’re

interested on all my platforms just talking about why we why you would use a checksum but for now

just imagine this is a fingerprint so if the fingerprints don’t match that means the files

don’t match right now the output file doesn’t even exist so it just is an error and that’s why the

make file thinks there’s an error because the output file didn’t exist so that’s the basics

of kind of getting started with this you know bare bones program now let’s start looking at running

program. Now let’s start looking at running the file tests. So file tests, we got to make a new

method. I’m going to stick it down here. Let’s see. I got a solution up so that I don’t have to

spend too much time typing. I’m going to try my best to balance between copy pasting and just

typing very quickly. But let’s see, where’s the file test? So we got this. I’m going to put the

I’m feeling pretty lazy.

I’m just going to copy paste the whole thing.

Copy paste the whole thing.

So now this method right here is going to get called the file tests.

I keep saying method because I teach C++ a lot too.

File tests.

If we go down further, this function is called file tests.

Here’s the signature.

It doesn’t take any arguments.

It just kind of does stuff.

It doesn’t return anything.

And here are the registers that I’m going to use.

the input file handle, the output file handle, and then the count of bytes read from the input

file at any given time inside of our looping buffer reader section. So the first thing I’ve

got to do is I’ve got to open a file to read. The second thing I’ve got to do is create a file to

write. And then I’m going to copy the input file to the output file. And then I’m going to print

a message saying, hey, everything was successful. And then I’m going to close both files. Notice how

anything i’m just sort of calling other functions do the work for me again if you don’t know the

prologue and epilogue stuff or calling functions and returning you should see my other videos

but i just like to use helper functions assembly is like so unwieldy right it’s it just gets out

of control so quick and so confusing so fast so anytime you can just you know take a chunk out

of your assembly code and move it somewhere to another module or to another function

going to make your life a lot easier and make debugging a lot easier people who try to write

the entire portion of their program in just one gigantic function those are the people who usually

end up spending 10 times longer debugging for no reason at all so i believe in the power of modular

thinking so anyway what are we going to do inside of the open file read function it’s not too bad

to be honest let’s see if i can find it real quick open file read i’m going to copy paste it because

Again, I’m pretty lazy.

I’ll just explain what it is though.

So down here we need a function called open file read.

So I’m just going to do that.

And you can see the signature that I’ve chosen for this is, you know, I like to

write all my functions in C++, uh, kind of lingo or prototypes so that I can have a

better understanding of what the assembly is actually supposed to do.

So you can see the function called open file read.

I want it to take two arguments.

two arguments the first argument should be a pointer to a string that represents the file

name that i want to open and it should be null terminated again if you look back at my uh at

my strings up here they all have little zeros at the end so they are all null terminated anyway uh

so that’s the first argument that’s going to show up as rdi in assembly and then the second argument

is the flags for opening the file so i think probably that was redundant if i if i name this

that was redundant if i if i name this open file read then i think it should be obvious that the

flags are just going to be the read flags only so i probably didn’t even need to provide this

that was bad design on my part you could write a better one on your own where it’s just one argument

and if the name is read then just use the read flags but if the maybe if you want to leave the

flags in there you could just say open file only it’s up to you anyway so it attempts to open a

successful it’ll return the file handle that’s the long return type right here

long file handle if it fails then it will just basically complain and exit

the program you probably want a more sophisticated way of handling errors in

your program I just decided to complain and exit the entire program because this

is you know not supposed to be super complicated I just want to show you how

to copy files and then for me I like to leave comments that just sort of explain

And once my functions get so complicated that I actually run out of registers,

then that tells me I probably need to just make another function,

you know, split the work up in some way.

So far, so good.

I only end up reusing the same registers for multiple purposes occasionally.

I’m not a hardcore assembly programmer.

I’m just, you know, I’m like medium.

So I’m going to use R12 and 13 and 14.

That’s why we have the prolog pushing all those registers to preserve them

pushing all those registers to preserve them because they’re callee saved and then the epilogue

epilogue that just kind of pops them i’ve got a label here for the function remember a function

is just a label and then a return statement as long as you obey and respect the abi like preserving

certain registers then you should be okay first thing i’m going to do is grab the incoming

arguments so i’m going to grab the file name which is a pointer which means it’s just a 64-bit

integer i can stick that into a register and then the flags same thing so i’m going to grab

rdi and rsi the incoming arguments i’m going to stick them into r12 and r13 so the character

pointer in the flags and then i’m going to attempt to open the file with a system call so

system call is right there line 168 if you look up the table for system calls in my favorite book

that i usually recommend or any table that knows the system call codes for x86-64 assembly

call code to open a file is some number i’ve assigned that to sys open if we look up here

open is code 2 so that’s why i you know i don’t want to remember the numbers it’s bad to hard

code number so i just i just put it as a define and then the first argument that it wants in rdi

is the name of the file so i just gave it r12 i guess i probably could have just used rdi

directly in the system call but that tends to make me nervous reusing the argument registers

registers, I like to have them somewhere where they’re not going to be destroyed.

If I like, let’s say I accidentally added some code here on line 163.

If I wanted to reuse RDI and I accidentally added some code there,

then RDI would have been destroyed.

Would have cost me a bunch of time debugging my program.

Although I admit it’s not super efficient to do it that way.

Then we’re going to do the file status

flags as the second argument, and then we just do a system call right away.

register gives you the result of your system call.

Notice how we use RAX to send in the call code.

And then the system call sends us back its return result also in the RAX

register. So I’m just going to save that right away to R14.

You can see up here, it’s just the file handle.

So we can assume maybe at this point that we have a file handle sitting in R14.

You know, what is a file handle when you ask the system to open a file for you?

The operating system under the hood is just going to do a bunch of stuff to

bunch of stuff to actually open a file it’s going to go it’s going to take the string

that you sent it and it’s going to parse it and figure out you know how do i how do i interpret

where that actually is on disk i’m going to look at like the file system in the past that you

provided i’m going to look at the mount points and i’m going to figure out like where exactly on disk

does that file start and then the operating system stores that the operating system stores the file

name it stores where you’re looking at the file currently stores a bunch of stuff that you don’t

a bunch of stuff that you don’t want to have to remember you know it creates data structures under

the hood and all it’ll give you back in return is a file handle for simplicity because then later

you can use that file handle to just sort of say I would like to write some bytes to a file or I

would like to read some bytes from an open file here’s the handle you gave me previously and then

it’ll just work assuming you have a valid handle so the handle is kind of the most important part

failed because it’s a mistake i’ve said this in other videos it’s a mistake that new programmers

make or lazy programmers make uh let’s suppose for the sake of argument uh uh file open sys call

pretend we’re in c plus plus and there is some sort of an api function that we can call either

directly to the system or some person’s library and it’ll open a file for us so maybe like a

just say we call this right so i’m going to do like a little comment if inside of your program you just

call it with the you know some some path and then you assume that what you have is a valid you know

handle if you assume that what you got back is a valid handle or maybe this is not a function

just assume that the call succeeded, your program is probably going to have errors when you least

expect it. And it’s not going to look good. Especially if you release a function like this

to the public, or if you have like a professor who’s like grading your code and they are testing

to see if you’re checking for return codes and stuff like that. That’s not a smart idea, right?

Like you shouldn’t, should not, shouldn’t proceed as if everything went according to plan. What,

just proceeding as if everything went according to plan.

You want to use an if statement, right?

You want to say if the handle has some value that seems to be valid,

like for example, more than zero in the case of opening a file,

I would say probably more than two because all of our programs

always have automatically assigned file handles of zero and one and two

to represent standard input, standard output, and standard error.

But I think usually people just say like,

if it’s greater than zero, then it’s fine.

zero then it’s fine uh you know for me i might put greater than two but more than zero is fine

the point is check to make sure that it actually succeeded

do i have spell check on this thing oh god you’re all going to see my true spelling let me see if i

can get it on real fast plug-ins what how come this oh okay now it’s highlighted

If we’ve succeeded based on some kind of a comparison of the return result,

then we’ll proceed in one way.

Otherwise we’ll respond to the error by, you know, doing something else.

Somehow, like writing a log file, sending an email, complaining to the user,

doing any number of things where you can actually respond to the error.

Maybe you probably want to change your execution path.

Like if the file successfully opened, then go ahead and start writing to it

or reading from it or whatever.

But if the file did not successfully open,

want to do something else in the program and not just start trying to read from the file so anyway

super super good idea and so that’s why i’m going to implement that inside of assembly 2. so instead

of just immediately using the file handle i’m going to check it i’m going to say let’s compare

it to the number zero if we succeeded then let’s go to another label called uh read success i

personally when i’m doing branching logic i like to say open file read is the name of the function

read is the name of the function and I’ll just I’ll just uh uh append some kind of a suffix

to the original function name that way it’s it’s easier to avoid collisions when you have lots of

functions and lots of labels and things like that so I’m basically saying if we succeeded I’m going

to jump to this label which is down here and so uh this video also is not about branching logic

and and how to implement those instructions you can probably infer it by looking at my code but

it by looking at my code but you know see another video in the future for that topic anyway if we

succeeded in opening the file handle then we’re just going to say oh we were successful and then

we’re going to uh um let’s see we’re going to print the name of the file that we just successfully

opened and then we’re going to send the file handle into rax so that this function has a return

So when you open a file to read successfully, the caller will receive the file handle.

You might be wondering yourself, wait a minute, wait a minute, wait a minute.

It just gave us the file handle in RAX.

Remember, we got to respect the ABI.

Anytime we jump anywhere or call another function or call another syscall,

which a lot of these things do,

we will probably lose the value of registers that are not callee preserved.

And that’s definitely RAX.

I mean, just doing any system call like this print null terminated string function does.

print null terminated string function does that’s going to destroy rex so that’s why i saved it away

first in r14 then at the very end of the function right before i return i’m just going to grab r14

and send it into rex again respect the abi do not return data as a return value in r14 or any other

register you have to use the designated registers and in this case an integer that you’re returning

x anyway so that’s the gist of that let me go back up for a second uh so notice how

we’re we’re sort of comparing oh gosh i just i just reconfigured my annotator and i bought a

new drawpad i wonder if this is going to work ah it works there’s a bunch of stuff i added too

so notice how uh we try to open the file and then we sort of compare the file handle to see if we

off to the success area down here oh my green’s not working oh it’s tricky it’s tricky i gotta

hit it in a certain way there we go if it succeeds we go down here to the success label so we

basically at that point um totally ignore all of the fail code right we’re just like branching

around on the other hand if it fails then execution falls through because it’s not going to jump

if uh if if r14 is not greater than or equal to zero so if we fail maybe i should put this in a

red if we fail then it’s going to fall through to the next label and then the next instructions

some people like to say let’s uh let’s jump to the success label and then if not let’s jump to

the fail label that can buy you a little bit more uh i don’t know jump length if you have a giant

program but in this case i’m just going to let it fall through it saves us one jump instruction

and so if it fails then it’s going to say first off let’s print a message that we failed

to standard error if you want a refresher on standard input standard output and standard error

see my other videos and then it’s going to print the name of the file that failed so that’s this

part right here it’s going to say hey we we failed to print or sorry we failed to open this file name

for reading and it’s going to print a new line there with the crlf thing

and then it’s actually going to exit the program at that point it’s going to say all right we

failed and so the whole program just just quits and that’s my die function that i showed you

earlier it’s just going to call the system call code for quitting and it’s going to give a return

code of one to indicate to anyone automating our program including new make that well our program

failed at least it failed okay so we got all that and then we got the success and so now you kind

of know the idea behind opening a file let’s do that real fast just for fun so file tests

um oh i know what to do i’ll just comment out these uh instructions just so that we’re only

doing the file open yeah that’s pretty good and then we won’t close anything just yet

so now let me run this in the terminal real fast make run it says it successfully opened

it says it successfully opened the file input.txt

and then the program exited.

No problem, that error code one,

that’s because the output file doesn’t actually exist.

So don’t worry about that.

And let’s change the name of the input file

just to show you that it can fail and we can detect it.

I’m gonna put a two there

so that the program will try to open an input file

that doesn’t actually exist.

And then I’ll run it again.

Notice how it says fail to open file input2.txt.

And then it says terminating program after failure to open file.

And then this time, notice how the make file never got far enough

so that it tried to print the MD5 sums of the input and output files.

The assembly program just failed.

And so GNU make said, I’m not going to proceed any further.

Kind of useful when your program gives good exit codes, right?

Because then other programs know when to stop

or maybe what to do depending on what’s happening.

So I’m just going to fix this real fast.

down here and maybe the next thing I want to add is closing the files so we’ve got a function to

open a file for reading and then we have a function down here that is not implemented yet

for closing the files so I’m going to do let’s see what is r12 r12 is the input file so I’m

going to close r12 so basically this function it’s going to it’s going to take one argument

handle. So that’s why I’m giving the file handle of the input file as the first argument. And then

I’m just going to call it. So let’s copy paste close file underneath this. So I’m going to do

like some more space. And let me let me go get this from my solution close file.

And it’s going to be a pretty simple one. Really nothing much to it. I’m just going to write my

C++ prototype saying, well, it takes in one argument and it’s a handle. It doesn’t return

argument and it’s a handle it doesn’t return anything it attempts to close a

file and I’m just gonna use R12 to hold the incoming argument your programs at

home should probably be a little bit better than mine you should check to see

if the file successfully closed or not and respond in some kind of a way but

for me I’m just saying I don’t really care I already showed you that we can

check for a return value so I’m allowed to be lazy now and just sort of try to

close it and then just assume it all went according to plan so grabbing the

So grabbing the incoming arguments here.

That’s why I’m using R12.

That’s why I’m doing a push-pop pair.

And then the system call code to close is pretty easy.

You just say, here’s the code to close.

Stick that in RAX.

Let me go up real fast.

Notice how sysclose is the call code number three

on line 43 there.

So I send it the call code three to say, let’s close a file.

It only wants one argument, which is just,

what is the file handle that you want me to close?

what is the file handle that you want me to close remember before the operating system created a

bunch of stuff under the hood and gave you a file handle you can then use the file handle

to close a file read a file write to the file whatever to the file so it’s pretty easy once

i’ve set up the incoming arguments to the system then i actually use the system call instruction

syscall and then i can assume it’s probably closed at that point then a return statement at the end

like any additional thing happening.

It should just be, it said it successfully opened the file

and then it just exited.

Okay, now we’re ready to add a little bit more.

Let’s create a file to write.

So this is going to be the same thing basically

as opening a file to read,

except it’s going to be a different call code

and we’ll give it initial file permissions

rather than a read mode flag.

But then we’ll just get a file handle in return.

get a file handle in return.

And I’ve also stuck this into another function, of course.

So the file name to write line 109.

If you just scroll up real fast here, or if I scroll up real fast,

it’s a line 27 here, just output.txt.

And then the file permissions that we want to use.

I’m going to scroll up here.

That’s the second argument to the system call code.

That’s just the stuff that I talked about a little while ago where it’s like,

we want the user to be able to read and write to the file.

to be able to read and write to the file we want people in the same group to be able to read only

and we want everyone else to not be able to do anything basic linux permissions not a big deal

at the end you should probably maybe note that uh you know this q i think i might have said this

before this q just means quad word and these zeros are always going to be the same so really it’s just

like three numbers representing file permissions i’ll go over that in more detail in some other

So for now, we know that we’re going to open a file name to we’re going to open a file

for writing doesn’t have to exist yet.

We’ll give it some default permissions.

And those are the incoming arguments to the function that we’re going to call now called

create file.

When that file when that function comes back, assuming it didn’t decide to exit the program

because we failed to open the file, we will receive the file handle in our ex per usual.

And so I’m just going to stash that away real fast into our 13.

Remember R12 has the handle to the input file.

R13 has the handle to the output file.

And then, you know, for me personally,

I put that in comments to help myself remember

what I’m even doing,

because things can get confusing really, really fast.

And while we’re at it,

before we even write the create file function,

I might as well just uncomment these things at the bottom,

just to say, let’s close both files properly.

You always want to do that.

let’s copy paste the create file function let’s see I didn’t do that already right yeah okay

so let’s do that maybe like right here I’m going to go grab it from my solution real fast create

file okay about as complicated as opening a file just because I put in some some checking logic to

see if it successfully opened the file which is a good idea so here’s my function create file

arguments. Oh shoot, file creation hand. Let’s see, am I using R13? Yeah, oh, I mislabeled that.

Instead of saying flags, it should be permissions. So let me just do perms here. Long perms,

file creation perms, perm. I wish I could get a perm, if you know what I mean. Anyway, so,

you know, we just have like the file name that comes in and the permissions that come in,

And it’s going to return a handle just like we did with the read file for opening function.

But this time we’re going to do something slightly different.

So the system call is going to be the code for creating a file.

SYS create, which is not real unless you define it.

So if we just look up, I define that as.

Where is it?

Create 85.

So like right here, code 85 for system create.

Again, not a smart idea to hard code numbers.

Defines are way better.

numbers defines are way better. So then the first argument that it wants is the name of the file.

That’s the incoming argument that I took into R12. It has to be a null terminated string. It’s going

to be output.txt. Then the second argument is the file’s permissions. So that’s R13 that I took here

from the second argument, long perms. Once I’ve set up those things, I can do the system call

right away. The system, again, will try to open the file. It’ll try to create the file,

set up some data structures under the hood. If it succeeds, it’ll give me a valid file handle

in RAX, the return register. If not, then things have failed and I need to respond to that. So

I’m just going to stash the file handle in R14 right away. That’s why I’m also preserving R14

in the push pop pair that I have, R14 up at the top and the bottom.

So now we got to check whether or not we successfully created the file. Again,

logic is just opening up off a reading I’m going to compare our 14 to zero if

it’s greater than zero I’m going to assume it’s a valid file handle so jump

if it’s greater than or equal to to that label create file success I’m still

using my appending can naming convention so the name of the function is create

file so that means the success area is create file and then append underscore

success and so then I’m just gonna you know print a cute message saying hey we

successfully created the file. Yay.

Same thing that we looked at before basically.

And then I’m going to return the file handle in RAX.

If we fail, same thing that we did before when we were opening a read file,

I’m just going to complain basically to the user and then call on my little

die function to properly exit the assembly program with a

exit code of one, you know,

and I could enhance that to exit with different codes. Like maybe exit code.

Maybe exit code one means the read file didn’t work and exit code two means the

write file didn’t work and exit code three means we failed for some reason

while we were copying the data, you know, whatever you want.

I’m keeping it kind of simple.

So we got all that.

Again, this is not different than reading just, you know, the call codes pretty

much and, you know, the arguments, but the idea is the same.

So now we’re ready to uncomment.

I think we actually already did that.

We’re ready to let the program try to create the file.

to create the file and the only thing we need to add after that is the copying portion and the

successful message so let’s see if this works do clear and make run so you can see that the program

starts running here and then it says okay the module started and then it says we successfully

opened the read file and then we successfully created the output file notice how the make file

doesn’t fail when it tries to call the md5 checksum of the output file because now it actually exists

because now it actually exists if we list the program uh list the directory here you’ll see

that the out file has actually been created it just has a length of zero because there’s nothing

inside of it notice also that the permissions match what we intended the initial user can read

and write or the owning user can read and write the group can only read and everybody else can do

nothing to heck with you we could change that real fast just to show you i can get this r to

show you i can get this r to turn into an rw just by modifying permissions up here

you know giving permissions to a group uh just is a nice way of allowing multiple users

to have a shared file location you know add them all to the same group and then set that group

onto the file and then set the group permissions to allow people to do whatever you want them to

do read or read and write or whatever so let’s see where the perms i’m going to change this

So now the group people should be able to read and write.

I can’t remember if this will work because the file already exists.

Let me give it a try.

Okay.

I ran it one more time and it looks like it did not create the file because it already

existed.

So let me just remove output.txt.

There should be another system call code you could use to just check to see if a file

exists or if you wanted to be kind of hacky, you could just try to open the file and see

open the file and see if it succeeded and then close it right away.

I wonder if there is a call code for just exists only.

I don’t remember off the top of my head.

So I’m going to remove it and then run the program again.

And then we should see now.

Yeah, now that the file didn’t exist and was newly created.

Now those new permissions that we added are reflected.

So the group, anybody who’s on the group can read and write.

And obviously the group is just the same as my new user by default.

But again, you could be more complicated than that.

you were running a multi-user system

and you wanted to share folders or whatever.

Okay, so I’m gonna remove output real fast

and I’m just gonna revert the permissions to 640

so that the group really can’t do very much

except just read it.

And then if I, oh shoot.

LS, okay, yeah.

So now you can see it reverted.

Okay, so we got the out file.

I’m starting to get lost here.

I’m starting to get lost here. What am I doing? I’m supposed to copy the data, I think. So file

tests and we are copying the file. I think I just uncommented that. Really? Oh, no, no, no. I’m

looking at my solution repo. Okay. That’s what I’m doing wrong. So we’ll look into your repo or your

the copy file I was like what how did I how did that program run if I already uncommented that

and we’ll we’ll uncomment this message for now no let’s leave it until we actually finish everything

so now we got to do the copy file function so where’s that okay I’m going to copy paste this

whole thing you know what this would have been like a five hour video if I actually had to type

this by hand I can’t even remember how long it took me to write this program I think it was like

off the top of my head. So this would be a nightmare to type, I think, on video, even if I

kind of already know how to do it now. So let’s see, string length, print an alternated string.

This is close file. This is create file. Okay, so I’m just going to do copy.

File is going to be right before close file and right after create file. Okay, so copy file.

Notice the signature that I’ve chosen for this one. It doesn’t return anything. So

So that’s like not great design.

You know, I need to check to see if the copying operations inside of my loop actually succeeded

and maybe return something to indicate success or failure or at least exit the program.

But I’m not doing that right now.

I’m just keeping it a little bit more simple.

It takes two arguments.

The first thing is the input handle and the second thing is the output handle.

Conveniently, we have both of those now at this point.

And then here’s my register usage.

through r15 to just sort of grab the incoming arguments here for r12 and 13 and then

r14 grabs the beginning of the temporary buffer which i’m going to make on the stack because i

think i’m so cool instead of making it as a global in the bss section and then uh

r15 is going to hold the result from the copy operation or i guess the the write operation so

Sorry, the read operation only.

Oh, I think I’m only checking the read bytes instead of the read and the write bytes.

I’ll talk about that in a second.

So I could upgrade my program a little bit more if I wanted to.

But basically R15 is going to be my temporary variable that looks at the return value to

say, hey, did we do we read anything?

Like how much did we read?

So copy file.

This is not a video about making local variables.

So just trust me on this.

so that I can use it to save the location of the stack pointer.

Then I’m going to make a copy buffer on the stack

just by subtracting the stack pointer

because the stack grows downward in memory location numbers.

And then the base pointer is going to help me remember

where the stack was when I started.

I’m just going to say that that’s going to be the first byte in my buffer.

And I’m going to move that into R14.

And let’s see, what did I do?

Let’s see, what did I do?

Think about from the stack.

Oh, did I write like a good program or a bad program?

I feel like I should have actually saved the base pointer and not the stack pointer there.

Let me see if this runs.

If it does run, I probably have a naughty program that might self-corrupt sometimes.

And it might be a good idea to move the base pointer as the first.

Because this is not a stack video, but basically the stack grows downward.

that means you’re sort of like extending its reach you’re allocating like a free space

if i take where the stack

nope nope nope i got it right i’m sorry if i take where the stack ends up after i extend it then i

have a lower address right because it grows downward to memory if i then say that the new

tip where it grew not where it grew from but where it grew to if i say that’s the first bite in a

in a buffer then when you’re actually using the buffer you increase memory locations as you’re

filling up a buffer so then that’s going to grow back towards where the stack started so it should

be fine i think if i if i did go ahead and reverse this if i used rbp instead of rsp there then i

think i would be going in the wrong direction and just corrupting memory so just so you know

this is not a stack video but just so you know so here’s a little label again i’m just kind of

iteration label and at the bottom I’m just kind of jumping back up to that label so this is a loop

you can imagine this is a while loop maybe I should draw that for fun I gotta find more excuses

to use my drophead so this is kind of like a while loop I’ll say while true maybe and here’s like the

body and then here’s like maybe the end of the body and so this jump statement just kind of goes back

this thing’s going to frustrate me so the first thing that happens is we read a portion

of the input file into the buffer so what are we doing we’re just using another system call

we’re saying let’s use the call code for read I can’t remember what that was it might have been

uh whoops oh I cleared the dang drawing oh hang on I have undo I think wait I have that I’m gonna

Okay, I’m not going to mess with it because this will actually terminate my whole program.

One of these keys, I forgot which one, will just kill the whole annotator.

So if we go up to SYS read in the defines, you can see that it is just call code zero.

So that means I’m telling the system I would like to read something.

First argument it wants is a file descriptor for the input file.

In a different video, I showed you how to use exactly this sort of thing to read standard

of thing to read standard input from the user or from another program that launched your program

but in this case r12 it’s not going to be the file handle zero for standard input it’s going

to be the actual file handle of the file that you’re trying to read from whatever that may have

been whatever the os gave you and then here here’s the address of where to store our characters and

if you look up again we decided to remember where the first byte in our buffer on the stack was or

like a local array like oh shoot let’s do it again let’s do more drawings you have like a function

right in c and then here it’s like we declared a local variable maybe not int maybe a character

array we’ll call it a or how about b for buffer and then we just gave it you know let’s say eight

bytes or something for the buffer i think i still have it set to two bytes obviously you want to use

more bytes for efficiency but just to prove that the loop actually works i’m keeping it small like

keeping it small like I said before whoa what’s all that you see that it’s like smearing okay

that’s not good so uh anyway we remembered where the uh buffer starts and it’s going to be r14

and then the copy buffer length is being you know used here uh and I think I have that set up to uh

from the input file and we want to read into our temporary buffer and we want to read at most

this many characters and then we say system call and it does all the work for us to read that many

characters and then we want to remember how many bytes were actually read because that could be

different from the number of bytes we requested maybe we’re at the end of the file maybe the

system is having like some kind of a buffer issue or something so we just want to remember how many

this little token up there to remind myself the temporary bytes read should

go there. Notice also that when we created the stack,

this is not a stack video again,

but like I made the stack buffer equal to the length of the buffer that I

actually wanted to use. So I use the same symbol,

copy buffer length and copy buffer length.

So then it’s going to try to figure out, okay,

how many bytes did we actually read? Let me,

let me do that while loop thing again. Cause I’m, I’m feeling it.

I’m feeling it.

feeling it did i really have to write the word true especially my bad penmanship so we’re doing

while true and then i’ll just say like read you know do some kind of a call to read maybe we’ll

say n equals read like a long you know the the r15 uh register is like the number of bytes that we

actually read and then we do a comparison here so we’re saying you know if you know n is um

if it’s equal to zero then we’re going to jump to the position in the while loop where we’re

um done which is actually past the while loop if you scroll down you’ll kind of see it so i’m just

going to say break so basically if we read zero bytes then we’re done reading bytes we’re just

finished so we just break the while loop and that’s what’s going to happen here when we say

the end of the body and you’ll see that in a second so then otherwise if we’re not done that

means execution is not going to jump it’s going to just fall through to the next statement here

and that’s going to be another system call code to write to the output file and it’s going to be

very similar we just load it up with the system call code for write let me just double check

is code one and then we’re going to give it the target for output which is going to be

a file handle so you know r13 r13 right here that’s a file handle that’s where we want to

write and then the next argument that it wants is the buffer and that’s going to be r14 which

is where we just what’s going on green grain there we go i’m having issues that’s uh the

that’s uh the buffer that we just read into right so if you look here r14 green oh my gosh okay so

green we uh read from uh the buffer pointed to by r14 and then we uh we read into the buffer

pointed to by r14 and then we are using that same buffer pointed to by r14 in order to grab

R15 says how many files or sorry, how many bytes?

Green, I’m having such problems.

R15 says how many bytes do you want to write to the file?

That should be our return value from before, right?

Because we want to read a certain number of bytes from the file

and then write exactly that many bytes.

If we did more, we would be writing some junk data probably.

And if we wrote less, then we would be missing data in the output file

that was originally in the input file.

So you want to do it exactly.

in the input file so you want to do it exactly and of course i’m just doing a system call here

but like i said before your program should probably be a little bit smarter and check

rax after you write to the file just to make sure that you know how many bytes were actually written

like what if you what if you read a hundred bytes but then you wrote 90 bytes only right that would

be like a bad situation so you’d want to do some branching logic there so that if you read 100 and

100 and you wrote 90 you probably want to backtrack the position of the file by like 10.

You know just to make sure that you can actually get all of the bytes into the output file

and seeking backwards 10 that’s just another system call. It’s not in this program but it’s

not too bad. You just make another system call give it the right call code tell it how far back

you want to go no problem. So then when by the time we make it here we’re going to jump back

We’re going to jump back up to the iterate label.

Let’s see, where’s that?

Yeah, right there.

We’re going to jump back up to the iterate label.

So basically this is how the while loop continues looping.

So let me clear that real fast.

Eventually when we’re out of data to read, you know, that’s because if we try to read

and we end up with zero bytes, that means we’re done.

We’ll break the while loop.

Then we’re going to go down here.

Notice how it says copy file done.

What I was talking about before, just sort of jumping past the end of the body.

so if we are done we jump to copy file done and all it does is just restore a

bunch of registers for us and then return to the caller so copy file we have that

handled now and if I go back up here file tests I guess I can I feel bad about

this I can uncomment the success message but we probably should have done more

checking on the reads and the rights just to make sure that we actually wrote

to make sure that we actually wrote the correct amount of characters and everything succeeded

every time and if not we exit the program and only if everything went well then we print a

successful message at this point in this program the way it’s written it could totally fail and

it’ll still say that it was successful so just keep that in mind that’s bad bad for your users

okay i think we have everything that we need now i can probably just run the program and

run. Notice now, oh shoot, I didn’t even show this to you before. Let me just emphasize this

one more time real fast. So I’m going to comment out the part where we actually copy the file

and I’m going to remove the output file. Then I’m going to run the whole program again. Notice how

the two MD5 sums are different. So remember before I said that MD5 sums, they’re basically

fingerprints. They’re not actually considered secure in the modern era. I just use them because

and fun if you are interested in security you probably want to use a

modern hashing algorithm so don’t use md5 but I am but don’t but I am and it’s

basically saying the fingerprint here of input is different than the fingerprint

here of the output quickly indicating to me that the files are different so if I

list the contents of the directory obviously that’s true because the output

file is empty still but if I uncomment this part here where I’m actually

here where I’m actually copying the file then I should see that the fingerprints

match and then if I look at what’s inside of the output file it should match

what’s inside of the input file really fast let me open up a terminal and I’ll

just cat the input file so this is all I added you know why hello there add some

stuff this is definitely more than two characters so we can be sure that our

buffer loop is actually working and so I’m gonna do clear and make run and now

And now the output file, notice how it has a matching file size.

It’s got 38 bytes in there.

Same thing for the input.

And then the thumbprints or, you know, the signatures, whatever you want to call it,

the hashes, they match exactly, indicating that we probably have two identical files.

Even with MD5, even though it’s old and not considered secure,

the chances of two files kind of having random differences,

not hacked differences, but just like random differences,

and having the same fingerprint is like astronomically almost impossible so if i do

cat input oops input.txt that’s what’s in there like we showed before and if i cat the output

now it is uh the same thing why hello there added some stuff for both i could make this as big as i

wanted to just for fun maybe let’s do uh let’s do a nano on the input file

I’ll just add like I don’t even know what I’m doing I’m just going to type a bunch of stuff

oh wait what is this remember that thing that people got taught a long time ago it was like

the quick brown fox jumped over the lazy dog and this was supposed to be all the letters of the

alphabet there was an there’s another one that I just heard about and I don’t remember exactly

look it up on the internet it’s it’s pretty cool i think i need to memorize this and stop using the

lazy dog it was um something like those sphinx of quartz hear my vow or something like that

you know what i’m gonna look it up for you right now i don’t want to do the wrong thing

it’s really cool uh i’ll type brown fox and then uh

Hear my vow.

Oh, Sphinx of black quartz.

Judge my vow.

That’s what it is.

Okay, so I’m going to go back to my little VM here.

Sphinx of black quartz.

Judge my…

I didn’t even write vow correctly.

Judge my vow.

And I think that has all the letters in the alphabet too.

probably less spaces. I wonder if that’s, I mean, that’s what the internet says. If this is true,

and it has all the letters of the alphabet, that’s going to be awesome. I’m going to memorize that

for sure. Sphinx of black quartz, judge my vow. Anyway, so I’m just kind of adding stuff into

this file. And if I run, let me save that here. I’ll do a clear. And then I’ll do, um,

I’ll cat the input file here, and then cat the output file. So you can see they’re different.

again let me remove the output file just in case I can’t remember if I’m supposed

to remove it manually or if I put that into the program we’ll just try it like

this so now they match and then if I cat again the output file notice how it’s a

perfect copy of the input file nice so I think that’s pretty much everything

that I wanted to show you maybe um well maybe we can use a more efficient buffer

we can use a more efficient buffer now that it’s done the copy buffer we could change this to like

eight kilobytes or something we should end up with the same result let me run this just as is

and see if it ends up being the same thing without erasing the file first yeah it looks good let me

remove the output file and then run it one more time so make run and then uh cat the output file

yeah okay so it still works but um you know whereas before we were just using a two byte buffer

two byte buffer there’s like very little chance except maybe at the end of the file that we would

request more data than the file had but using the return value of the read operation always told us

exactly how much was read by the operating system on the other hand if we have a giant buffer we

could request way more bytes than the file could ever have because that file is way less than eight

kilobytes so again we still want to look at the return value to make sure we know how many bytes

how many bytes should be sent into the right file.

So I guess that’s everything that I wanted to tell you

about reading and writing files using system calls.

I hope you’ve learned a lot of stuff

and you enjoyed this video and had a little bit of fun.

Thank you so much for watching.

I’m going to cut the video.

I’ll see you, whoops.

I’ll see you in the next video.

Hey everybody.

Thanks for watching this video again

from the bottom of my heart.

I really appreciate it.

I do hope you did learn something

I do hope you did learn something and have some fun

If you could do me a please a small little favor. Could you please subscribe and follow this channel or these videos or

Whatever it is you do on the current social media website that you’re looking at right now

It would really mean the world to me and it’ll help make more videos and grow this community

So we’ll be able to do more videos longer videos better videos or just I’ll be able to keep making videos in general

So please do do me a kindness and and subscribe

and subscribe. You know sometimes I’m sleeping in the middle of the night and

I just wake up because I know somebody subscribed or followed. It just wakes me

up and I get filled with joy. That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could you control me if you want

to just wake me up in the middle of the night just subscribe and then I’ll just

wake up. I promise that’s what will happen. Also if you look at the middle of

the screen right now you should see a QR code which you can scan in order to go

to the website which I think is also named somewhere at the bottom of this

also named somewhere at the bottom of this video and it’ll take you to my main website where you

can just kind of like see all the videos I published and the services and tutorials and

things that I offer and all that good stuff and uh if you have a suggestion for uh uh clarifications

or errata or just future videos that you want to see please leave a comment or if you just want to

say hey what’s up what’s going on you know just send me a comment whatever I also wake up for

I wake up in a cold sweat and I’m like,

it would really mean the world to me.

I would really appreciate it.

So again, thank you so much for watching this video

and enjoy the cool music as I fade into the darkness,

which is coming for us all.

Thank you.

The post Master File Copying with System Calls in x86-64 YASM Assembly appeared first on NeuralLantern.com.

Ready to dive into x86-64 assembly? This beginner-friendly video breaks down CPU registers like RAX, RBX, and more in Yasm assembly. Learn how to use general-purpose registers, respect the ABI to avoid debugging nightmares, and optimize code by minimizing RAM hits. We’ll cover callee-saved registers, function arguments, and why you shouldn’t mess with the stack pointer. Perfect for coders looking to master low-level programming. Grab the free book mentioned and subscribe for more assembly tips! #AssemblyProgramming #x86

Introduction to Registers 00:00:00
x86-64 Yasm Assembly 00:00:04
Recommended Book 00:00:09
Move Instruction Example 00:01:04
64-bit Registers Overview 00:01:52
General Purpose Registers 00:02:24
Two’s Complement for Integers 00:03:37
Floating Point Registers Introduction 00:03:54
ABI Importance 00:04:55
Function Return Values 00:08:01
C++ to Assembly Translation 00:08:43
Avoiding System RAM 00:11:45
Optimizing with Registers 00:13:04
Callee Saved Registers 00:14:16
Preserving Registers with Push/Pop 00:16:40
Stack and Local Variables 00:22:00
Function Arguments in Registers 00:25:12
Stack Pointer and Base Pointer 00:31:29
Instruction Pointer (RIP) 00:36:30
Temporary Registers (R10, R11) 00:36:49
Accessing 32-bit Register Portions 00:38:29
Floating Point Registers Details 00:42:53
Conclusion and Call to Subscribe 00:45:35

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

Hello there.

Let’s talk about registers in assembly.

More specifically, x8664 Yasm assembly.

Okay, so first off, check out this book.

It’s a wonderful book.

The author is a genius.

It’s called x8664 assembly language programming with Ubuntu.

It’s free.

website and you know grab your copy it’s wonderful it’s released under a copy left license

author’s a genius whenever i’m trying to remember things about cpu registers for assembly

i always go to this section i say callie saved i search for callie saved i already had it there

callie saved and it ends up being section 12.8.2 register usage so before we do that let me just

that let me just give you a little quick example so you kind of know what I’m

talking about here hopefully everybody’s seen this instruction by now this is a

move instruction in Yasm x86 64 assembly it just moves data from one place to

another it takes two operands so you know we have like operand one and

operand two basically operand one is the destination operand so we could put

destination there if we wanted to operand two is the source we could put

that actually won’t, you know, compile or assemble,

but I’m just saying that’s what those positions are for.

So here’s an example of a register receiving the value 10.

We use the move instruction and we say,

we would like to move something into the REX register.

We would like to move the value 10 into the REX register.

And there you have it. There’s a move instruction. Okay.

So REX is a register.

that it is a 64-bit register in our 64-bit CPUs every single register or

sorry every single general purpose register and the plot registers they

have 64 bits available for us to use 64 bits like you know ones and zeros it’s

like a very very very big number a long time ago we had 32 bit registers and so

these are like you know twice as mathematically robust or whatever you

allows the registers to address, you know, the 64 bit memory addressing space,

which helps us go beyond four gigabytes of RAM in our modern computers,

helps us go far beyond what we can even achieve right now.

So we have a register called RAX and there’s a list of other registers on this

page here. So basically, you know,

we have the RAX register and the RBX register and the RCX register and so

forth. I have a hard time remembering all these names,

remembering all these names so I go to this book when I forget but otherwise

you know you can kind of think of like ABCD and then just surround them with

RNX you know our kind of for register and X for extra big maybe so we’ve got

the RAX RBX RCX and RDX registers and then we have a bunch of other ones

through R15 but first before we do that let me just emphasize that these are

general purpose registers to be used for integers or data you can put

characters in there for strings you can put just like you know whatever data you

want inside the machine we use twos complement to represent integers so it’s

it’s fine the instructions that you will do for addition and other mathematical

but don’t put floating point numbers in these registers because the computer the

system the machine won’t know how to operate on that data the thing is

integers are stored as twos complement I’m going to talk about that more in

another video and floats are stored in something called I triple E seven five

four standard which is just like a crazy different way of storing floating point

numbers that makes more sense for floating point numbers but because the

differently in the machine you can’t really use normal instructions like you

can’t add two floats together the same with the same instruction that you would

add two integers together you would have to use special floating point registers

and special floating point instructions I’ll talk about floats at the end of

this video I hope but basically just keep in mind these are general purpose

registers to be used for integers in data only okay so what am I talking

Okay, so what am I talking about?

What are we seeing here on the side here?

Why does it say return value?

What is going on with Kali saved and fourth argument and third argument and so forth?

So there’s a standard that you’re supposed to use when you program.

You can get yourself into a lot of hot water or you can dramatically increase your debugging

time if you don’t do this.

standard called the ABI which I think is short for application binary interface but basically I just

like to say the ABI respect the ABI there’s a plan that people came up with that says this is how you

should use these registers don’t use them in a different way and that way if everybody is writing

you know modules and they’re all going to interact together like I write a module you write a module

the abi then it’s it’s pretty much guaranteed that we can we can expect certain things like

our registers won’t become corrupted after a function call or that we’re not going to corrupt

someone else’s uh function or you know whatever right so you can also use this to benefit yourself

even if you’re the only person who is writing your code and you’re not calling on anyone else’s

function um then you know like how are you going to remember like what was i using this register

Was I supposed to save that one?

Was I supposed to preserve it?

How was I going to return data from that function?

Was I going to use this register or the other register?

It’s hard to remember what you,

what you yourself even did like a month ago.

So if you respect this plan,

then your functions will work not only

with other people’s functions,

but with your own functions from a month ago.

The other thing too, is we have system calls, right?

So you have like a system call.

Let’s say we want to move something into REX.

something into REX, maybe I want to exit the system or something.

Just forget about this.

This is not a system call video.

Suppose I want to do a system call, right?

The system call itself is also going to respect the ABI.

So if you start calling other

services in the system call instruction, like if you want to open a file,

close a file, read a file, write a file, whatever.

If you don’t respect the ABI and the system call is respecting the ABI,

might have some of your data corrupted so it’s a really really good idea to respect the abi

in fact think about it this way what if uh what if you wrote a bunch of functions for a long long

time and then like a year later you couldn’t you couldn’t remember what you were doing you know

last year oh what was the return register uh and it costs you a bunch of extra time debugging

eventually you’ll probably decide to write your write your own standard okay from now on i’m always

going to use this register for return values and i’m going to use this register for the first

and i’m going to use this register for the first argument and i’m going to write you probably

come up with a plan right that’s basically the abi the abi covers more than just how to use

registers but um register usage is covered in the abi so why would you put yourself through

a bunch of heartache and then eventually come up with your own plan when you could have just

been following the correct plan in the first place right so everybody should respect the abi

I wanted to talk next about the return value.

Okay, so let me write up a little function here.

Let me just say that we have a C++ function.

And we’ll just say it’s like void f.

And we’ll say it calls on g.

And then we’ll have another function called g.

And actually, maybe it’s not void.

Maybe it actually does return a long.

returns the number five or something. Okay.

Hopefully you’ve seen some kind of a higher level language before like C++

so that you can understand what’s going on here.

We’re just making two functions and one is calling the other.

And the second one is just returning a value to the first one.

So in assembly, the equivalent of this would be,

let’s make a label with the name of the function and then a little colon,

and then just put a return instruction at the end of it. Wham,

it, wham, you’ve got a function. It’s not going to work very well, but you do have a function at

this point. So F, uh, I’m going to try to copy the C++, uh, function. So it’s a really good idea.

Whenever you’re writing a function in assembly, try to imagine what the prototype would be for

C++ and just put it as a comment at the top. So I know how the F function is going to behave in

my assembly module because I put a comment up there just kind of reminding me what the prototype

for C++. It doesn’t really do anything. It just sort of runs. So that’s okay. And then I’ll make

another function down here. I’ll do the long G again in a comment, and then I’ll do the actual

assembly version. I’ll say G colon, and then I’ll return. So just by putting that comment up,

I kind of can remind myself now that the G function is supposed to return some kind of a value.

up here, you know, do how about let’s say, I don’t want to start adding a bunch of local

variables right now.

Pretend that we’re going to print the return value of the call to G somehow we’re going

to use C out or whatever.

We’re going to send it to a variable, whatever.

I’m just going to try to keep the assembly as simple as possible.

But anyway, the point is G returns something.

you know, a value in your assembly function.

Well, remember that higher level languages,

part of why they’re so awesome

is they do a lot of extra work for us under the hood

and they actually provide illusions to us

that make programming easier.

For example, there are no functions

going on inside the actual machine.

I mean, I guess from a certain point of view there are,

but basically the machine is just sort of like moving data

and jumping to instructions

and jumping back from somewhere.

And, you know, it’s just sort of like jumping around

and executing instructions.

and executing instructions there’s no actual function it’s so it’s like if you want to pretend

that you have a function in assembly well there is a return instruction that will help you jump

back to wherever you came from most recently but we have to we have to implement more is what i’m

saying so how do we return a value in an assembly function we just have to load up the return value

it as return value that just means we have to load rax up with something so for example we wanted to

return the number five so i’m just going to load it up with the number five and then return

now we’ve pretty much translated a c plus plus function into uh an assembly function i mean

that’s really what’s happening under the hood when you compile your c plus plus program

it’s um it’s just you know translating all the c plus plus into assembly

Another thing that I should probably point out is that you should use registers as often as possible

and you should try your best not to touch memory.

Of course at some point you have to touch memory when you want to save your final result or send

it off somewhere or whatever but you know imagine that you have an assembly function and you’re

doing lots and lots of calculations you’re performing an algorithm or something your

program will be so much more efficient by like a factor of a hundred or probably more if you don’t

if you don’t hit system ram because every time you hit system ram like a global variable or the

stack or something then um your cpu you know typically in the uncashed uh scenario your cpu

has to go talk to the system bus on your motherboard and then you know send a message

to system ram and then wait for the system ram to figure out what it’s doing and then get a response

back so when your program is executing on the cpu you can encounter a stall which is like your

like a hundred clock cycles or more like it’s a long time at least in the most basic case

and how do you avoid that just use registers only when you’re doing lots of calculations the

registers are built into the cpu they’re part of the cpu’s hardware so they are lightning fast

compared to system ram or your disk or whatever

i probably say this a lot but you know part of the reason you would even want to code an assembly

Maybe you have a big program that does a lot of stuff and eventually you profile the program

and you realize, Hey, this one part of the program is really slow because it gets called

constantly and it’s not super efficient.

That might be a good use case for writing a hybrid program where you have multiple modules.

Some of your modules are in a higher level language and some of your modules are in assembly.

So you take your most important function that slows down your program that gets called all

like a big loop or something and you rewrite it to assembly so that you can

have more control over how often you touch system RAM to try to make the

whole thing more efficient and you know reduce the number of instructions and

just like whatever and you can improve the product of the efficiency of your

program so anyway you want to try to avoid hitting system RAM your registers

are built in the CPU there’s 64 bits that gives us 64 bits of address space

can reach you know back in the day we had 32 bit systems that means you could only have a memory

stick that was about four gigabytes so now we can go much further so um yeah that’s what’s going on

with our registers on the cpu back to the return value okay so we have return value here goes into

the rax register and then the next thing here is it’s saying that the rbx register is something

remember we said that uh we have to respect the abi right like you have to respect this convention

uh because if you don’t you’re going to cost yourself debug time and your

functions probably won’t be interoperable interoperable with other people’s functions

or the system call uh instruction well so one of the things about the abi is some of the registers

are designated as the function that is being called has to be the thing that saves the register’s

registers value so that it doesn’t corrupt for the caller. Imagine this if I had a function

called f I’m going to do like f and g here suppose the function f is going to move something into

let’s say r12 or actually let’s do rbx move the value 10 into rbx and then it’ll call g for some

reason maybe g doesn’t take any arguments maybe g is just kind of doing stuff let’s just say that

g just moves a different value into rbx so the thing is when the call comes back like after we

get to this next line let’s say we’re going to do something with do something do something with

rbx by the time we get to this line dude can i get the line numbers on this oh yeah i forgot okay

so by the time we get to line seven uh the register rbx is ruined these registers are not

local variables they’re not like uh you know tied to any scope or function call these registers are

just basically global variables that are sitting on the cpu for lightning fast performance but that

means the rbx i use inside of f is the same rbx i use inside of g so that means if g messes up the

value of rbx and then if f calls g then f now has a bad value for rbx this is a broken program

broken program because we did not respect the ABI.

The ABI says that RBX is callee saved,

which means if I use RBX in the G,

then I have to preserve the value so that by the time I return,

the value is the same as it was when the call first came in.

So how do we do that?

We’ll do that with a push pop pair.

I’ll probably make more videos in the future about pushing and popping,

but I’m going to try to keep it simple for now.

We just say, let’s push RBX onto the stack.

at the beginning and then we’ll pop it off the stack at the very end.

This basically means we’re going to take the value of RBX.

We’re going to send it onto the stack.

So, so yeah, we are hitting system RAM.

It’s a little slower at that point.

The ABI will save us a little time for the other registers.

I’ll try to explain that in a second, but basically we’re preserving the value here

with push and then we’re popping it back off.

So we’re restoring it.

So that means even though we ruined the value at line 14, when F does its line

When F does its line 7, it’s going to have the correct value of RBX.

It’s going to have the value 10.

The book and I like to call this the prologue, just meaning this is a little section of code

where we’re going to set things up.

We’re going to start getting ready to do more instructions.

And then this at the bottom is going to be called the epilogue.

This is just like the finale.

We’re like, we’re kind of cleaning up.

We’re finishing up right before we return.

If you wanted to return a value from G, then you could put, you know, the move inside of

RAX somewhere else.

Like you could put it like below the epilogue or just above the epilogue.

It’s fine.

As long as you’re sure that RAX is not getting trampled upon.

So it’s important to note also that if I do a, let’s say a system call right after that,

let’s say I call G and then I do a system call with, you know, like, you know, some

you know some other number as the call code i want to open a file i want to close a file

i want to read or write a file whatever i want to ask the system to do something for me the

system is also going to respect the abi which means i’m guaranteed that rbx is not modified

when the system call comes back if if the system call you know if the syscall instruction didn’t

respect the abi then my rbx could be ruined i’d have to do a bunch of stuff to preserve it so this

some of these registers let me go down a little bit here like this R10 the

temporary register and also the RDI if you decided to use that in the body of

your program which you’re allowed to these are not designated as callee saved

which means system call could actually ruin the value of those registers so

suppose for the sake of argument I really decided that I needed to use I

10 because that’s marked as a temporary I’ll put a value in our 10 and then I’ll say you know

do something

With our 10 I’m sorry our 10

Then that means by the time I’m done with my call to G

I should assume that our 10 is ruined because even though you’re you can see right here that that G doesn’t actually do anything

To our 10 we should assume that we have to respect the ABI which means the other function could have ruined it

Ruined it. This is especially true if you call someone else’s module or system call or whatever same thing for the system call

so if I call system call

and I use

R10 at some point before and then after then I have to assume R10 is destroyed by the time I get back in system call

So that’s no good

The cure to that when we’re talking about a temporary or something that is not designated as callee saved is that the caller has to save

hit a system RAM just to make a call.

Anything that we think we need when we’re finished.

So I’m going to do a push.

This is not the only way to do it, but I’m going to do a push R10 here.

And then afterwards, I’m going to do pop R10.

So that sucks.

And then I have to do the same thing for the system call.

I can go push R10 and then pop R10.

And of course, if you were clever, you probably would, you know, put the call to G inside

of that system call push pop pair.

So you could have one less push pop pair.

push pop pair but I’m just saying there’s no guarantee r10 is going to survive so you always

have to preserve it if you ever want to use it again so this is like another way that the abi

kind of can help you save time notice how here in the uh in the g function which I probably should

have prototyped let me just say it looks like to me it’s a void and it doesn’t take any arguments

to prototype your functions in comments.

Maybe let me do the same thing to F up here.

So F looks like it’s not returning anything and it’s not taking anything.

Okay. Whoops.

Those are C++ comments that would not compile.

All right. So notice how I’m using RBX.

So I decided to preserve RBX, but there’s also other registers that are marked as

marked as Kali saved like R12 through 15 and RBP and whatever,

but I’m not preserving those.

The reason I don’t have to preserve those is because I’m not using them.

So the, uh, the, uh, the ABI can save you a little time here.

Like for example, I’m preserving R10 because I’m supposed to assume that I,

that I, that they could be destroyed by the time the function comes back.

What if instead of using R10, I used R12.

have to surround any calls with a push pop pair because I can trust that whoever is going to

modify R12 will preserve it for me. But then notice down here G is not actually using R12.

So G doesn’t even do push pop on R12. So we save hits to memory. We don’t even have to touch memory

to preserve R12 because the ABI is helping us sort of stay a little bit more efficient.

So this is great, right? F is a broken function at this point though, because I’m using

at this point though because I’m using two registers that are callee saved I

can’t assume that whoever called F is gonna know that I’m modifying RBX and

R12 so I should do a prolog and an epilog up here I’m gonna say push RBX

and then I’m gonna push R12 and then down here at the bottom I’m gonna do an

epilog epilog and I’m gonna pop RBX and I’m gonna pop R12

but I’ve done something wrong.

The thing is, I’m not going to talk about the stack too much in this video,

but the stack is a particular type of data structure

that will return to you data in a reverse order than you sent into it.

This is great for helping us keep track of function calls and return addresses,

as I’ll probably try to explain in this video.

But basically, the data comes out backwards.

The data comes out backwards. So if I do it like this

Then actually by the time the return statement instruction gets executed

RBX will have the value that was intended for R12 and R12 will have the value that was intended for RBX

It’ll be backwards. So you have to do your push pops in the reverse order to notice how

It’s kind of like a shell that goes outwards. It’s like R12 is first on the inside and then RBX is next on the outside

That’s just what you have to do to preserve everything.

So the F function works now.

The G function, I think it works now.

We have a prologue and epilogue.

Okay, so we talked about the ABI.

We talked about calls.

We talked about the registers.

Talked about callee saved.

We talked about the fact that we don’t have to save the other ones.

I think I can talk about…

um so uh one thing that i should make sure to mention is that these are general purpose registers

they’re to be used for integers integer data or like characters or just like regular data

they use certain instructions that are not to be used with floating point data so you actually

should not store floating point numbers inside of your general purpose registers you should only

store floating points in special registers which i’ll talk about at the end of this video

So keep that in mind.

Floating point numbers are stored differently in the system.

They’re stored with a scheme called IEEE 754 floating point.

So like the numbers wouldn’t make sense.

Integers and floats are stored differently.

So the hardware is wired differently to operate on two different types of data.

So anyway, I just want to say that this is only for integers and general purpose data.

So now let’s look at the other types of registers.

rc x and rd x and rsi and rdi are designated as arguments first second third and fourth

okay so let me uh let me write like a quick c plus function here and this is going to be uh let’s

say we have like a function that returns some value we’ll call it uh we’ll call it f and we’ll

say that f takes in some arguments let’s say that it takes in three arguments um again uh

integers right now because we’re only using integer registers.

We can’t use floating point arguments or return values.

Just keep that in mind.

So I’m just going to do like three arguments long A and B and C.

OK, so we can take in three arguments and maybe we’re just going to return,

you know, a plus B plus C.

OK, simple C++ function.

Let’s do this in assembly.

We’ll make a label and we’ll do a little comment that just reminds us.

of sorry of the

Function that we’re trying to implement we stick a little return instruction at the end of it so that

it will jump back to the caller and

then we’ll say

Well when the caller of this function

Called us and gave us a and B and C. How do we get a and B and C?

Well a is the first integer argument, so it’s just going to be the RDI register

So we’ll literally just use a move instruction

just use a move instruction.

Let’s say we want to, for whatever reason, use the R12 register

and we’ll do something with it later.

We’ll print it, we’ll save it, we’ll do whatever.

Let’s just grab the incoming argument.

So we’ll just grab RDI.

So I’m going to put a little comment up above here, you know, grab

a and do something

with it and I’ll just write down here more instructions just to just to denote

Just to denote that we’re doing something with the a value, but I’m not going to write it down here because I don’t want this to get huge.

So we’ll do the same thing with the b.

Maybe I should remember that programming is case sensitive.

We’ll do something with the b.

It’s not RDI.

It’s the second argument.

So that’s actually RSI.

And then we’ll do something else.

We could have used R13 or other registers if we wanted to.

I’m just showing you how to grab incoming arguments.

So then we’ll grab the c and do something with it also.

C and do something with it also it’s not going to be RDI it’s going to be RDX and you can do this

up to like I think six arguments let me just double check here yeah so like R9 ends up being

the sixth argument and if you want more than that then the caller will have to put stuff on the stack

and in fact if you if you kind of like understand what’s happening here let me just do like a main

Let’s say we do cout whatever f returns.

You know, this is like a typical function call, right?

So we’ll call f.

f will jump in there.

It’ll jump into its body.

It’ll do some sort of a manipulation with the incoming arguments.

It’ll return a final value.

Then that final value gets printed out.

So what’s 5 plus 6 plus 7?

That’s 11 plus 7.

What is that, like 18?

I’m bad at math.

So let’s just say that’s 18 gets printed.

So what happens is, um, we return, Oh, I forgot to return.

I’m going to say compute the, uh,

compute the sum of the things.

Uh, and I’ll just say like block cause I don’t want to put a bunch of addition

instructions here. Uh, and we’ll just like store in, uh,

in R13, let’s say. So then when we have finally computed our result, I’ll just move R13 into the

return value. And what I’m really trying to say here is if you imagine a function that behaves

this way in C++, then what I’ve written down below is really what’s actually happening in

assembly. Your compiler compiles the code down to assembly language first, and then it assembles it

down to machine code. So really this is what’s happening under the hood. It’s not like a special

under the hood it’s not like a special trick when you call a function in C++

literally the A B and C have been loaded up just before the the jump

instruction to go to that you know line 9 they’ve been loaded up with the

appropriate values so that’s part of like you know the magic of what higher

level languages give us it’s just makes things a little bit easier okay so I’ve

If I had only used RDI and RSI and RDX, those are not designated as callee saved.

So I wouldn’t have had to preserve those, but because I chose to use R12 and R13, I

have to preserve those for the caller, even if the caller is not going to use them.

So I’m going to do, I’m going to do push R12 and I’m going to do push R13.

And then at the bottom, let me do like a prologue here.

is kind of helpful because it kind of helps you remember like, oh, did I forget the prologue?

Did I forget the epilogue? They got a match. And then I guess the fact that you can see the words

prologue and epilogue also helps remind you that everything is supposed to be in reverse order

in the epilogue. So again, notice how R13 is on the inside and R12 is on the outside

of the push pop pair. So now my program is good. And we’ve, you know, successfully translated

We’ve, you know, successfully translated a nice function call there.

And we’ve done a bunch of nonsense in the middle that I’m not writing down at this point.

We are respecting the ABI.

So if somebody else uses our function in their module, then they can be pretty confident

that we’re not going to ruin their registers and so forth.

We talked about the return value.

We talked about that these general purpose registers are not for floats.

We talked about pushes and pops.

and pops. We’ve talked about function arguments,

which right now we can only do integer arguments and return values.

We’ve talked about, uh, well, he talked about the stack a little bit.

So let me, let me just point out that, um,

suppose you have a function. I just want to mention this briefly.

Suppose you have a function F let’s say it’s, it’s void.

So it doesn’t return anything and it has an integer a equals five.

I think the reason that I wanted to do this is to show you how dangerous it is to mess

with the wrong register like the stack register.

So suppose we have two variables and then we’ll do something with a and b.

So now suppose we have two threads.

We have an execution thread one and an execution thread two.

If you’re not familiar with threads, that just basically means your computer is literally

executing your function or sorry, it’s executing twice at the exact same time.

Maybe not the exact same time if you only have a single core on your CPU, but you could

imagine that that’s possible, especially if you have many cores, that’s an operating systems

video.

But basically pretend that we have an execution thread.

So it’s like going through your program, executing one instruction at a time.

Then you launch another execution thread that also executes your program one instruction

at a time.

at a time so at some point it’s possible that um thread one and thread two could be executing f

at the exact same time right so i’m not going to talk too much about this because this is not an

os video but basically this could create a race condition where thread one and thread two kind

of step on each other’s toes and they both try to modify the value of a uh at the wrong time and

because the other thread modified it.

So this is why local variables in a function actually live on the stack.

A and B are not global variables.

They’re actually temporary local variables that are sitting on the stack.

And the way the stack works, I’m not going to talk about it too much in this video,

is that, well, every function kind of has its own area of the stack.

So when the function comes in, on the stack sits the return address

return address so that the function knows where to jump back to when it returns and any local

variable that the function makes. So if you think about it, when thread one calls F, we actually

end up with a different version of A and a different version of B. We could imagine them

as being, you know, A sub one and B sub one. But when thread two comes in and, you know,

creates those local variables, we can imagine that we get two different versions of A and B also.

of a and b also so this is how the computer prevents multiple threads from stepping on each

other’s toes if you’re using local variables local variables are just local to the function

this also helps if a function calls itself a bunch of times maybe one call or another might want to

see a different version of a or b and it would be just incredibly difficult to keep track of that

if you were using globals but when you use locals well they’re just basically different variables

trying to lead up to is the stack is pretty important if you corrupt the

stack then you probably are going to crash the entire program you might make

it so that a function doesn’t know where to return from like when you do the

return statement it might jump to some other part of the code that doesn’t even

make sense and then everything crashes or you might mess up some data in a local

variable like if you mess up if you mess up the stack you might be messing up the

that the caller is depending on and so then the caller continues to execute and

it sees the wrong value and it just crashes or you might even mess up your

own local variables so don’t miss with the stack the reason I’m saying that now

is because this very this register right here the RBP sorry that’s not it the

RSP register that’s the stack pointer eventually you can learn how to

manipulate the stack pointer in order to create your own local variables that’s

variables that’s okay once you know what you’re doing but unless you know exactly what you’re

doing you probably shouldn’t touch the stack pointer especially you shouldn’t mess with it

right before you call a function or right before you return from your own function be very careful

with that the rbp uh register is similarly dangerous uh it won’t like automatically destroy

your program but it is uh it’s usually i mean it’s quite often used as sort of like a bookmark for

mark for where the stack pointer was pointing in other modules and other

functions.

So if you fail to preserve the base pointer,

the RBP and then you returned from your function,

then you might have actually messed up the stack pointer for the caller or some

other caller somewhere in like the ancestry of your call graph.

So be very careful. I mean,

I guess all callee preserved variables or registers you should be very careful,

careful about, but these are like kind of the two worst ones to forget about.

first ones to forget about.

There’s also another register that is not listed on this page called the

instruction pointer. It’s RIP.

It basically is a register that holds

the memory location of the next instruction to be executed.

So if you modify that, then you just told your program to go execute

in some random crazy place and probably everything is going to crash.

R10 and R11.

I can’t remember already if I explain this, but I’ll just say it again.

But I’ll just say it again, R10 and R11 are just temporary registers.

You don’t have to preserve them.

But the callee, if you call another function, they don’t have to preserve the registers either,

which means it can be really fast to use R10 and R12 if you’re kind of like already running out of registers.

If you don’t have to make a function call anywhere, so you know no one is going to ruin your R10 and R11,

then you can also use R10 and R11 to sort of like, you know,

reduce your hits to system RAM to speed up your program.

So R10 and R11, they should probably be used last.

R12, 13, 14, 15, I usually use those first.

Once I start running out of those, Kali saved.

Then I’ll start eating into the arguments.

I’ll say, you know, I’m going to start using RBX

and then I’m going to use RDI and RSI and whatever.

It’s okay if you use, you know, the argument registers.

as long as you’ve already done something with your incoming arguments or you don’t have any.

So just keep that in mind.

You’re allowed to use them.

I mean, this is all just a standard.

As long as you obey what the rule is, then you’ll be all right.

The rule is you got to callee save those.

The rule is that one’s just temporary.

The rule is this one’s an argument and so forth.

Okay.

locals and how we use these registers. Let me try to just show you one more

thing real fast. So I said before that the size of the REX register is 64 bits

because it takes up the whole available register bits in the CPU but there are

other versions of this register that we could use. What if you only wanted to use

32 bits in your register? What if you wanted to pack like two different 32

32-bit numbers in the same 64-bit register.

You could do that.

There are also older modules and instructions

that will operate only on 32-bits.

So how do you reference only 32-bits of a register?

Well, if I search for, oh shoot, what was it?

Is it EDI?

No, no.

Shoot.

It’s in here somewhere.

This is like a good lesson in actually preparing before you record a video.

So I’m going to do architecture overview, CPU registers.

Oh, it was at the beginning of this section.

I always skip down to 2.4, 12 point something, and I should have gone to 2.3.1.1.

So obviously I’m not going to remember all of this, but basically notice at the top,

we have the REX register, all 64 bits of it.

But if you wanted to access the lowest six, sorry, the lowest 32 bits, then in your code,

instead of putting REX, you put EAX.

So for example, you know, move REX, whoops, REX, let’s say the number five, but over

here we’re going to move EAX, the number five.

five uh here it’s going to set the whole 64 bits to just like a bunch of zeros and then there’s

going to be a few bits that help represent five the lowest bits so it’s going to erase like the

whole thing all 64 bits but if you use the eax instruction then only the lowest 32 bits will

actually be modified which means whatever data you had in the higher 60 the higher 32 bits of the

of the register itself they’re just going to stay there it’s going to be considered

point so sometimes if you’re going to work with something that’s going to be using only 32 bits

of your register you better make sure that the other bits are uh are cleared out if you intend

to use rax right after that and and vice versa so keep in mind that we have other forms of the same

register a designation but just to let the cpu know that we only want to touch 32 bits worth we

And this, this kind of table covers all of the registers,

REX, RBX, RCX, and so forth.

I think it doesn’t cover the instruction pointer

and something else in there, but you know, most of them.

However, you know, for my purposes,

I usually just use 64 bits

because I’m not like super advanced

unless I have to divide or do something.

Okay, so that’s the last thing I wanted to mention

about the general purpose registers.

Let’s see.

Callie saved.

So the not sure if I said this before already, but basically the.

So just to emphasize the, uh, the RBP register is the base pointer register.

You’re probably going to mess up, uh, the caller because the caller often uses RBP as

a bookmark for the stack pointer.

mark for the stack pointer you definitely don’t want to mess with a stack pointer unless you

actually know what you’re doing in order to create local variables um there’s another variable

another register in here called rip which is the instruction pointer register so if you

if you mess that one up then the program is going to start executing in some crazy place that doesn’t

even make sense okay so now that we’ve talked about general purpose registers by the way i

called special purpose registers, not general purpose.

General purpose is like RAX, RBX, all these ones that you can just randomly use as long

as you respect the ABI.

But the base pointer and the stack pointer, those are kind of special.

And the RIP, the instruction pointer, that’s a special register.

You shouldn’t mess with those unless you really know what you’re doing or you’ll get yourself

in trouble.

But now that we’ve talked about those, let’s talk about the floating point registers just

real fast.

about using floats until a lot later but basically

i at least want to mention that we do have registers that will work with floating point

operations let me see there we go okay so it’s 18.2 floating point registers um essentially

we use xmm0 through xmm13 for floating point numbers there’s not going to be any

not going to be any crazy letters like RDI, RSI that you have to memorize. You can just use zero

through 15 and it’s totally fine. When you want to return a floating point number from a function,

you will load up XMM0 as the return value. You won’t even touch RAX. The arguments are the same.

They’re just kind of ordered. It’s like the first argument is going to be XMM0. The second argument

is going to be XMM1 and so forth all the way up to XMM15. If you need more than 15 arguments,

some sorcery with the stack or with some kind of system like the global variable or something

and also for floating point registers we use different instructions so what I really want

you to know because this is mostly about the regular registers is that if you have floating

point numbers and you want to multiply them or do some other operation on them the normal

instructions for regular registers won’t actually work you’ll have to look up a different set of

and i’m going to do this in another video some other time uh if you want to move uh data with

a floating point register you can’t just use the regular move instruction you got to use either

move ss or move sd um and and both operands have to be floats or actually i think the one on the

right can be memory but um move ss basically means a single piece of data single precision

So you can move like multiple pieces of data at a time.

I’m not going to really cover that.

Um, but you can move single precision floating points, which means there are 32 bit floating

points or you can move double precision floating points, which means they’re a full 64 bit

floating point number.

There’s also bigger registers, but I’m not going to talk about that.

Yeah.

Well, yeah.

Later processors 256.

I think mine has that, but I’m not going to talk about that.

I think mine are like YMM or something.

So yeah, with that, those are the basics of registers and some stuff to keep in mind.

In future videos, I’m going to talk more in depth about making functions and calling functions

and all that stuff, respecting the ABI.

But for now, here is your primer.

I hope it was useful on CPU registers.

Thank you for watching this video.

I’ll see you in the future.

I hope you had a little bit of fun and you learned a little bit of stuff.

hey everybody thanks for watching this video again from the bottom of my heart I really

appreciate it I do hope you did learn something and have some fun if you could do me a please a

small little favor could you please subscribe and follow this channel or these videos or whatever

it is you do on the current social media website that you’re looking at right now it would really

mean the world to me and it’ll help make more videos and grow this community so we’ll be able

longer videos, better videos, or just I’ll be able to keep making videos in general.

So please do me a kindness and subscribe. You know sometimes I’m sleeping in the

middle of the night and I just wake up because I know somebody subscribed or

followed. It just wakes me up and I get filled with joy. That’s exactly what

happens every single time. So you could do it as a nice favor to me or you could

you could troll me if you want to just wake me up in the middle of the night.

Just subscribe and then I’ll just wake up. I promise that’s what will happen.

Also, if you look at the middle of the screen right now, you should see a QR code which you can scan in order to go to the website

Which I think is also named somewhere at the bottom of this video

and it’ll take you to my main website where you can just kind of like see all the videos I published and

services and tutorials and things that I offer and all that good stuff and

If you have a suggestion for

Clarifications or errata or just future videos that you want to see

please leave a comment or if you just want to say, Hey, what’s up, what’s going on? You know,

just send me a comment, whatever. I also wake up for those in the middle of the night. I get,

I wake up in a cold sweat and I’m like, it would really, it really mean the world to me. I would

really appreciate it. So again, thank you so much for watching this video and, um, enjoy the cool

music as, as I fade into the darkness, which is coming for us all.

Thank you.

The post Mastering x86-64 Assembly: A Beginner’s Guide to CPU Registers appeared first on NeuralLantern.com.

Want to understand bitwise operators? This video dives into OR, AND, NOT, XOR, and NOR with easy-to-follow examples. Learn how to use these operators for flags, masks, and more in programming. Perfect for beginners or anyone wanting to master binary logic in C or other languages. I break it down with real examples, a touch of humor, and no fluff. Subscribe for more coding tutorials, and check out my site for extra resources. Drop a comment with your questions or video ideas!

Introduction to Logical Operators 00:00:00
Explanation of Bitwise OR 00:00:35
OR Operation Examples 00:01:01
Bitwise OR with Multiple Bits 00:02:12
Using OR for Flags 00:03:52
Introduction to Logical AND 00:08:06
AND Operation Examples 00:08:29
Using AND as a Mask 00:10:00
Checking Specific Bits with AND 00:11:17
Introduction to NOT Operation 00:13:36
Introduction to NOR Operation 00:14:38
Introduction to XOR Operation 00:16:37
XOR and Neural Networks 00:16:53
Conclusion and Call to Action 00:18:38

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

Hey everybody! In this video I’m going to talk about basic logical operators such as OR and AND.

Uh so let’s let’s dive right into it. What am I talking about with the OR and AND?

Suppose for the sake of argument that this notepad is totally dark and I wanted it to be really light

and then I have to go into the system settings to fix it. Sorry let me change my theme.

How about that?

Okay.

So suppose for the sake of argument, we’ve got, you know, a couple of bits.

These are going to be a bitwise operations for the most part.

In other languages, sometimes we will say logical operator, but actually we’re just

talking about values rather than bits individually.

So these are bitwise operators.

Imagine we have like a couple of bits.

Remember the possible values for bits are just, you know, a zero and a one binary.

So suppose we have a couple of values.

values, let’s say we have a zero here and a one.

So if I apply a logical or to the zero and the one,

the result is going to be a one because either the first bit or the second bit are a one.

You could also expand these operators to have multiple sets of bits,

but we’re just going to do, you know, one set against another set.

In this case, each set is just one bit long, but we’ll do, we’ll do a more complicated stuff in a minute.

If I have a zero and a one, then the answer there is, well, let me just put or maybe.

The answer is a one.

I’ll put or maybe at the top, just like or to let you know that we’re doing ors here

on the top.

So if we have a zero and a one, the answer is going to be a one.

If we have a one and a zero, the answer is going to be a one.

Also, if we have two ones, which looks like an L over there, I got to work on my penmanship.

Then the answer is also going to be a one.

if either of the bits in question are a one then the answer should be a one. The only case with an

OR that results in a zero is if both of the bits are zero because neither the first or the second

are actually a one right so this is the basic idea of using an OR operator and you can also do this

with multiple bits at the same time like for example we could say let’s take a bunch of random

work on the it’s the pressure dude the l’s are driving me crazy okay oh my god okay so i do that

and i let go okay i’m just going to put some random bits uh underneath the the first set of

random bits put like a zero here and then like a one here maybe and we’ll say that we’re going to

do a logical or just like you might think of doing a you know addition or subtraction we’ll just say

you know, addition or subtraction. We’ll just say we’re going to or these two sets of bits.

Actually, these are six on the top and six on the bottom. If I add two more, then it’ll be a nice

little bite for the top and the bottom. So I’m just going to do that, you know, to have eight

bits on the top and eight bits on the bottom. Okay. So if I just want to logically or two sets

of bits, literally, I just have to do one pair of bits at a time. So a one or zero is just a one.

One or zero is just a one, a zero or one is a one, a one or zero is a one, a zero or one

is a one.

And then these ones, everything is just a one.

Okay.

So that was too easy.

Maybe if I, I don’t know, maybe if I change one of these ones to a zero, then we would

actually be able to have a zero somewhere in here.

So that’s a logical or a bitwise or operator or operation.

So you can, you can kind of use this in various ways.

can kind of use this in various ways i mean obviously if you want to manipulate some bits

this can be pretty useful inside of the machine but there was kind of an old school way that

people did flags with arguments they would basically say something like this they would go

in their computer program they would say you know flag a name it something like turn on the display

or enable caching or just like whatever right so we’ll just have a flag we’ll call it flag a

that value is equal to a one and then maybe flag b its value is equal to a two and then flag c

its value would be a four and then we basically just double the value of the flag and the reason

for that c d e f i’ll just stop with f maybe oh wait that was supposed to be 16 and that’s 32.

the reason for that is if you double the value of each flag so that uh

and then you can do a bitwise or against all of these flags and sort of combine multiple flags.

Because if you think about it, if we’re talking about binary,

if we suppose this is just a regular eight bit number, then, you know, the first bit has a

strength of one. If you’ve seen my other videos for converting between binary and hex,

the second bit has a strength of two. The next bit has a strength of four and then eight and

and then 32 and 64 and then 128.

And so if you look at the flags,

1, 2, 4, 8, 16, 32,

they map to only one bit.

It’s not going to be some kind of random pattern for these numbers.

It’s literally going to be flag A is going to look like this.

1, 2, 3, 4, 5, 6, 7, 8.

And then flag B is going to look like this.

1, 2, 3, 4, 5, 6, 7, 8.

five, six, seven, eight. And flag D is going to look like this. Whoops. Let me make that green.

Still getting used to this. Oh, sorry. C is the next one. One, two, three, four, five,

six, seven, eight. Can you see the pattern here? Let me just do D and be done with it at this

point. One, two, three, four, five, six, seven, eight. So because we’re increasing the value of

the flags by a power of two, or by a power of two, they’ll always correspond to just one bit.

they’ll always correspond to just one bit, which means if you apply a logical or operation,

you can represent a bunch of different flags with just one number.

Think about this.

What if I wanted to have, oh, I don’t know.

Let me erase this.

What if I wanted to have some, let’s say I wanted flag A and flag D and flag F just for

the sake of argument.

Dang, this pen.

It’s actually my fault completely, but I need to practice.

but I need to practice F okay and DNF so that would basically be you know 1 2 3 4 5 6 7 8

and then D would be the 8 so a 1 0 0 0 there and then a bunch of zeros elsewhere and then the F

So if we did an OR between all of those, then the OR is just basically 00101001.

And if you convert that from binary to decimal, what is that?

That’s a 1248 plus 8 plus 1248 and then a 32.

So 41.

just write down the number 41 and if the programmer is smart enough to you know parse all the bits

and everything then they’ll know that you have flags a and d and f set that’s not necessarily

something that all the modern programs do anymore it was much more popular in the olden days but i

think some people still kind of do it especially if they’re programming in c and other languages

where they want speed it’s pretty fast to look at bits inside of the machine so keep that in mind

Keep that in mind now we know how to do an OR operation and we know one reason that it might be useful and

Yeah, okay. I’m gonna move on to the next operation

So clearing the screen now

Hello little doggy he barked and now he’s in the room

Let’s do

The logical AND operation okay, so suppose we have two bits here

in a one only if both of the input bits are a one i’m gonna whoops i accidentally cleared the whole

entire thing let me forget where my red pen is okay and okay so if we have a zero and a zero

the result is zero because neither of those are a one if we have a zero and a one the result is

still going to be zero because we need both bits to be a one to result in a one so then that means

would also result in a zero. So you get a bunch of zeros until finally you have an input pattern

that is just two ones. And then finally the result is one. So that’s a logical and.

Let me do a quick example so we can and a bunch of bits together. I’m just going to do more

random bit patterns. So there’s another L there. I’m cringing. I’m self-cringing. One, two, three,

okay so then i’ll do like another one there and like a zero there and a zero maybe a couple of

ones maybe three ones and then a zero and then one i guess and we’ll just say that we’re going

to end those together so and oh man i’m mixing uppercase and lowercase like crazy

so uh to end them together you know that bit position right here that’s going to be a one

and then we have a zero because they don’t match they’re not both one and then we have another zero

a one and then we have a zero and a zero and a zero and a one so this is a logical and you can

use logical ands for a wide variety of things but one thing you can kind of do somewhat easily is to

use one number as a mask against another number for example notice how uh suppose this was the

input number let’s just say we have the input number up top and maybe you wanted to make sure

because you’re you’re checking for those bits individually or maybe you want to just prevent

the input from having certain bits on for some other reason well you can you can apply the mask

as the second bit and use a logical and i’ll say mask here sorry you can apply a mask as the second

bit pattern and notice how in the answer there are only ones where both you know the input and

means if I wanted to just control only which ones are allowed I can use the mask notice how the mask

has ones in these positions and there are definitely no zeros sorry there are definitely

no ones in any position where a mask had a zero so the mask can kind of like you know mute or mask

or control the input pattern if that makes sense hopefully another thing we could do if we wanted

if one bit exists. Let me go ahead and clear this real fast. I’m going to just do maybe four

bits this time. So we could obviously do an and against four zeros, and this would result in just,

you know, a resulting pattern of zero. So this is not super useful. The result would just

definitely be four zeros. But notice again how the second pattern is sort of controlling what’s

allowed to go through from the first pattern. Suppose I wanted to check to see if that particular

particular bit was on or off.

All I have to do is mask it with a one in the correct pattern.

So, you know, the second bit that I just wrote down on the bottom row,

I just want to see if that second bit is on or off in the input pattern.

I don’t care about any of the other bits.

That means the result will be this.

So now it’s much more easy for me to see if that bit is on.

I could just compare the value of those bits to a regular integer.

Like, for example, if we consider that this was the one and this was the two

considered that this was the one and this was the two and this was the four or sorry four and then

the eight I could just ask now if the final value equals two and then I would know if that bit was

on or not in the original pattern and so if I wanted to check to see if this other you know

bit was on I can move this over here and set that back to a zero so the resulting pattern would be

zeros then I’d ask myself is the resulting value equal to four no it’s equal to zero and so then

Another thing you can do that I’m going to talk about in a future video is just sort of shift the bits over.

You could, instead of checking to see if the value was a 4 or like a direct integer,

you could just sort of shift over a certain number of spots and then check to see if it was equal to 1 or 0.

Let me put this 1 back over into its original position just so that we’ll have something that had a 1.

is one from uh you know the right side if it’s one to the left from the right side

then i could just shift all the bits one to the right and end up with a pattern that is zero zero

zero one i’m not going to talk about bit shifting operations in this video but just know that you can

and you’ll see more of it in a future video so then you know this is another way to check to

see if a bit was on first you do a mask for that bit and then you shift bits and then you just

check to see if the final value is a zero or one which may or may not feel easier than checking for

or may not feel easier than checking for an actual integer in your program.

Okay, so we’ve done OR and also AND. The next bit pattern is called a NOT, which is really easy.

It’s literally just an inversion of the original bit pattern. So for the NOT, we don’t really take

two bits against each other. We just take an input bit and we just invert it. We’ll just say

So that’s a knot. Pretty easy. We could also knot, you know, a random bit pattern with Ls.

So I swear, somebody’s going to show up and this is their first computer science video.

They’re going to go tell their parents, hey, there’s Ls in computer science.

So sorry. I’m so sorry. Okay. So I got four there. So if I knot those, then that’s pretty easy.

It’s just going to be the opposite, you know, an inversion.

you know, an inversion.

One, zero, one, zero.

Let me just double check that I did that correctly.

Yeah, so that’s the knot pattern.

No big deal.

Pretty easy.

So then maybe the next thing that we can talk about is the nor,

which just means not or.

So let me draw that out real fast just to show you what I’m talking about.

So if we do nor, pretty much you can imagine first taking the or and then knotting it.

So inverting the or.

the OR. So for example, if we have two bits here, actually, let me, let me do, let me do a

sequential counter. Cause I think that’s more fun. I’m counting right now from one to a three

or a actually, I do that in the last one. I started with zero. I hope let’s count from zero

to three. So zero and then one and then two and then three. So I’m counting in binary.

two input bits and we’re going to do a nor then the first thing we probably want to do is take

the or operator so that would be a zero here i’ll just put or in parentheses just to let you know

that this is kind of a nice first step you could memorize nor if you wanted to but i don’t i don’t

really remember how to do it without doing these steps so uh it’s going to be ones for everything

else because in the or you get a one if either of those is a one and then uh the next step is you

the or i’ll just put nor here just to let you well just to let you know that you’re uh well i

don’t know if i put nor then it kind of sounds like i’m norring that one bit doesn’t it so maybe

here i’ll say uh not just to let you know that this is just one step against the previous bit

so the knot is uh just going to be an inversion and so the nor of zero zero is one the nor of zero

nor of 1 1 is 0 and that’s how you do a nor and all of these logical or bitwise

operators can be used in circuits and circuit design and just you know other

types of logical operations I’m gonna move on let’s see the next one is gonna

be XOR that I wanted to talk about in this video so what is XOR it just means

exclusive or so it’s a little bit more complicated than or this is actually a

one because it has a history with neural networks. When you have a neural network that does not have

more than one, or sorry, if you have a neural network that does not have any hidden layers,

like if you just have an input layer and an output layer, then the neural network should

actually not be able to solve XOR. It should not be able to learn it. You have to increase the

topology of the neural network in some way, make it a little bit more complicated. For example,

one or more middle layers between the input and the output layers. If you understand neural

networks, it’s just kind of fun to know, oh, XOR stumps a shallow network and kind of starts to

prove that deep networks might be a little bit smarter or deepish at least. Okay. So XOR,

let’s start off by counting here. I’m going to do zero and zero, and then this is the number one,

and this is the number two, and this is the number three. And exclusive OR just basically means

just basically means an or but if both of the bits are one then it’s a zero so that means

either of the bits can be a one to produce a one but it must be exclusive the bit that is a one

can’t also be next to another bit that’s a one so let me show you so in is in a double zero

the answer is just going to be a zero in a zero and one the answer is going to be a one in a one

exclusive, the one is it has a, it has a buddy or a partner.

It’s not an exclusive one.

So we’ll say that that’s a zero.

So that’s the XOR.

I don’t know.

You could put like a, a, a not on top of that or an and on top of that or whatever

you wanted to do.

And we can make stuff that’s a lot more complicated, but these are the basics of

or and not XOR and NOR as bitwise operators.

So thank you for watching this video.

That’s all I have to say for now.

See you in the next one.

Hope you learned a little bit and had a little bit of fun.

I’m out.

social media website that you’re looking at right now it would really mean the world to me and it’ll

help make more videos and grow this community so we’ll be able to do more videos longer videos

better videos or just i’ll be able to keep making videos in general so please do do me a kindness

and uh and subscribe you know sometimes i’m sleeping in the middle of the night and i just

wake up because i know somebody subscribed or followed it just wakes me up and i get filled

with joy that’s exactly what happens every single time so you could do it as a nice favor to me or

it as a nice favor to me or you could you could troll me if you want to just wake me up in the

middle of the night just subscribe and then i’ll i’ll just wake up i promise that’s what will

happen also uh if you look at the middle of the screen right now you should see a qr code which

you can scan in order to go to the website which i think is also named somewhere at the bottom of

this video and it’ll take you to my main website where you can just kind of like see all the videos

i published and the services and tutorials and things that i offer and all that good stuff and

if you have a suggestion for uh uh clarifications or errata or just future videos that you want to

see please leave a comment or if you just want to say hey what’s up what’s going on you know

just send me a comment whatever i also wake up for those in the middle of the night i get i wake up

in a cold sweat and i’m like it would really it really mean the world to me i would really

appreciate it so again thank you so much for watching this video and um enjoy the cool music

the cool music as I fade into the darkness which is coming for us all.

Thank you.

The post Master Bitwise Operators: OR, AND, NOT, XOR, NOR for Beginners appeared first on NeuralLantern.com.

Hey coders! Dive into this quick DDD tutorial to learn the Data Display Debugger for C++ and C programs. See how to launch DDD, set breakpoints, view source code, and use the GDB console. I’ll walk you through the basics, but check my GDB video first for a better debugging foundation. If you’re new to GUI debuggers or just curious, this is for you! Subscribe for more programming tips, and let me know in the comments if you want advanced DDD content. Scan the QR code for more tutorials!

Introduction to DDD 00:00:00
DDD vs GDB Comparison 00:00:04
Installation Instructions 00:00:56
Launching DDD 00:01:20
Source Code Window 00:01:57
Setting Breakpoints 00:03:16
Running and Debugging 00:04:08
GDB Console Commands 00:04:21
Modifying Breakpoints 00:05:20
Closing DDD 00:05:36
Recommendation to Learn GDB 00:05:48
Call to Subscribe 00:06:32
Website and Comments 00:07:17

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

DDD debugger, Data Display Debugger, debugging tutorial, C++ debugging, C debugging, GDB debugger, programming tutorial, software debugging, coding for beginners, debugger GUI, set breakpoints, source code debugging, Ubuntu debugging, learn to code, programming tips

hey there in this video i’m going to give you a very very quick overview

of a program called ddd which you can use to debug your programs

disclaimer you should see my gdb video first before you watch this one because it’s much more

useful and in my personal opinion gdb is a much better debugger than ddd ddd ddd is actually

over GDB so it doesn’t really add any more functionality it’s sort of for

people who like to use GUI’s but the GUI is not it’s not very good but it’s

there if you’re still struggling with the command line anyway so yeah see my

other video if you want to learn about make files if you want to learn about

C++ C assembly GDB debugging all that stuff are in other videos but assuming

that you know how to use GDB we can start on DDD now DDD anyway if you don’t

Anyway, if you don’t have DDD on your system, you can go sudo apt install DDD.

I’m on Ubuntu.

You could use whatever package manage you have on your system like DNF or whatever.

So sudo apt install DDD.

I don’t have to do that because I already have it on my system, unfortunately.

Anyway, so the first thing that you can do is you can sort of launch it with DDD up here.

It’s called the data display debugger.

You can launch it and then you can attach it to your program for me.

attach it to your program for me i like to just launch it uh from the command line i’ll type ddd

and then the name of my executable i’ll build my executable real fast again this all this stuff is

in another video how to build and you know what so forth so i’m going to build my uh executable

and there it is main so i’m going to go ddd main and this is the uh i can’t remember the name of

display debugger yeah I don’t really like to use this anyway you can see that

right away there is a source code window visible which sort of looks at your

program’s source code if that’s not visible you can click on the view menu

item up here and start you know enabling and disabling windows there’s a data

window to let you look at data there’s a machine code window I’m just gonna

basically make sure that the GDB console is up and that the source window is up

when I closed both windows hoping that I could show you that I opened both of them it just shut

down the whole program okay anyway so yeah click view and make sure that the source windows open

so we can see our source code and then also make sure that the gdb console window is open so we can

type gdb commands and then um well you know probably if you know gdb you’ll you’ll you’ll

want to start typing commands here you know enter a breakpoint at main.cpp line you know

dot cpp line you know whatever but once you start doing that a lot you’ll realize maybe you don’t

need to be inside of ddd with ddd you can right click on a line and add a breakpoint manually so

that’s a little convenient i think we can do can we do control mouse no there’s a lot of obscure

areas here well you can go to the preferences and change the font size i think i’m not going to deal

with that in this video but so suppose for the sake of argument i wanted to break at this line

line right here I could just right click on it and I have to hold down the right

mouse and say set breakpoint and then I could do the same thing for this set

breakpoint and then for this set breakpoint so it’s a little more

convenient a little bit faster if you like looking at the text in this way to

set breakpoints and then you can disable breakpoints and you can delete breakpoints

and you can reset the execution position if you’re absolutely sure you know what

know what you’re doing you can have your program skip an area and jump somewhere and then once

i’ve kind of set up my break points i can go up here at the top this is the uh i forgot what

window this is called but i can basically hit run which i accidentally already clicked when i was

trying to resize the window there we go oh i can’t resize it okay so we’ll go run and uh

well now we’ve already hit a breakpoint right away notice how at the bottom in the gdb uh

GDB console area it says breakpoint 2 at line 36 and then there’s a green arrow here letting

us know that we hit one of our breakpoints already so then we can do normal GDB stuff

we can go info breakpoints just to kind of see what’s in there and you can resize with this

handle on the very right side I don’t think it works in the middle here I’ve tried it many times

but so you can kind of resize with this handle on the right side to get more real estate for

panel and so it’s telling me all right I did info breakpoints just to see the

breakpoints I can go info locals to see my local variables like a print a

variable you know all that all the normal GDB commands I’m gonna hit

continue and five to skip the next five times this breakpoints get hit this

breakpoint gets hit now the next breakpoint that gets hit is this other

one over here I can do the same thing info locals I can see the state of all

what is b you know what is i what is a what is whatever and when i’m finished i can say continue

and i can also modify my breakpoints by just sort of like deleting them enabling them disabling them

but that’s me trying to type everything in the terminal of course with ddd you can right click

on a breakpoint and disable it or delete it and so forth when you’re eventually done let’s see

kill the process and then you can just kind of exit DDD at this point or you can exit

the GDB console with Q and that’s it that’s the basics for DDD.

However again I strongly encourage you to learn GDB first and by the time you do that

you will probably not want to use DDD.

But I have to put up this video regardless.

Let me know if you’re interested in very advanced stuff covering DDD.

20 years, I might upload another DDD video. You never know.

Okay, thanks for watching this video.

I hope you learned a little bit, and I hope you go directly to the GDB video after this.

See you in the next one.

Hey everybody, thanks for watching this video again from the bottom of my heart. I really

appreciate it. I do hope you did learn something and have some fun. If you could do me a please,

Could you please subscribe and follow this channel or these videos or whatever it is you do on the current social media

Website that you’re looking at right now

It would really mean the world to me and it’ll help make more videos and grow this community

So we’ll be able to do more videos longer videos better videos or just I’ll be able to keep making videos in general

So please do do me a kindness and and subscribe

You know sometimes I’m sleeping in the middle of the night and I just wake up because I know somebody subscribed or followed

subscribed or followed. It just wakes me up and I get filled with joy. That’s exactly what happens

every single time. So you could do it as a nice favor to me or you could you could troll me if

you want to just wake me up in the middle of the night just subscribe and then I’ll just wake up.

I promise that’s what will happen. Also if you look at the middle of the screen right now you

should see a QR code which you can scan in order to go to the website which I think is also named

somewhere at the bottom of this video and it’ll take you to my main website where you can just

all the videos i published and the services and tutorials and things that i offer and all that

good stuff and uh if you have a suggestion for uh uh clarifications or errata or just future videos

that you want to see please leave a comment or if you just want to say hey what’s up what’s going on

you know just send me a comment whatever i also wake up for those in the middle of the night i

get i wake up in a cold sweat and i’m like it would really it really mean the world to me i

really appreciate it. So again, thank you so much for watching this video and enjoy the cool music

as I fade into the darkness, which is coming for us all.

Thank you.

The post DDD Debugger Tutorial: Fast Guide to Debugging C++ & C Code appeared first on NeuralLantern.com.

Hey coders! Ever hit a wall with a program that just won’t work? In this video, I’m spilling the beans on caveman debugging—a super simple, no-fuss way to hunt down bugs in your C++ code (or any language, from assembly to Python)! No need to wrestle with complex debuggers; this method is all about using print statements to trace what your code is doing, step by step.

I’ll show you a real C++ program where things go wrong (think integer overflows and mystery crashes) and walk you through how to sprinkle in cout statements to spot the problem fast. You’ll learn how to label decision points like loops and if-statements, break down complex expressions with temporary variables, and format your debug output so it’s easy to read. Plus, I share a neat trick called short circuiting to toggle your debug prints on or off without deleting them—saving you tons of time!

Whether you’re a beginner just starting out or a pro debugging a massive codebase, caveman debugging is a lifesaver. It’s quick, it’s intuitive, and it fits my “let’s figure this out” vibe perfectly. Stick around to see how I catch a sneaky bug in a for-loop and fix it in minutes.

Why watch?

• Learn a beginner-friendly debugging technique that works in any language.
• See real code examples with clear, relatable explanations.
• Get tips to make your debug output readable and avoid hours of frustration.
• Discover how to short circuit print statements for reusable debugging.

If you’re ready to level up your coding game and squash bugs like a champ, smash that play button! Don’t forget to subscribe and hit the bell for more coding tutorials, from beginner hacks to advanced tricks. Drop a comment if you’ve ever used caveman debugging or have a bug you need help with—I read every one! Check out my next video on using a proper debugger for even more debugging goodness.

Scan the QR code on-screen or visit my website (linked below) for more tutorials, services, and coding resources. Let’s keep the coding community growing—your support means the world! #CavemanDebugging #CodingTips #DebuggingHacks

Hey everybody! In this video I’m gonna try to familiarize you with a concept

called caveman debugging. It’s just as bad as it sounds but it’s really really

really useful. So suppose for the sake of argument you’re writing a program I’m

gonna show a C++ program here but this this concept is not just for C++

debugging it’s also for assembly and any other kind of language that you can come

other kind of language that you can come up with but suppose I have a program and I’m trying to

figure out why it’s not working so if you look at this program right here that I’ve kind of written

up already we have a main function here and we have like a little hello message that’s not my

name I love that name though and we have a variable a and then we just sort of do some nonsense to it

to try and compute a value for a when I say nonsense I mean literally I’m just I just made

I’m just I just made up instructions the point of this video is not to show you some advanced program

It’s just to show you that you know

This is how you can possibly debug a program that has gone awry

So you can imagine at home that this code you’re seeing right here might be your larger project your larger

Code base whatever it is that you’re doing that is not working for some reason and you’re not sure why

So, um, let me run the program real fast

It basically is just like a little for loop and then it just sort of

of you know not randomly but it just kind of increases the value of a for no reason

a bunch of times and then it calls a function that will crash later

so let me show you what happens when we try to run this program okay do do do

okay i want to go clear and make run if you don’t know how to do a make file or compile

or link or anything like that uh then go see my other videos so clear and make run

What did I do wrong?

TempResult was not declared in this scope.

Okay, well, this is now a video on reading compiler errors.

Line 59, I probably left something out.

Oh, because I just changed it.

I forgot to put it back in there.

Return tempResult, we should just return input times two.

And I’m just making this up.

It’s not really like a valid algorithm.

Okay, so we run our program.

We print the final result and we realize for some reason the final result is wrong.

result is wrong. So I don’t, I mean, I just made this up. So I don’t really know what the right

answer is. But just imagine that you are looking at some sort of an output, some sort of a final

state, maybe a crash. And you realize, oh, my program doesn’t work, but it’s too complicated

to figure out. Caveman debugging to the rescue. Caveman debugging kind of is as bad as it sounds.

It’s just really, really simple. But it’s also really useful, especially if you just want to do

on you don’t want to dive deep into a full-on debugger or do something more advanced it literally

is just printing a lot of things while your program is running i do it all the time i usually

don’t even go to a debugger unless i really get in trouble with like some huge mess um okay so

the first thing i’m going to say is in this for loop we uh you know we’re kind of like iterating

And so probably this is a good idea to announce that we’re iterating in the for loop.

So I’m just going to go Cout.

In C++, you know, we have the Cout object that we can use to stream texts to standard output,

which usually goes to the terminal.

So use whatever construct you’re using for your particular language.

So we’re going to do Cout.

And I should say also, if you’re programming in assembly,

if you are programming in assembly,

it’s a little bit more complicated than just writing a Cout.

little bit more complicated than just writing a C out you probably have to have some pre-computed

messages and then you can use a library to print a number to the screen or use printf to print stuff

to the screen but you can do it just takes a little bit longer so anyway conceptually I’m

just going to say this is the first iteration of my loop so I’m going to sort of announce it I’m

going to say main and then I’m going to call it main four or how about primary four or first four

but I want to try to label the for loop.

And maybe instead of leaving those parentheses blank,

I could say iteration number i right there,

or maybe I could do iteration i.

That would be pretty good.

Then I just have to replace the i with the actual variable i

so that the i keeps increasing.

So I’m just going to like do another stream operator here

and I’m going to say i.

Then I’ll print a new line.

we’ve got, you know, one iteration of our loop.

Maybe I should also print what is the current value of A

because the point of this, you know, weird nonsense code

is we’re coming up with a value for A, right?

So I should just print what A is at the top of each iteration of the for loop.

So I’m going to say A is equal to, and then do another A at the end of it.

And then maybe at the bottom of the for loop,

when the for loop is actually ending one of its iterations,

I can just say we’re at the bottom of the iteration so maybe I’ll put to end

iteration and then print the final value of a and then at the top I’ll say begin

iteration at this point you might start to feel like hey aren’t you using too

many words here like why can’t I just print a bunch of numbers I mean you

could but when you’re coding you need all the brainpower you can get to not

just code but to debug coding is already hard enough without making it harder

harder for yourself than you need it to be. So, you know, I see people all the time, they’re

trying to debug their code and they just like start printing numbers. And after not very long

at all, they’re looking at the debug output and they’re just like, what did that number mean?

Where is the number I’m looking for? It’s just a bunch of numbers. It’s harder to debug when you

do it that way. Do it the nice and pretty way. It just costs you a couple of extra keystrokes to do,

you know, nice letters and new lines and things, nice words, labels. Isn’t that still a lot better

Isn’t that still a lot better than debugging for an extra six hours?

Because you can’t really understand what you’re seeing.

Anyway, let me show you what this looks like so far with just those two lines added.

Now we can kind of see, alright, alright, on iteration number 61, where I was 61, then

this was the first value of A and then after that this was the second value of A, you know,

when we were finished with the iteration.

It seems to have gone up by a certain amount.

you know it was like a negative blah blah blah 836 and then negative blah blah blah 708 so it

kind of increased in value all right that’s a little bit helpful now it’s a really good uh

place to uh print our decision points so anytime in your code where you have an if or an else or

a function call or anything where you are kind of like you know making a decision or processing your

data in some way it’s probably a good idea to announce your decisions so i could say up here i

say up here i can go maybe i’ll say uh main first four and then i’ll call it uh maybe i’ll do a

double colon there and i’ll say top if just to make it easy to read that i’m kind of like at

the first if statement um maybe i’ll even put parentheses i’ll say a is more than 20 just to

kind of like name what i’m actually doing and then i could replace the a with the actual value of a

actual value of a so i could say a like that and maybe uh when i’m reading this later i might want

to kind of actually see the variable name so i could say uh you could just like put a as a string

and then maybe its value in parentheses or something like that do a new line um and then

maybe after that top thing i’ll say uh true to indicate that we’re inside of the the if statement

the if statement and then maybe at the bottom of that if statement we’ll just say

a is now true and we’ll say like a is now you know whatever the new value of a was so just

basically we’re announcing that we decided to go into this if block and then we announce what we

ended up changing a to and also you probably anytime you see a compound expression like this

You know B time something or a plus something or just you know a big part of multiple parts of the expression any expression

That’s more than just like one variable or one number. It’s probably a good idea if you break that up into temporary variables, too

and then

Print out each variable and I know that’s a lot of stuff to read but again it beats debugging for an extra six hours

I’m gonna leave that be for now though

leave that be and

I’m just gonna continue adding comments into the rest of the code. So I’m gonna do the second if block here

So I’m going to do the second if block here.

I’m going to say we’re in the first floor.

We’re in the bottom if more than 20 true.

And then we’ll print out what is the value of a after we’re finished.

We’ll say a is now is now whatever value for a.

And then I’ll do the same thing for this function call.

Because, you know, when I call this function, it’s going to change the value somehow.

So we’re going to do cout about to a plus equals f, you know, call to f.

And then inside the arguments, I’m obviously putting i plus 3.

But because i is a variable, we could just print that.

So I’m going to do quote, quote, and then just stick the actual i in there.

And then another new line.

a finished a plus equals f and then I’ll just say you know a is now you know a you know print the

new value of a you could also say a equal equal a and then print the value whatever you want but

the point is I’m just printing everything here so now let’s go down a little bit more because

there is a function call if you look at this function call down here here’s like some nonsense

being used here’s some other like you know disabled code really what i’m doing at the

very end is i’m just taking the input that the function received and i’m just multiplying it by

two and returning it so again imagine that your code is a lot more complicated than this

maybe input times two is actually input times two divided by three and then some other function

call and then some other this and some other that and whatever so a lot of people will just kind of

stuff like a really complicated expression in one line or one assignment or one return statement

And that’s super confusing because you can’t really be sure that every part of the expression is as you thought.

So it’s a really good idea to break it all up into parts and print each part.

So you could imagine that we have like a C out here and we’ll say C out, you know, begin F.

I’ll say like begin for F and then F receives an input of input.

Do an end L.

And then I’ll make a temporary variable here.

variable here I’ll say int temp results equals input times two and then I’ll

print that f and maybe I’ll do the input again

temp result is now and then say temp result so I’m just gonna print what the

temp result actually was and I could print something about I just multiplied

thing about I just multiplied the input by two and then you know the more

complicated your expression is the more temporary variables you want to use and

just kind of print every single one of them and print you know this new

variable is the result of dividing by two this new variable is the result of

calling some other function and so forth

so then we have like a basically you know basically a pretty good idea maybe

at the end though instead of multiplying by two again you want to make it more

want to make it more consistent with your debug output so like here temp result is obviously going

to be the result that i return why would you do the expression all over again for the return part

when you could easily get it wrong why not instead just return the temp result that you made right so

then that way your output completely matches what you’re actually returning and for now i think

that’s all we need to do let me run it one more time and then you’ll see a bunch of stuff now uh

Now, we have a lot of information that we can use to trace how our program was thinking and hopefully find the problem.

But isn’t this like a little bit starting to get a little bit hard to read, right?

You can see that there are kind of blocks happening whenever we iterate.

So, you know, for me, I always try to keep in mind you need all the brainpower you can get.

Why not just format it a little bit better so it’s really easy to just quickly look at one block and see, you know,

the couts kind of like belong together so i’m just going to add one more cout in the main for loop

here just at the very bottom i’m going to go couts and l just so that i get a new line and if i run

the program again notice how it’s easier to see the blocks like oh that’s clearly one iteration

right here you know your mind just grabs onto it faster and that increases your brain power and

makes it easier to debug and read the debug output so i can go all right all right okay so

all right okay so we’re right up here oh around uh iteration um number 83 uh a was this number

and then it got increased by uh this other number and the reason that that happened is because the

function returned 172 so it basically increased it by 172 and then it ended up being that number

oh okay i think i see what went wrong oh no right in this particular program if we scroll up just a

little bit we can probably see that the integer is overflowing right the integer was getting bigger

right the integer was getting bigger and bigger and bigger here and then eventually

it jumped into the negative at some point so right here we can see oh okay when did this

number become negative suppose we didn’t want it to be negative um what was this this is like

a million this is a billion no wait wait wait this is uh no that’s a million right there so it’s like

299 million and then it overflowed oh no no it didn’t it didn’t overflow it started at 299

it started at 299 then at the bottom it was sitting at 899 million that’s kind of close to a billion

and it did jump up from 300 million to 900 million so that’s a jump up of like 600 million

oh you know it’s like kind of jumping up faster with each iteration oh and i’m using a 32-bit

signed integer which has a maximum value of around 2 billion so now i could possibly realize at this

the number is just like it became too big and I need to change my data type or I need to change

my algorithm for some reason right so you can kind of get to the bottom of things pretty quickly

so here’s another problem that people encounter when they’re using caveman debugging

basically you you add all these cout statements or print statements or whatever you’re doing in

whatever language you have and then when you’re finished you’re kind of like well I guess uh

I need to delete all of these Couts because I don’t want all this you know

Junk being printed in my program after I fix the problem or maybe you’re trying to debug a different part of your program

So then you start commenting out all the print statements or you start

You know deleting them or whatever and then whoops later on you realize maybe that part of my program

Was not actually fixed and I have to add all the Couts all over again from scratch that costs time

So that’s not fun. So here’s a trick that I like to use. It’s called a short circuit

it’s called a short circuit it’s a sort of like a beginning C++ thing or just

when you’re first learning how to use logical operators for boolean

expressions so I’m gonna do a boolean and I’m just gonna name it after what

problem I’m trying to solve so we could just call this you know main C outs or

something like that let’s I don’t know primary problem I’ll call it primary

the boolean as true because then what will happen is uh we can then short circuit all of the cout

statements we can say primary problem couts and cout like that and the way the short circuit works

works is if you have a logical and expression you can see right here we have two sides

of that statement now one’s on the left which is just the boolean and one’s on the right which is

have a logical and then you know one and zero is equal to zero true and false is equal to false so

both things have to be true for the expression to evaluate to true which means if the first thing

is false there’s no point in even looking at the second thing at all because if i if i set that to

false then the second part the c out is it doesn’t matter the whole expression is going to evaluate

to false anyway so uh the logical operator itself will just you know block out the rest of the

you know, block out the rest of the statement.

That’s called a short circuit.

So I’m going to copy the short circuiting to all of my C out statements like this.

Okay.

And do that.

And then the C out there.

And I guess I’ll leave the final result there.

And for the moment, you know, this is just a regular function.

apply the short circuiting to this other f unless I do a separate boolean but

keep in mind if this was a class and you had two different methods that you

wanted to short circuit see outs inside of at the same time you could just use a

member variable and name it after the problem you’re currently trying to solve

and then just short circuit each see out in the appropriate method with that

boolean so I guess in this regular program that doesn’t have a class I

could move the boolean into the global if I wanted to but I’m not going to right

if I wanted to, but I’m not going to right now.

And if you’re writing assembly or some simpler language

and you’re thinking, hey, I can’t short circuit an assembly

or some other language, well, you could write a function

that just takes a couple arguments.

You could write a function that takes a string to print

and maybe a number to print or just, you know,

something simple like that.

And then in the function itself that prints,

you could call it debug print if you want.

Have it look at a global variable or define

that you’ve set up at the top of the assembly module.

set up at the top of the assembly module, which you can just turn on and off,

like just do a data byte and set it to a zero or set it to a one.

And then the function debug print will just look at that variable to decide

whether or not it’s going to actually print or not.

So, you know, it’s a little more complicated in assembly,

but you can do it basically the same concept.

Let’s run this again just to make sure it still works.

Okay, so it still works.

So now suppose I want to turn off all the Cout statements.

If I just change the true to false,

the true to false notice how it’s all gone except for the stuff inside of f which i told you i

wasn’t going to touch but notice how easy it was to mute it and then if i want to bring it back

later i just go true to unmute it of course if you want to do a little bit more typing you can

also do if statements like if this condition is true and that condition is true then print the

debug statement so then you can have a more complicated way of muting and not muting but

I’m going to leave it as is right now.

Let’s see, what else do we got here?

I think actually at this point, this is the basic idea of caveman debugging.

Just basically print everything.

Print all of your decision points.

Use pretty labels that are really, really easy for you to understand.

Use formatting so that your brain doesn’t have to struggle to understand what you’re seeing.

If you just print a bunch of numbers, you’re going to be shooting yourself in the foot.

you’re going to be shooting yourself in the foot and use short circuiting or if statements to

selectively mute them so you can do less typing and and debugging the debugging and so forth but

yeah i think i think this is all i really wanted to show you in this particular video

i hope you feel like an expert in caveman debugging i certainly am and it you know it

kind of fits my personality a little bit i’m like what’s going on um and like i said before

debugger it’s probably a better idea but I usually don’t unless I’m in big trouble

and I have a huge mess on my hands I usually just go directly to caveman

debugging we’ll look at the same piece of code in my next video that I’m going

to publish which is going to talk about using a proper debugger so watch the

next one also but for now I hope you’ve enjoyed this video thank you for

watching I hope you learned a little bit and had a little bit of fun see you in

video

whoops what the heck

hey everybody thanks for watching this video again from the bottom of my heart

i really appreciate it i do hope you did learn something and have

some fun uh if you could do me a please a small little favor could you please

subscribe and follow this channel or these videos

or whatever it is you do on the current social media website that you’re looking

at right now it would really mean the world to me and

more videos and grow this community so we’ll be able to do more videos longer

videos better videos or just I’ll be able to keep making videos in general so

please do do me a kindness and and subscribe you know sometimes I’m

sleeping in the middle of the night and I just wake up because I know somebody

subscribed or followed it just wakes me up and I get filled with joy that’s

exactly what happens every single time so you could do it as a nice favor to me

or you could you control me if you want to just wake me up in the middle of the

and then i’ll i’ll just wake up i promise that’s what will happen also uh if you look at the middle

of the screen right now you should see a qr code which you can scan in order to go to the website

which i think is also named somewhere at the bottom of this video and it’ll take you to my

main website where you can just kind of like see all the videos i published and the services and

tutorials and things that i offer and all that good stuff and uh if you have a suggestion for

clarifications or errata or just future videos that you want to see please leave a comment or

if you just want to say hey what’s up what’s going on you know just send me a comment whatever i also

wake up for those in the middle of the night i get i wake up in a cold sweat and i’m like

it would really it really mean the world to me i would really appreciate it so again thank you so

much for watching this video and um enjoy the cool music as as i fade into the darkness which is

us all.

Thank you.

The post Caveman Debugging: Simple Trick to Debug C++ Code Like a Pro! appeared first on NeuralLantern.com.

Confused by hexadecimal numbers? Don’t worry! This fun, step-by-step guide makes converting hex to decimal super easy, even for beginners. With clear examples and a chill vibe, you’ll master this computer science skill in no time. Perfect for students, coders, or anyone curious about number systems. Hit subscribe for more coding tutorials, and check out our site for extra resources! #HexToDecimal #CodingForBeginners #ComputerScience #LearnToCode

Introduction to Hexadecimal Conversion 00:00:00
Purpose of Conversion 00:00:11
Number System Basics 00:00:39
Hexadecimal Explanation 00:01:12
Converting Hex to Decimal 00:01:59
First Example Setup 00:02:35
Decimal Place Value Recap 00:03:02
Hexadecimal Place Value 00:05:14
Formula for Conversion 00:05:43
Translating Hex Letters 00:08:17
First Example Calculation 00:09:51
Second Example Introduction 00:11:14
Second Example Conversion 00:11:58
Second Example Result 00:13:11
Conclusion and Call to Action 00:14:00

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

Hello there. Let’s talk about converting hexadecimal to decimal.

So why would you do this? Of course, sometimes in computer science and other realms, you may be

faced with a number that looks like this, and it’s got some letters in there, and it’s weird,

and you’re thinking, oops, not a V. That wouldn’t work. Not a G. And you’re thinking like, what does

what does this number mean in decimal well this is a number that is real and we can just change

the way it’s represented uh to decimal so that we can understand what it is so just like a quick

recap if you haven’t watched my other videos yet uh in decimal we have a base 10 system which just

basically means we have these characters zero one two three four five six seven eight nine there

base is 10. In binary, of course, we have base two, which is just, you know, we have a zero and a one

because in the computer, which is why we learn binary, we just have on and off basically for

every single, you know, part of the computer. There’s just like a certain voltage or there’s

not a certain voltage and that’s it. And then for hexadecimal, which is a way to represent the same

numbers, but just in a more compact way. It’s a little bit more compact than decimal. It’s a lot

than binary we can say that this is base 16 which means we have 16 total characters that we can work

with zero one two three four five six seven eight nine and once we run out of numbers we just start

using letters so a b c d e f so there are 16 total characters if we include the zero which means we

So that’s the basics of you know the number basis let’s uh let’s work out how to convert a hex

number to decimal. So I’m going to say ox because in hex when you write down a hex number you should

usually put ox in front of it unless the program you’re working with doesn’t understand that but

usually especially for a human reader you should do it this way. So I’m going to just type like a

few random maybe I have to I have to keep the number small because hex will explode it’ll be

not careful. So I’m going to put like a I don’t know, maybe a few decimal numbers there or a few

like digits that are zero to nine, then I’ll just to make it more interesting, I’ll put some letters

in there. How about like an E there? And then I don’t know, like, we’ll do a B there. Okay, so

how many do I have? 12341234? How about we get rid of? Now, let’s go for it. This is going to be an

So this is our starting number hexadecimal. What we need to do is understand that, well,

a recap if you haven’t watched my other videos yet. In decimal we have, let’s say, 0, 1, 2, 3,

4, 5, 6. You know that the first digit has a strength of 1. You multiply 6 by 1 to understand

the real power of that 6. For the 5, you know that it has a power of 10 or a strength of 10

10 because it’s the next digit over you know to the left same thing for the four it’s like got a

strength of 100 and so every time you move to the left the strength of the digit increases by a

factor of 10. why does it increase by a factor of 10 because decimal is base 10 because we have 10

possible digits we can represent for each character okay so by the time we get to that

left, we have a strength of 100,000. So, you know, if you wanted to really understand 100,000,

if you really wanted to understand, you know, how powerful, let me, let me give some spacing here.

So this feels better. Okay. If you really wanted to understand like, you know, what is the strength?

What is like the actual value of this digit right here? You’re imagining this is like 100,000.

this digit here you’re imagining that this is two of ten thousand you know two times ten thousand

and so forth so uh uh just like another recap the first digit is really 10 to the zero power

like in terms of the strength because if you multiply um let me pin this to the top

if you multiply you know 10 to the something power and you start at zero with the most

the weakest digit 10 to the zero power gives a strength of one and then every time you move over

to the left you just increase the exponent there by one so 10 to the first power is going to be 10

that’s what that five has got so it’ll be five times 10 to give us an understanding of how you

know powerful that digit is move one over to the left it’s 10 to the second power so that’s 100

move one over to the left it’s 10 to the third power and so forth until we get to 10 to the fifth

1 times 10 to the fifth power to understand how powerful that is so we can do the same exact thing

with hexadecimal except instead of raising 10 to a power we raise 16 to a power because hexadecimal

is base 16 whereas decimal is base 10. so that means this e is is uh you know 10 to the or sorry

16 to the zero power and then that 3 is 16 to the 1 power and that f is 16 to the 2 power and so

16 to the 2 power and so forth so first what we should do is let’s write out a

formula which won’t work in a calculator because we’re going to put some letters

in there and then later we’ll translate the letters to actual values so we’ll

start off with the e we’ll say e times 16 to the something power it’s going to be

16 to the zero power okay so then the next digit is 3 so 3 times 16 to the

And then the next thing is going to be F times 16 to the second power.

And just as a reminder here, I’m starting with zero with the smallest digit.

And I’m just working my way up in steps of one.

So it’s zero power or raised to zero and raised to one and raised to two and just so forth all the way to the left.

That number will just keep increasing by one.

The exponent will increase by one.

times 16 to the third power do it again um one times 16 to the fourth power do it again

um d times 16 to the fourth power oh what did i do did i erase something

0, 1, 2, 3, 4, 5.

Oh, that was supposed to be a 5.

Okay, maybe it’s good that I thought I made a mistake

because that drew my attention to the bad exponent.

Okay, so after the D is a B.

B times 16 to the 6th power.

And then one more.

We’ll say 6 times 16 to the 7th power.

And then another one.

A times 16 to the, whoops, to the eighth power.

And another one.

One times 16 to the ninth power.

Ninth power.

Okay.

So just double check your work real fast.

You know, because I make typos all the time and I get things wrong all the time.

So just double check.

Zero, one, two, three, four, five, six, seven, eight, nine.

It’s sequential.

Double check the digits.

6 b d 1 3 f 3 e okay so i got that right i’m not going to erase my work because if i end up screwing

up the next part oh man is it going to be a hassle to correct so i’m just going to copy paste it here

and then i’m going to start translating the letters to numbers anytime you see a number here like one

time something it’s just one but every time you see a letter you have to translate that into

in decimal. Remember in hex, we’ll say, what can I do?

I can say A, B, C, D, E, F.

And I can say that the A is worth 10.

The B is worth 11.

The C is worth 12.

And the D is worth 13.

The E is worth 14 and the F is worth 15.

Well, maybe I should do the other numbers too.

five, six, seven, eight, nine,

just so we have a visual reminder

of like what we’re even looking at.

And I won’t write down what the digits are worth

because they’re worth themselves, right?

So like zero through nine, it’s just worth zero through nine.

So now that we have this little translation table up here,

anytime we see a letter,

we can just translate it very quickly to the decimal value.

So A is worth 10, we’ll put a 10 there.

Maybe I’ll add some spacing so that this continues to line up.

I see a B here, so the B is gonna be worth 11,

11 add another space so it lines up i’m running out of room but i’ll try the d is worth 13 add

another space so it lines up and then the f is worth 15 add another space so it lines up the e

is worth 14 so i’ll add another space so it lines up okay let me just double check my work here a b d

So now I’ve got like a big formula that I wrote out.

I can literally now, I mean, you can do this in your head if you’re like a crazy genius,

but I’m just going to paste this into a calculator and hit enter.

And this is the number that we had originally in hex.

Maybe I’ll put commas here to make things more fun.

I don’t know.

You don’t really need to do that, but I’m going to.

So for me, it’s easier to read.

this is uh like 113 trillion 478 no wait that’s a million and that’s a bill okay so 113 mil a

billion 478 million 25 022. let me punch up my personal calculator here to make sure that i’m

getting this right i’m not going to show this on the screen because i’ve just got this up

on my host machine bet you didn’t know i’m inside of vm right now surprised you didn’t know that

decimal and the number is supposed to be 113478025022 okay so we did this right we now know how

to convert from hexadecimal to decimal and it’s pretty awesome right okay let’s do another number

one that is not quite as hard let’s see how many digits do we have here one two three i think we

5, 6, 7, 8, 9, 10.

Yeah, okay, we had 10.

Let’s do a five-digit hex number.

Okay, maybe I’ll copy…

I’ll copy just this table at the top

since you don’t need it anymore,

but I’m going to need it to do my calculations.

So we’ll do 1, 2, 3, 4, 5,

and I’ll just start randomly changing

some of these numbers.

Like an 8 over here, and how about like a 2?

So I’ve got five numbers.

This is OX.

I’m going to say this is a hexadecimal number.

Kind of ambiguous if we tell the reader this is a hex number,

but then we put OX.

Kind of don’t really need to tell them that it’s hex

because OX tells you it’s hex.

It’s not even part of the value.

So let’s get on with it.

I’ll start by just doing 8 times 16 to the something power,

which is going to be 0 for that first position.

the power as we go to the left so it’s going to be 1 times 16 to the first power and then it’s

going to be f times 16 to the second power and then it’s going to be 2 times 16 to the third

power oh no my thoughts are wandering i think i’m getting bored of recording this video i’m starting

to the fourth power but honestly why couldn’t they end up together so and

then I think one two three four five okay so that’s five digits a to f one

eight a to f one eight all right zero one two three four just to make sure

that I got my exponents right copy paste it so I don’t have to repeat my work if

I get something wrong I’m gonna translate the letters into numbers so a

becomes 10 f becomes 15 and the other numbers are fine as is I can just copy

fine as is I can just copy paste this whole thing stick it into a calculator and now I know that

this number is actually 667 416 with a little comma in there don’t put commas if you are taking an

exam somewhere if you’re watching my video to help with your exam because most most likely the exam

that you’re taking will not accept a comma it’s not been pre-programmed for a comma I don’t know

If you start typing numbers and a comma just shows up, then it probably was programmed for a comma.

But don’t assume it might be a string match and not a numeric match.

So be careful out there.

Be careful.

So 667-416.

Let me punch this into my personal calculator just to make sure I got this right and I don’t have to issue an errata.

667-416.

All right.

We’ve done it.

We know how to convert hexadecimal numbers into decimal numbers.

Thank you so much for watching this video. I hope you enjoyed it and had a little bit of fun and

learned a little bit of stuff. I’ll see you in the next video. Hey everybody, thanks for watching

this video again from the bottom of my heart. I really appreciate it. I do hope you did learn

something and have some fun. If you could do me a please, a small little favor, could you please

subscribe and follow this channel or these videos or whatever it is you do on the current social

It would really mean the world to me and it’ll help make more videos and grow this community.

So we’ll be able to do more videos, longer videos, better videos, or just I’ll be able to keep making videos in general.

So please do me a kindness and subscribe.

You know, sometimes I’m sleeping in the middle of the night and I just wake up because I know somebody subscribed or followed.

It just wakes me up and I get filled with joy.

That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could troll me if you want to just wake me up in the middle of the night.

Just subscribe.

just wake me up in the middle of the night just subscribe and then I’ll just

wake up I promise that’s what will happen also if you look at the middle of

the screen right now you should see a QR code which you can scan in order to go

to the website which I think is also named somewhere at the bottom of this

video and it’ll take you to my main website where you can just kind of like

see all the videos I published and the services and tutorials and things that I

for clarifications or errata or just future videos that you want to see please leave a comment or if

you just want to say hey what’s up what’s going on you know just send me a comment whatever I also

wake up for those in the middle of the night I get I wake up in a cold sweat and I’m like

it would really it really mean the world to me I would really appreciate it so again thank you so

much for watching this video and enjoy the cool music as as I fade into the darkness which is

the darkness which is coming for us all.

Thank you.

The post Hex to Decimal Made Easy: Fun & Simple Conversion Guide! appeared first on NeuralLantern.com.