In this hands-on tutorial, we dive into bit manipulation in x86-64 assembly using Yasm on Ubuntu. We cover the basics of logical operations like AND, OR, XOR, and NOT, then move into shifting (logical vs arithmetic), rotating bits, and why signed vs unsigned matters for shifts.

I explain each concept on paper first, then show real code examples running in GDB to prove how the bits change. We look at patterns in registers, see what happens with negative numbers in two’s complement, and even touch on how shifts can multiply or divide by powers of 2.

Perfect if you’re learning low-level programming, reverse engineering, or just curious about how bits work under the hood. No prior assembly knowledge needed, but it’ll help if you’ve seen my other videos.

Like and subscribe for more assembly tutorials!

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, we’re going to talk all about manipulating bits in x86-64 Yasm assembly within

Ubuntu.

But if you’re not using Yasm or you’re not on Ubuntu, this video is probably going to

be pretty useful to you anyway, because I’m going to talk about the basic concept of manipulating

bits in various ways.

We’re going to talk about some basic logical operators like ANDing, ORing, XORing, and

XORing, and then we’re going to talk about shifting the bits to the left and the right,

and then we’re going to talk about the difference between shifting without any respect for whether

the number inside of the bits is an actual integer, or whether we just consider them

to just be bits by themselves, or whether we’re actually respecting the bits as numbers,

and also we’re going to look at the rotation instruction.

So first I’m going to explain this, I’m going to write it down in a pad, and then I’m going

show you a program that actually does it just so we can prove that it all works.

Okay, so for starters, let me open up a little notepad here.

What the heck am I even talking about? Let me write this down because I forgot this on my

first take I spent like five minutes, blew right past the explanation of and and or and xor because

I forgot that that was supposed to be part of this video. We’re going to look at and or and xor

at least for now and then we’re going to look at shifting and then we’re going to look at rotating.

at rotating. Okay so first off what is anding? I’ve explained that in another video but long

story short and just requires that two bits that you’re comparing against each other are both a one

in order to receive a one and so any other pair like a zero versus a one or one versus a zero or

two zeros are just going to be a zero. So and means both bits that you’re comparing have to be a one

The OR is pretty easy.

If either of the bits is a 1, then the result is going to be 1.

So if I say 1 versus 1, the result is going to be 1.

If I say 0 versus 1, the result is going to be a 1.

Or if I say 1 versus 0, the result is going to be a 1.

In the only case where you end up with a 0, it’s just going to be 0 versus 0 results in a 0.

To upgrade to exclusive OR, basically exactly 1 bit needs to be a 1.

bit needs to be a one and if two or zero are a one then the result is a zero which means here when

we have the two ones at the top the answer is going to be a zero these are the two stay the

same and this one stays the same so that’s xor again i have another video where i explain this

a little bit better but i’m just doing like a quick overview shifting is pretty interesting

because let me do a pattern let’s say zero one one zero suppose we just have four bits

to the left or to the right. So imagine left, if I shift them to the left, then what I’m really

doing is I’m just taking off that zero on the end and padding on the right with a zero. And then if

I’m shifting to the right, then well, it’s to the right. I’m just going to, you know, take off,

let’s see the zero on the right side and pad with the zero on the left. Be careful though, because

or logical shifting. I haven’t actually shifted with respect to the original number. Think

about this. That number right there on line three, if we just consider that an unsigned

integer or just bits, then what I just did with the shifting is fine. But what if that

was a two’s complement number that can represent a signed integer? If it’s two’s complement

or if it’s just like a signed integer, then the leftmost bit being a zero tells me that

result of my left shift, there’s a one now in that first position, which tells me that’s

probably a negative number.

We could face a similar problem with shifting to the right.

I mean, we didn’t this time.

It just looks like it actually shifted and the answer is going to end up being right.

But what if we shifted something else right?

Let’s see, what am I going to do here?

One, one, zero, zero.

What if I shifted that number one to the right?

The answer would be zero, you know, one, one, zero, right?

you know 110 right but then that’s wrong because the original number was negative because there’s

a one in the first position but the result is a zero so if i’m not careful about what instructions

i’m using and how to respect whether the number i’m shifting is actually considered an integer

assigned integer or if it’s just bits if i don’t respect that then i could end up ruining the

number so keep that in mind we’re going to do several examples of that i’m not going to show

shift by hand I’m just going to show you what the instructions in the assembler

will do so then the other thing that we should talk about is rotating so imagine

that I rotate this number one to the right well nothing really happens

visually but what you’re supposed to do if we rotate to the right you take the

number on the very right side and you just pop it onto the front so it sort of

it doesn’t fall off and get replaced by a zero or get replaced by a one depending

moves to the other side so if I shift this again maybe let’s shift it one more

time to the right I’m gonna take that one and pop it off the right side and

put it on the very front so see do you see how there it’s kind of rotating I do

this one more time actually let me copy paste this I’ll take that number on the

right side pop it off put it back on the front then if I do it again take that

zero pop it off put it back on the front notice how it eventually gets back to

the original pattern and I would have to rotate you know exactly four times to

to get that to happen same same thing applies for rotating to the left i’m not going to show you

because uh it’s it’s the same thing as rotating to the right just in a different direction

one thing that i forgot to say a moment ago when i was talking about shifting is uh think about this

if we shift to the right pretend that uh we don’t really care that much let’s let me put some extra

zeros here so that we don’t have to carry too much we don’t have to care too much about what’s

happening with positive or negative. If you know how to convert to binary, which I’ve explained in

other videos, then you’ll know this number is, let’s see, there’s a one and a two, and then these

positions are four and eight. So this should be a 12, right? If I shift this to the right,

I should be dividing this by two because the base of binary is two. So every time you kind of like

move to the left in terms of what digit you’re looking at, you’re increasing the power of that

every time you move to the right you’re decreasing the power of the digit by two

so that means if I shift the entire thing to the right I should be dividing the whole thing by two

right not just one bit so if I just take a zero off of there and put it on there I’ve now shifted

all the bits shifted all the bits one to the right I should end up with the six let’s just

