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