compute what it is there’s a one there and there’s a two there and there’s a four there what’s four

plus two that’s six so this is actually six in binary or the original number divided by two

because we shifted to the right on the other hand if I take this number one more time and

just kind of shift it to the left I should multiply it by two so that means I should

expect to see a 24 let me just remove one of those zeros and put it on the right side there

this is not a rotation I’m just kind of like filling in zeros I’m keeping it simple with

the shifted number this is a 1, a 2, and a 4 again if you don’t know how to convert

from binary to decimal or back see my other videos so then we basically have

an 8 here and a 16 what’s 8 plus 16 that’s 24 24 is twice of 12 so we have

multiplied by 2 so you could multiply by 4 by shifting twice multiply by 8 by

shifting 3 times you know whatever you want to do but shifting is is like a

is like a shortcut besides just to move the bits it’s also a shortcut to multiply and divide by two

okay so that’s the basic idea let me start working on a little program here for you before I continue

I just want you to know that my program it’s got stuff in it already we’ve got a make file here

if I uh I edit the make file I just have a make file set up to build the program so again this

is specific to just you know bits we’re not going to talk about make files see my other videos if

you want to know how to make your own make file same thing for this gdb.txt file I’ve just put

commands that I’m going to send to gdb my debugger of choice this is not a gdb video I haven’t

actually made my gdb video yet so look out for that in this in the somewhat near future

so we’re just going to focus on the actual program for now anyway so I’ve got a solution

Anyway, so I’ve got a solution already set up here.

Let me start copy pasting some stuff in there.

Going to copy paste my data section.

So first off,

my sample program is just gonna have codes for writing,

you know, with the system call

and exiting with the system call.

And then I’m gonna output to standard output

and I’m gonna do a zero return code.

If you don’t know that,

see my other videos that I’ve already put out.

I’m gonna make a sample string where I just say,

I just say hello my name is Gibson Montgomery Gibson that’s not my name but I love those names

I’m just going to say hello basically when the program starts then I have some bit strings here

that will help me with the you know help me demonstrate some of the bitwise operations

the ending and the oring and the shifting and whatever and then I’m going to put a negative

number here as a variable just to prove to you that sometimes the bitwise or logical shifting

break a number if the number is supposed to actually be assigned integer and and use that

as evidence for why you should use arithmetic shifting so now I’m going to start my program

here let’s see my entry point should start at line 30 I got to be super careful about this

because if I don’t know 26 if I don’t then all of my debug statements are going to have to be

it lined up correctly so i’m basically just going to print the hello message and then maybe you know

what at the very end i’m going to exit from the system with a system call so basically if we run

this program again system calls and everything like that are not part of this video see my other

videos but uh if this works we should see just like a simple message okay so that’s it my name

Conmary Gibson. Okay.

So then the next thing that I’m going to do is I’m going to show you a bitwise

and operation. So I’m going to copy paste that should start on line 42.

And if I get this wrong, the debugging is going to be awful.

I was trying to make this a pure assembly program without a bunch of extra work.

I guess I could have linked GCC so I could just print results to the terminal,

but whatever too late now. So it starts on 42.

and ends on 51 okay so I think that’s good so the instruction for ending doing

a logical and between two registers which are full of bits and then what

will happen is every bit gets anded against its own course or I guess the

corresponding bit in the other other register is just and so what I’m doing

first is I’m gonna set up the registers so I’m gonna move the a sequence which

sequence, which if you look up is just, you know, I put a bunch of bits. So like in hex,

I like to type hex more than binary when I’m just kind of putting stuff in there.

So, you know, each F is basically four ones. So it’s going to be like, I guess, 16 ones,

and then a bunch of zeros, and then, you know, a few ones, and then some zeros and ones.

So I’m just making a little pattern for bits A. Don’t think that they mean anything right now.

And I’m going to make a different pattern with bits B. And when we look into the debugger,

And when we look into the debugger, we should see the before and after patterns so we can kind of see what the AND instruction did.

So I’m going to move bits A and bits B into R10 and R11.

Then I’m going to move, so these are going to be like the original bits that we can inspect later.

this AND instruction against R11 which is the B pattern. So I’m basically taking the A pattern

and I’m ANDing it against the B pattern but I’m also loading up the registers so we can see

the A pattern then the B pattern and then the result of ANDing them together.

Finally on line 50 here I’m using a NOPE which is just a non-operation so that I can easily

break the debugger so we can sort of inspect the program and see what’s going on inside of there.

program and see what’s going on inside of there. You know what, let me, uh, let me open this up

again here so that I can control where I’m breaking. So 48 is where the nope is. That’s

totally wrong. I’ve already ruined my program somehow. It’s going to be 50, I guess. All right,

50. And what I’m doing inside of this, and again, this is not a GDB video. I’m just saying,

let’s break at line 50 so I can kind of poke around. And I’m going to comment all these

And I’m going to comment all these things out for now.

That’s going to happen at the very end.

It’s going to be majestic.

How many different things we can look at.

So I’m telling GDB not to execute any of these instructions, except for the, uh,

the break point instructions.

So we can just break on line 50.

Okay.

Hopefully this works.

I’m going to now use make debug, which under the hood is just going to be compiling and

then telling GDB to launch with the name of my program inside of it.

And then to execute those things.

and then to execute those things.

So it hits breakpoint number 50.

There’s a bunch of crap that gets printed.

And I can now inspect my registers.

I’m going to go info R for just info registers.

And let’s see.

So we had R10, 11, and 12.

So if we look at the terminal, you can see that R10, the hex version,

has the original pattern of the A sequence,

and then R11 has the original pattern of the B sequence.

original pattern of the b sequence if we do a logical and and put the result into r12 then

you should see let me just double check that that’s definitely r12 yeah then you should see

the result of ending all of the f’s together remember that an f is just four ones so i’m kind

of simplifying it a little bit you could make yours more complicated with lots of randomness

in your ones and zeros just to prove it to yourself but notice how r12 only has an f

So like FF means F, F0 means 0, F0 means 0, you know, and so forth.

0F means 0.

So only where you see two Fs will you see an F in the final target pattern.

So that’s a logical AND, and that’s how you do it in Yasm Assembly.

You just load up a register with some bits, R12.

We loaded them up with the first pattern.

And then we take the second pattern and say that’s what I want to AND it against.

that’s what I want to end it against. And you can have that in a register or I think an immediate

or a memory location. So we’re just ending these registers together. And you know that they’re

loaded up with patterns A and B. So nothing too hard at this point. Let’s do a, let’s look at

bitwise or this should start on line 52 or I’m screwing myself. 52. Okay. 52. So same thing,

up R10 and R11 with the bit patterns and then we’re going to move the first bit pattern

into R12 so that we can or it against the second pattern and so basically R10 and 11

will have the original bit patterns R12 will have the result of oring them.

Then we’ll do a nope on line 60 so I want to break here on line 60.

Yep I ruined all my line numbers. What did I do wrong? I think I just have it offset by 2 now

two now for some reason so if we just kind of run the program now in the debugger again i’m going to

quit and then yes if we clear and make debug probably clear was unnecessary we’re broken at

line 60 if i say info registers the registers in question are oh shoot um 10 11 and 12 right so

we look at 10 and 11 they have the same pattern as before and 12 has a lot more f’s because if

has a lot more F’s because if either of the patterns had an F,

then the resulting pattern would have an F.

So this is a logical OR.

Same idea as AND in terms of the way you format the instruction and the OPS,

but it ORs instead of ANDs.

Okay, no problem.

Let’s move on.

Next thing I want to show you is the XOR, which is pretty cool.

By the way, so far we’re just operating on bits.

We don’t consider these bits to actually be numbers.

maybe they are but we should probably be careful about that anyway so I’m going to say let’s check

out our bitwise xor which is exclusive or which means exactly one bit in any pair needs to be a

one for the resulting bit to be a one and of course per usual all bits will be checked against each

other in the pair of of bit patterns it’ll be one bit at a time from each pattern that gets checked

Okay, so it starts on 62 and then we got a nope there.

Okay.

So same thing that we did before.

We’re just loading up two registers with the bit patterns and then R12 is going to be the

result of exclusive oring or X oring the two bit patterns.

So that means we’re going to break on line 70.

Now, let me just get rid of my other break point, change that 68 to a 70.

And now I should quit.

bug we’re at 70 good info registers so I think we said it was 10 and 11 had the original bit patterns

and notice the resulting bit pattern it only has an f in a position where there was exactly

one f between the two input patterns so

wait did I just do something wrong here what did I just do wrong

hang on a second I’m seeing something bad x or r12 am I looking at r12

Yeah.

R10 and 11.

Did I just do something wrong?

10 and 11 and then we load 10 up into 12 and then we XOR it by 11 and then it stores it

in 12.

Something’s a little fishy here.

Exactly one.

XOR.

I don’t like that.

Oh, I understand now.

Okay.

So that was a little scary.

This has shifted because the printout is not great.

Because the printout is not great. See how there’s like a blank space here?

That threw me off. So you have to imagine that all of the bit patterns are kind of shifted.

Maybe I should just copy paste this.

I was worried that I suddenly didn’t know how to do an XOR in assembly.

So let me get rid of these integers here.

Notice how there’s just a blank space that shifted everything and threw it off in terms of the display.

So I’m going to do this.

And what should really happen now is that there should be a zero here.

A zero at the front.

a zero at the front now everything would make more sense sometimes the display likes to just

kind of truncate things and just assume that everything will be read correctly but it wasn’t

so notice uh in the first position both of the uh both the input patterns are are an f so the

output pattern will be a zero you can imagine under the hood there was a bunch of ones and

then a bunch of ones and that resulted in a bunch of zeros uh here we’ve got like an f and a zero so

the result is going to be an f and then f and a zero and after zero zero and an f is an f

f um and then where you see zeros that means uh there was not exactly one uh one in each bit

position so for the let’s say the first one that’s a bunch of zeros for both input patterns so that’s

why there’s a zero there then for the next two each of them had all ones or just the two f’s

uh so that’s why x or says it’s a zero and so forth right so like at the end two f’s making

Okay, that was a little scary.

I’m glad I figured that out quickly instead of taking a million years.

Okay.

So now let’s do another example.

We’re done with XOR.

Now let’s look at bitwise knot.

I forgot to explain knot.

I’m not going to redo this video.

But let me just say that a knot is just inverting the bit.

So if we have a zero, it becomes a one.

And if we have a one, it becomes a zero.

If you knot against a register that has lots of bits or a memory location that has lots

of bits, you can do that and just every single bit in the sequence will just be flipped from

a zero to a one or vice versa.

So let’s see, we just did bitwise XOR.

Now we’re going to do a knot starting on line 72, I guess.

And then we’re going to do another nope there.

Okay.

All right.

So now let’s get rid of the break point at the line 70 and put it at line 78 instead.

78.

Oh man, this video is going to take forever.

Okay.

So now let’s check out bitwise knot.

We’re going to have R10.

Oh, I guess I should improve this because what I’m doing is I’m moving everything into

everything into R10 and then I’m just nodding R10 so we can’t really compare R10 against itself.

That’s not fun. Let me instead move R10 into R11 so that I can nod R11 so that we can

see two different registers at least. Okay, so let me just update my solution real fast.

move r11 r10 okay so now it stops at 75 and that one stops at 75 okay cool

now we got our breakpoint should be at line 79 not 78 now we’re ready to run it and see what the

does clear and make debug info registers so we should have r10 r11 again the formatting is a

so I’m just going to copy paste it up here. I’m going to do this, get rid of the numbers,

pad on the left for the missing zeros, and then now you can see clearly that all of the

F’s were flipped to zero. Again, that means, you know, each F had four ones inside of it,

so all those ones were flipped to a zero, so that’s why it’s a zero. Okay, so nodding, pretty easy,

this and show the next example which was gonna be let’s see seven let’s check out bitwise rotation

i’m going to copy paste all the way up to that nope there should start on line 81

i paused before i took a drink of water hopefully i reminded myself later to edit the drink of water

out i don’t know maybe you’ll be wondering why my mustache is wet right now if i did not edit it out

I did not edit it out.

Okay, so let’s check out bitwise rotation.

So I’m gonna set up R10 and 11 and 12 and 13 and 14,

all with the A pattern.

And then I’m gonna start rotating things.

So first I’m gonna rotate to the left R11 and then R12.

I’m gonna rotate by one position on R11

and then two positions on R12.

And then I’m going to rotate

rotate by one position for R13 and then two positions for R14 so we should see

some interesting patterns. The NOPE is now on line 94 so I’m gonna break there

instead whoops so I’m gonna change that and I’m now off by three it’s getting

precarious and then I’m gonna uncomment all of my little print statements to

show you the value of the registers after I rotate it so we should see like

printed in the terminal just to prove to you what’s going to happen okay so man I got to

remember what’s happening now first thing that I did was I printed r10 to show you one type of

rotation and then I printed r10 again to show you another type of rotation so we should see the

original and then the two rotated values and then the original again and then the other two rotated

values so here’s the original we’re printing it in binary with the special print command in gdb

in GDB, which is just like P slash T and then the register. So this is the original pattern

right here. And if you just kind of squint at it for a while, you can realize that the dollar

sign two pattern has been, uh, shifted once to the left. Actually, let me just make sure that

I’m doing a shift and not a rotate. I’m accidentally saying the word, uh, rotate, I think. And, uh,

that’s, oh no, no, it is rotate. Yeah. We’re going to shift later, I guess.

I guess. Okay, so we are definitely rotating. So we should see some wrap around. I guess I used

bad bit patterns for the wrap around. But just imagine that, you know, in this pattern right here,

this one, if we’re rotating to the left, this one fell off and it got placed on the right side of

of the next pattern it’s going to be the same thing basically so but this is rotation so we

wouldn’t be reusing the bits that fell off but anyway you can see that if I rotated to the left

by one position that whole thing is is kind of shifted to the left I shouldn’t use the word shift

and then for the second pattern we did a rotation by two positions so all the bits are just kind of

moved to the left compared to the very first pattern okay so no problem then the next thing

that we’re looking at is just you know rotating to the right and you can tell that everything is

offset by one here and it’s offset by two here so rotating to the left by one position by two

positions rotating to the right by one position or by two positions that’s rotation in a nutshell

okay so then the next thing that we’re going to do we’re on 94 now

um let’s see logical shifting nope nope nope I’m gonna grab some code that will shift both

logically and arithmetically so we can kind of see the difference

okay so show maybe I should change this to show some some shifting

because uh if I just say it’s logical then yeah sure uh the shift function uh the shift

those are logical shifts but then down here when it’s a sal and sar those are arithmetic shifts

I don’t know maybe maybe I can do that maybe I can just

duplicate the comment maybe to make it more more intuitive so show arithmetic shifts

Okay, I think that looks pretty good. Let me paste that into 105 on my solution so I don’t get out of sync here.

So what’s going to happen here? We’re basically going to load up R10 with a negative number.

I’ve chosen the number negative 12 because I kind of feel like it at least shows you a little bit for dividing and stuff like that.

So we’re loading up R10 with a negative number, and then R11 is going to get R10, but then we’re going to shift it left by two positions.

positions so that should be multiplying it by four but this is well a bitwise

shifting so it it’s not going to necessarily respect the fact that the

number is in twos complement so this is not a good idea if you consider r tend

to be a number because sometimes the result might be right and sometimes the

result might be wrong here it says math won’t work in my comment but sometimes

it will accidentally work but you still want to consider it to be non-working

It’s only good for bit shifting.

Then we’re going to put R12, we’re going to give it the same value as R10 and then we’re

just going to shift it to the right by two positions.

This will definitely break because when you shift to the right, the sine bit is going

to get padded with a zero rather than what the actual sine bit was originally.

So that will almost certainly break it almost every time.

Then we’re going to use arithmetic shifts which just respect the fact that the original

number is two’s complement.

two’s complement so you know like we have this negative 12 number it’s going to end up being

bits but the uh the shl and the shr instructions are not going to respect the fact that it’s

negative 12 they’re just going to consider them to be bits but the sal shifting to the left

arithmetically and the sar shifting to the right arithmetically are going to respect that respect

the fact that it’s two’s complement so let’s see we’ve got all this stuff and then we’ve got a

We’ve got all this stuff and then we’ve got a non-operation here.

You know, again, like per usual, when we’re shifting, when we’re rotating, when we’re

oaring, anding, whatever, it’s just the instruction name followed by both the source and the

destination operand.

And then the second operand is only going to be source.

So if we have a shifting left R11, then the result is going to be stored in R11, but it’s

going to take as the source R11 and shift it to the left by two positions.

to the left by two positions and so forth.

Okay.

So we have all of that.

We’re going to nope on line one of what is it?

One, one 14.

So that means I’m going to stop breaking on 94 and I’m going to break on one 14.

I thought it was four lines off and now I’m only two lines off.

I think I just did something else wrong here between my source.

Let’s see.

Is the nope on one 14 up there?

Yeah, it is.

Okay.

Guess I didn’t do that much wrong.

Okay.

Okay, so let’s run this, but this code up here was just going to print bit patterns

related to our rotations.

I don’t really want that anymore.

So I’m going to uncomment all of these other prints that relate to our shifts.

And this is going to be a nightmare to read and interpret, but I’m going to try.

I really should have written a more complicated program that can just print them in the terminal

so I don’t have to like read the debugger.

Whatever, it’s brain exercise.

size. And I think this actually is the end of the program. 119 is the last line. Yeah. Okay.

So we just need to run this and see what happens. So really we’re interested in these, uh, you know,

shifting to the left twice, shifting to the right twice bit wise, and then shifting to the left

twice, arithmetically shifting to the right twice, arithmetically. Okay. So we’ll go back to the

terminal here and quit. And then I’m going to do make debug. And now there’s a bunch of junk.

here’s the original number and then we’re gonna bitwise shift left binary

notice how it just sort of you know it shifted everything to the left and you

know we’re not using we’re not printing hex anymore because I want you to see

the binary and then you know like the patterns are just shifted to to the left

like see here’s the first one if we’re looking at the right side and then here

is the first one if we’re looking at the right side for the shifted version

A similar deal for shift right except we lost a couple of numbers there because of the display

so I’m going to copy paste both of these real fast.

Per usual we lost numbers due to the display so I’m going to say notice how we have two

numbers missing here if I added zeros on the right side that’s going to change the actual

value so I’m going to have to add them to the left and now we can clearly see that the

shifted four positions I think to the left wait did I do that where did I where did I even just

copy paste from original shift left and shift right okay so shift right is what it’s supposed

to be doing let me just double check here shift right is printing r12 and what does r12 have it

shifting right by two. Okay.

Oh, I’m supposed to compare it to the very first one.

Let me just double check that I have this correct now.

Why is it

shifting to the right? Oh gosh, I think I just lost track of myself. Let me just,

give me a second here. Or 14.

I’m forgetting where I copy and paste. Okay. Bitwise shift right is

bitwise shift right is R12, not R14. Oh gosh. Did I do it wrong? Were you cringing at home?

Maybe this will work. And the two, that’s kind of the same thing that I did before. No, no,

it’s different. Okay. So I had it wrong before. Now I finally have it right. So you can see that

So you can see that the bit pattern is shifted twice to the right and then on the left two zeros show up which would have destroyed a number.

Okay.

So we shift it to the right and now we’re ready to look at arithmetic shift to the left and right.

And let’s see do we have enough bits to actually print everything?

This one should look like it’s shifted to the right just because of the way it prints.

So that means this one is totally lined up.

Okay so let me grab the original pattern here.

grab the original pattern here so this is the original pattern and then if I go shift left

in binary I’ll just put an L here and then I’ll put shift right in binary

there we have enough bits I think in both cases so we don’t have to pad

so now if we look at the original pattern and then we shift left arithmetically twice

twice notice how it does kind of look like it survived right like this one moved over to the

left twice because the sine bits are just kind of falling off but there’s enough of them that it’s

not going to change the sine bit thank you two’s complement but when we shift to the right

arithmetically normally we would have padded on the left with zeros remember we had zeros there

on the left before but now that we’re respecting the arithmetic uh the the padding is correct now

is correct now for two’s complement so that’s why there are ones there instead of zeros

and then if you kind of look at it it’s like well we shifted twice to the right let me get

rid of the left because we already understand that now it seems to be that the pattern is uh

every bit is shifted over to the right the correct number of times the zeros dropped off the side

and um the sine bits were padded on the left so everything seems to be correct and then just to

to kind of prove to you that what we’re seeing is real, I just have the same things printed

all over again from scratch in decimal. So originally we had our R10 as negative 12.

And then if we do a bitwise shift to the left, it multiplies it by four. And so we’re accidentally

correct here. Remember, this is a bitwise shift, so it doesn’t respect two’s complement. So just,

we happen to have a starting number that would end up looking correct after we shifted it to the left.

And then when we do a bitwise shift to the right, again, this could be disaster because we’re not

respecting two’s complement or the sine bit. And that’s exactly what happened. You know, definitely

if we’re shifting to the right, that should be 12 divided by four equals three or negative three.

But instead we get this gigantic huge number because the sine bit got killed with the zeros

killed with the zeros that were padded on the left. And then we finally try to shift left

arithmetically. We end up still with negative 48, which is the correct number. If we’re going to

shift left twice, that’s multiplying 12 by 4 and that’s 48 or negative 48. And then when we shift

to the right, that should divide it by 2 twice because we’re shifting to the right by two

positions. So that should be 12 divided by 4, which is negative 3 or sorry, negative 12 divided

which is negative three so everything seems to be working except for a couple of moments of

stumbling on my part which i hope you laughed at um and i think this is the end of the program so

now hopefully you’re an expert in uh ending oring x oring nodding shifting left and right uh bitwise

rotating. We’ve done it all in this one video. How long did this video take? 40 minutes?

Anyway, thank you so much for watching this video. I hope you learned a little bit of stuff

and you had a little bit of fun. 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,

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 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.

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 the services and tutorials

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

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 x86-64 Assembly Bit Manipulation: AND, OR, XOR, NOT, Shifts & Rotates Tutorial appeared first on NeuralLantern.com.

Want to conquer negative numbers in binary? This fun, beginner-friendly tutorial breaks down two’s complement with step-by-step examples (-109, -29) and shows how to convert, pad, and subtract in binary. Learn sign bits, carry bits, and avoid common mistakes. Subscribe for more coding tips and tech tutorials that make learning a blast! Scan the QR code for more resources and join our community!

Introduction to Two’s Complement 00:00:00
Signed vs. Unsigned Integers 00:00:28
Sign Bit Explanation 00:01:55
Positive and Negative Representation 00:02:06
Range of Signed Integers 00:02:48
Padding Signed Integers 00:05:36
Converting to Negative (Example: -109) 00:07:00
Binary Addition and Carry Bits 00:10:16
Correcting Conversion Mistakes 00:16:38
Converting Negative 29 00:13:32
Subtraction Using Two’s Complement 00:18:21
Adding Binary Numbers (109 – 29) 00:20:41
Verifying Results 00:23:56
Conclusion and Call to Action 00:25:40

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 there! Let’s talk about representing negative numbers in binary.

We’re going to use a system called 2’s complement which is going to allow us to represent signed integers,

which means there will be a positive sign or a negative sign on the integer

and we’ll still be able to do it in pure binary.

So let me talk a little bit about what I mean first here.

signed and unsigned okay so if i just type the number 14 by itself that is uh that’s an unsigned

integer we don’t really know if it’s positive or negative like do we know that it’s negative 14 or

do we know that it’s positive 14 right so the sign is what lets us know if something is positive or

negative okay so if i if i type a number in binary let’s just do a pure binary number one two three

if you know how to convert binary to decimal you probably recognize right away that this is just

the number zero even if we add a couple of bits here that’s just like the number three

and so this is the number three but so far if if you haven’t learned signed integers in twos

complement or in binary then you don’t really know that there’s a sign you just kind of assume

that the number is positive by default if you’re not using twos complement and you’re just saying

and you’re just saying like well let’s just do a bunch of binary you know digits then yeah it’s a

safe assumption that the the sign is positive but we’ll use two’s complement which starts with the

idea that the highest bit the leftmost bit the bit with the height you know the most power that’s

going to turn into the sign that’s that’s going to turn into the plus or the minus so like you

the sign.

So this means that we have to decide, you know, does a zero mean positive or does it

mean negative or what means what?

So in two’s complement, we’ll say that zero is positive and one is negative.

So you can see right here that we’re still actually representing the number three, but

it’s positive three for sure because this sign bit right here is zero.

That’s positive.

Once we decide to represent two’s complement, then we can say that for sure.

On the other hand, if we put a one here,

then we definitely know that this number is now negative.

However, we don’t actually know that it’s a three

because the numbers don’t work out the same anymore

in two’s complement.

So the positive numbers, they will mostly look the same.

The negative numbers, they’ll look a lot different,

but they’ll still be valid in order,

you know, in terms of us being able to add them together,

subtract them from each other and things like that.

So two’s complement is pretty cool.

Let’s do, let’s see, what else can I tell you?

Oh, one thing to understand is that

One thing to understand is that in an 8-bit unsigned integer in binary, let’s say 1, 2,

3, 4, 5, 6, 7, 8, let’s say unsigned bits, maybe I’ll just put like, maybe just some

like V for value, all the bits are values, that means the range is 0 to 255 with 256

total combinations.

But if we want to use a signed number, then we’ll actually have the signed bit be the first bit,

and all the rest will be value bits.

1, 2, 3, 4, 5, 6, 7.

In this case, the range kind of goes down.

Because if you think about it, every single bit, you know, represents like, you know,

it helps towards the highest possible value that you can represent.

If we’re using the leftmost bit, then for an 8-bit integer, that’s 128.

integer that’s 128 that’s a value of 128 so we lose a lot off of the maximum

integer that we can represent so the range here is I think it’s negative 20

128 to positive 127 just keep in mind you’ll have to trust me in terms of why

is the negative 128 bigger and the positive 127 you know smaller but that’s

just the way it is so that means we only get these value bits here and if you if

that um let’s see if i can do this quickly enough without screwing it up we’ll say 127 minus um

minus negative 128 i guess that’s 255 and then also a zero but uh in terms of positive and

negative the way this is going to work out is the zero will probably show up twice because uh

255 possible combinations with seven bits.

Normally you would have a range from negative, sorry, from zero to positive 255.

And in this case, we’re just, you know, losing our range, but we can represent negative numbers.

Anyway. Okay.

So let’s talk about doing an example real fast. Let’s see.

I’ve got like a little notes to tell me what I should do. Okay.

It’s important to understand that normally when you have, let’s say, let’s say you have

like an 8-bit number and you go 1, 2, 3, 4, 5, 6, 7, 8.

And then you have 2 bits right there and so this is like, you know, positive 3.

If you wanted to copy that number into more bytes, like for example, if you wanted to

take a 2-byte integer and have it copy the value of a 1-byte integer, then it’s pretty

easy.

zeros to the left you’ll say one two three four five six seven eight that would work perfectly

however if you did this with a negative number let’s say that we have a negative number

I’m going to put some of the random patterns so that you don’t think it’s the three let’s see

one two three four five six seven eight that’s eight total so I’m going to make that a one and

then get rid of that so we have like eight negative number if we were going to copy that

integer then we would copy paste it to start but then you’d have to pad with

ones to the left one two three four five six seven eight same negative number

more bits so be very careful about how you pad if you’re padding an unsigned

integer then yeah you’ll always pad zeros to the left no matter what is

happening but if you’re padding a signed integer then you have to pad differently

signed integer you have to pad with whatever the highest bit is so in this case the highest bit was

a zero so we do pad with zeros but then in this case the highest bit was a one so we have to pad

with ones if you don’t do that you’re going to end up with a number that doesn’t actually make

sense okay so now let’s work on actually converting a number to a negative number or representing a

negative number in twos compliment okay so i’m going to write twos compliment here and then uh

Let’s start off with the number negative 109.

Okay, how do we do this?

The first thing is convert it to its positive form.

Take the absolute value. Okay.

So we’re really just, you know, take positive form here,

and that’s just going to be positive 109.

Okay, no problem.

I’ll say start with negative 109, and then we’ll take the positive form 109.

Now we’ll convert it to binary.

Okay, this is not a video that teaches you how to convert to binary, so I’m just going

to try to do this in my head real fast here.

It’s going to be, let’s see, we got 8 bits, we’ll use just 8 bits to store the number,

and because it’s low enough and I don’t want to use that many bits, so it’s odd, so I can

add a 1 there, but maybe for now I should find the highest bit that is less than the

actual number.

So this is the 128 bit right here. So that’s going to be a zero. This is the 64 bits

I’m going to put a one there and I’m just going to say

Mmm, maybe like

This is like maybe not the smartest way to do it. I’ll say 109 minus 64

Because I put a one there and then 45 so now this is 32 that’s less than 45. So I’ll put a one there and

Then it’s going to be minus 40

So it goes from 45 to 13.

So then that was the 32.

Okay, so 128, 64, 32, and then 16.

Is 16 less than 13?

No, it’s not.

So we’ll put a zero here.

And then the next one is going to be just four.

Four is definitely less.

So I’ll put a one bit there.

And then I’ll subtract four.

And then one, two, four.

Oh, wait a minute.

One, two, four, eight.

wait a minute one two four eight sorry that was supposed to be subtracted uh subtracting eight

because that was the eight bit uh then i want to get five so here is the four bit so i put a one

there and then i’ll just put a one here because four plus five is equal to uh i’m sorry four plus

one is equal to five so let’s see um it is let me just double check here one

one let me just double check my conversion real fast it’s going to be

the one bit plus two four plus eight six thirty two plus thirty two plus sixty

four did I get one on nine yeah okay so I guess I did it right so convert to

binary and that’s going to be this the next thing we’ll do is we will invert the

bits I made a little edit jump here because I inverted the bits incorrectly

on the first try which is sad but hey it happens the next thing we’ll do is

but hey it happens the next thing we’ll do is we’ll invert the bits so basically you know we

take this original sequence here and i’ll just turn every single bit uh i’ll flip it i’ll flip

ones to zeros and zeros to ones so i’m going to go one zero zero one zero zero one zero okay so now

we have this number invert the bits then we just have to add one so we’ll add positive one to that

that it’s just going to be a one there at the end.

But sometimes that might not be the case

because what if we already had a one there

and we had to add one to that?

Well, we’d add one to the right side

and it would turn into a zero

and then it would carry a bit to the left.

That would become a zero

and then the carry bit would show up all the way over there.

So I just want you to be aware of the fact that

when you add two binary numbers together,

you have to be careful.

You have to add them the same way you would add decimal numbers.

For each digit’s position,

you have to add the two numbers together and then if they overflow then you just

kind of wrap around to the lowest number again subtracting you know the highest

value or sorry subtracting the base like in decimal if you add 9 and 9 the answer

is 18 but you’re not going to write 18 in that one position you’re going to

subtract the base which is 10 so it’ll actually be 8 and then you’ll carry the

plus nine is equal to eight carry the one right so we’ll do the same thing in binary we’ll say

if we ever get a one plus one when we’re adding the answer will be two but then we subtract the

base which is two so the answer is actually zero carry a one bit keep that in mind i’m just gonna

write it all out for you so you can kind of get a little bit of practice it’s important to to

practice this because it’s easy to get wrong i’m going to put a bunch of dashes up at the top to

and I’m going to say we’re going to add, you know, one number plus another number,

put a little plus symbol over there just to try and make sure we do it the right way.

Okay, so how do we add these?

Well, we’ll just go to the right side.

Zero plus one is one, no carry bit.

One plus zero is one, no carry bit.

Then we got a couple zeros here, no carry bit, of course.

One plus zero is one, no carry bit.

And then a couple zeros and then another one with no carry bit.

Okay, so, you know, we could have done that pretty easily, but

but well now we’re getting a taste for binary addition that might be harder later.

So we’ll just do that for now.

And now this is the two’s complement representation of negative 109.

I’ll say now we have negative 109 is equal to that.

leftmost number the most powerful sorry leftmost bit the most powerful bit is a one remember one

always indicates negative so when you’re looking at it if your leftmost bit turns out to be a zero

then you probably did something wrong or you had an overflow maybe um and again if we were going

to try to you know send this number into a two byte number or an eight byte number or whatever

uh then we would just have to pad with the sign bit so one two three four five six seven eight

help my brain so this was this is the way it would look in a two-byte number this is the way it would

look in a three-byte a four-byte and five six seven how many one two three four five six seven

okay one more this is what it would look like as an eight-byte number or a quad word 64-bit number

yeah okay so now we know how to do negative 109 okay so now let’s do a number that’s a little bit

negative 29. So let’s say convert, or how about represent negative 29 into

2’s complement. Okay. So first we, you know, first get the absolute value.

So just 29. And then we have to invert the, sorry, we have to get that into binary. So

next convert to binary. And I’m going to start with zeros, one, two, three, four, five, six,

1, 2, 3, 4, 5, 6, 7, 8.

For this video, remember, we’re choosing to use one byte integers.

But if you wanted to do a bigger one or you had to do a bigger one,

then just, you know, keep that in mind.

Okay, so 128 is not smaller than 29.

64 is not.

32 is not.

16 is, though.

So I’ll put a 16 bit there.

And I’ll just subtract 16 from 29.

29 minus 16.

Now we’ve got 13 left.

So 64, 32, 16.

six four thirty two sixteen eight okay so now I’m gonna put a one bit there and

I’m gonna subtract 8 from the remainder and then we got a five which is pretty

easy to do eight four and then a one so now we have well zero zero zero one one

one zero one that’s the binary number the positive or unsigned representation

representation. So now we’ll add one. Positive one. And let’s try to do this the right way so

that we can practice carry bits with addition a little bit. Notice how this one is already there

on the right side. So it’s going to, we’re going to have at least one carry bit for sure.

So then I’m going to go doop like that. And then I’m going to say that we have like, you know,

what is the result? Put a positive sign there. And then I’m going to put a bunch of dashes

my carry bits because I can I can forget that pretty easily. So the first thing is we add one

and one. The answer is two, but we can’t put the number two here because it’s binary. Instead we

need to subtract the base which is two. So two minus two is equal to zero, but then we have a

carry bit of one. So I’m going to put a one there. The first carry bit will stay as a dash for this

whole you know exercise because you’re not going to carry on to the first digit. So now we have

what would have been just zero plus zero now we have one plus zero plus zero so

that means this is going to be one and then the carry bit is just going to be

zero because we don’t actually carry anything so then we have zero plus one

plus zero so that’s going to be a one and then zero carry bit and then zero

one zero is just going to be one and then there’s going to be no carry bit

and then zero one zero again a one no carry bit because we didn’t actually

zero zero zero and then I’m just gonna put zeros here okay so now we have

successfully added I blew it totally blew it I always forget steps don’t

forget the steps this is a good lesson I’m gonna leave this in the video

because I want you to see that everybody makes mistakes and you got to practice

practice practice especially before you have to actually do this in real life or

or something like that.

Next, convert to binary.

Before you add one, I’m gonna just remove this.

Oh my gosh.

Next, flip the bits,

which is gonna be 1110010.

Okay.

So now we take this bit flipped number

and we will add one.

So that’s gonna be zero, zero, zero, zero, zero, zero, zero,

one, oh, it’s too easy.

Maybe I got excited and I thought,

excited and I thought, oh, it’s carry bit time.

But even though the last edition that I did was wrong because I forgot to carry

the or flip the bits, you still at least saw a little bit about how to carry the bits.

Right. OK, so it’s just going to be one.

Let me start from the right side.

One one zero zero zero one one one one one one.

Let me just double check here.

One one one zero zero zero.

OK, so I got that.

Now we have.

negative 29 in twos compliment. Again notice if we actually tried to add those numbers up to be

like an unsigned binary number they’re not really going to make sense because this is like 64 plus

32 plus 3. So what would that end up being? Let’s just double check here. 64 plus 32 plus 3, 99.

That’s not actually the number but the number is 29. So keep in mind you can’t just look at this

unless you’re like really, really practiced.

Okay, and again, notice that the number is 1 at the very left,

indicating that it’s a negative number.

Now, let’s look at how to subtract one number from another

using 2’s complement.

Okay, so what I want to do is I want to subtract,

let’s say, 29 from 109.

Okay, so let’s subtract, and I’ll just say 109 minus 29.

109 minus 29.

And how I would do that is basically I’ll start by just taking 109.

Let’s see, convert to binary.

So I’m just going to copy paste that number.

So 109 is this and then 29, take the positive version.

It is just, let’s see, before we flip the bits or anything,

let me make sure that I grab the right one.

Invert the bits, okay.

So positive 29 is this number.

Whoops.

is this number whoops let me put parentheses around that so it’s easy to tell and then I’ll

put a positive sign there like that maybe like that nope nope nope nope how about this okay

so now we have both of these numbers in positive form so now if we added 109 plus 29 that wouldn’t

negative positive 29 that would be what we wanted right because really if you’re subtracting

i’ll say aka

positive 29 plus negative 29 all we really need to do is um invert the 29 and then add the result

to 109 so that means we’ll we’ll turn positive 29 into negative 29 using two’s complement

through the steps again but basically put it there but basically you know that’s negative 29

so say positive 129 is equal to what i just put up here and then negative 29 is equal to

maybe i should do the parentheses again for clarity uh is equal to this okay so you can tell

that positive 29 is pretty pretty different from negative 29 but now we have

29 but now we have both of those numbers so let’s see 0 1 1 0 and then we’re ready to add okay all

we got to do is add them together next add them together maybe I should write the steps up here

negative 29 using twos complement and then next add them together so then I’m

going to copy paste the bits here and it’s going to be this plus this do a

positive plus sign just to remind ourselves that we are actually adding

and then I’m going to put a bunch of placeholders for sign bits up at the

top and now we’ll have a little bit more fun adding numbers together maybe I’ll

drag this down

Oh my god. Oh, there we go. Okay. So I’ll start with the one on the right, the position on the

right. That’s going to be one plus one equals two, but then that’s an overflow. So I’m going to

subtract the base. So it’s going to be zero. And then don’t forget to carry the one. Oh,

cool. More interesting. So we have one plus zero plus one. That’s going to be another two carry

two carry the one so it’s going to be zero and then carry the one again so i’m going to put the

carry bit up there and then again we have one plus one is equal to two so it’s going to be zero

carry the one again zero carry the one and then finally we don’t really have a carry bit

um so we’ll just have like a one and there’s there’s no carry so it’s going to be you know

carry a zero and then we add these two together so it’s going to be a zero carry the one and then

Now we have a three.

Oh, that’s kind of nice.

So this is an interesting edge case kind of.

One plus one plus one is three.

But if we subtract two, the base from it, you know, three minus two, it’s going to be one, not zero.

So it actually is going to be a one and then carry the one on top of that.

Then for here, let me space this over a little bit so that I can illustrate what’s going on a little bit better.

We’re going to have one plus zero plus one.

definitely going to be zero and then carry the one but there’s no bit where that carried one can

can show up on right so that one overflows it falls off the edge if this was a bigger number

then okay we you know if we had more bits to this number then sure we would just keep carrying over

over to the left but remember we said before that when we have a very big number let’s see

bits it’s just ones all the way to the side that will actually help us make sure that if our final

number is actually going to end up being positive that everything kind of like dominoes like carry

the one carry the one carry the one carry the one carry the one all the way until one of the ones

falls off think about it so anyway this one just is gone we don’t really care about it anymore

the result is going to be just only eight bits because that’s the number that we started with

bunch of zeros what is you know the final answer let’s just compute this

real fast to decimal so this is 128 and then 64 so it’s gonna be 64 plus not 32

but 16 so 64 plus 16 that’s gonna be oops 16 that’s gonna be 80 and now we

just have to ask ourselves again as like a final step to double check yourself to

what you’re doing and that you got it right is just punch up 109 minus 29 just to make sure

109 minus 29 whoops what happened here 109 minus

oh i think i stole my subtraction key for the annotator 109 minus 29 is 80

so again you know if you’re if you’re trying to like you know write something down to do some

you know taking an exam or something you definitely want to double check yourself in several ways

As you can tell from this video alone

I got one of these things wrong because I forgot to input the bits as a step before adding one

So you know your final step should be actually trying to add two numbers together or subtract numbers or whatever

You’re doing to make sure that you got the binary correct

So let’s see

Hmm

I guess maybe your first indication that the result was going to be positive would be that

there’s a zero there. And just, you know, as a sanity check, you look at the top and you’re like,

well, I was going to subtract a small number from a larger number. So the result should probably be

positive, right? Like 29 is like way lower than 109. So it should be positive, which means the

final result should have a zero at that leftmost position. Okay, so that’s two’s compliment,

two’s complement how to convert numbers from positive to negative in two’s complement you

know what the sign bit means and all that stuff and how to perform subtraction via two’s complement

i hope you enjoyed this video thank you for watching i hope you learned a little bit of

stuff and had a little bit of fun 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

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 me a kindness and subscribe.

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

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 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 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 Two’s Complement: Convert & Subtract Negative Binary Numbers appeared first on NeuralLantern.com.