In this practical x86-64 assembly language tutorial we dive deep into conditional branching using YASM (also works with NASM) on Ubuntu/Linux.

We cover:

• The CMP instruction and how it sets the RFLAGS register
• All major conditional jump instructions (JE, JNE, JL, JLE, JG, JGE, JB, JBE…)
• Important difference between signed (JL/JG) vs unsigned (JB/JA) jumps
• Real code examples showing how to implement if-style decisions
• How to handle the “jump out of range” assembler error
• Visual flow diagrams explaining control flow

Perfect for students learning low-level programming, reverse engineering, operating systems, or anyone who wants to understand how if-statements, comparisons, and decisions are actually implemented at the machine level.

Highly recommended companion resource: Professor Ed Jorgensen’s free x86-64 Assembly Language Programming book (linked in comments).

Enjoy learning assembly!

Intro to Conditional Branching in Assembly 00:00:00
Recommended Book: x86-64 Guide by Ed Jorgensen 00:00:23
Unconditional vs Conditional Jumps 00:01:39
How Conditional Branching Works 00:02:06
The CMP Instruction Explained 00:03:21
Overview of Conditional Jump Instructions 00:04:50
Signed vs Unsigned Jump Instructions 00:06:10
Jump Equal & Jump Not Equal (JE/JNE) 00:07:00
Main Conditional Jumps Summary 00:08:14
Starting the Code Example 00:09:09
Program Structure & Printing Setup 00:10:35
Function Prologue & Getting User Input 00:13:21
First Branch: Is Number Greater Than 0? 00:15:17
Live Demo: Testing Greater Than Zero 00:21:53
Second Branch: Is Number Less Than 10? 00:22:52
Live Demo: Testing Range 0-10 00:26:06
Third Branch: Is Number == 5? 00:26:52
Live Demo: Testing Equal to 5 00:28:00
Jump Out of Range Error & Workaround 00:29:00
Final Summary & Closing 00:32:17
Thanks & Call to Subscribe 00:32:57

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

Hey there. In this video,

we’re going to talk about conditional branching in an assembly program.

We’re going to be looking at YASM x86-64 assembly or AMD 64 assembly

within Ubuntu, but this will probably be a useful video.

If you’re just thinking about how to branch in assembly in general.

So for starters, I’m going to promote one of my favorite books,

as I often do. This is a book that is free and open source. You can get a copy yourself. I did

not write this. The author of this book is a genius. His name is Professor Ed Jorgensen, PhD.

He made this whole book and released it under an open source license. So you can literally just go

to his website and get a copy of this for free. You can use this to make yourself into an assembly

expert. So I highly recommend this to everybody. Anyway, so I’m going to open up this book. I’m

up this book i’m going to assume that maybe you’ll get a copy or you’re just going to follow along

with what i’m doing on the screen but i’m going to open this book and i’m going to go to section 7

which is entitled instruction set overview i’m going to double click it so open out open the

subsections and then i’m going to click on 7.7 control control instructions and then under that

i’m going to click on 7.7.3 conditional control instructions so uh that’s a lot of subsections

So that’s a lot of subsections, isn’t it? I love a book with a ton of subsections. It makes things so much easier to find

If you or someone you know is going to write a book, especially if it’s technical, please use lots and lots of subsections

Anyway, so conditional control instructions in my last video

We talked about the jump instruction where we can just be sitting somewhere in our program and then just jump somewhere else

Anywhere we want based on the label so conditional branching or conditional control instructions

conditional control instructions are kind of the same thing except they will

decide whether or not to actually jump they might fall through to the next

instruction or they might jump away to somewhere else so conditional branching

or conditional jumping it basically kind of goes like this step one you compare

two values to each other they will probably be sitting in registers and then

conditional branching instruction or a conditional jump instruction there’s

lots of synonyms for these but basically in the regular jump instruction that I

just talked about in the last video you just jumped and it was only one thing

that you had to do but in this case we first have to compare two items and then

we’ll issue the jumping instruction because the jumping instruction will

have to decide whether to jump or not based on the result of your comparison

which makes sense right like if you’re going to implement something that’s like

if you know I’ll put like a expr for expression then well the first thing that we have to decide

before we jump either into the block of the if or if we jump into the block of the else is whether

or not that expression is true right so that’s kind of what the compare instruction is doing

sort of in higher level languages like c++ it can get a lot more complicated than that but you know

Okay, so we’re going to do conditional branching instructions.

Let me show you a few of those.

Okay, so for starters, here’s the compare instruction right here on page 126.

I think it’s actually 127 in the PDF, but basically, you know, 126.

We do CMP followed by two operands.

So if we want to compare, I don’t know, let’s say R12 with R13, that’s how you would do it.

just a two operand instruction there’s no results that are going to get stored in one of these

operands both of these operands are just for input the result actually gets stored in a special

register called r flags which we hardly ever use or look at in in the most common assembly

instructions and design patterns we just kind of like let the r flags do whatever it’s going to do

and the compare instruction will fill that up so imagine that you know depending on whether r13 is

is like greater than r12 or less than or they’re equal or something else is going on between the

two of them the compare instruction just fills up all sorts of flags defining the relationship

between those two registers or those two operands r12 and r13 and then after the r flags register

is all set up then the conditional branching instruction will sort of rely on r flags in

order to decide whether or not it’s going to jump or not okay so let’s see there are tons

there are tons of conditional well not tons i guess like half a page worth but there are lots

of conditional branching instructions we can use the first two i want to show you and after this

by the way i’m going to write a sample program just to show you how it is in practice but so the

first one is je which means let’s jump if the two operands were equal so again you know we compare

here we’ll say sets up r flags and then we’ll decide like what we’re going to do are we going

to jump if they’re equal to some label i’ll write some label here so that means uh the je instruction

will look at the r flags register and decide did compare think that r12 and r13 were equal if it

did then we’ll jump if not execution will fall down to the next line so i’ll put a nope instruction

So if they were equal, then we’ll end up jumping to some label.

And if they were not equal, we’ll end up letting execution fall through to the nope on line 10.

And same thing for jump not equal and all these other ones.

But there are actually two different versions of some of these instructions that kind of seem the same.

Like for instance, this one right here, JL, that means jump if the first operand was less than the second operand.

is a jump below that jumps also if the first operand was less than the second operand so

what’s the difference between these two let me get my pen I love excuses to do my little pen now

well I’ve got my pen it’s working oh I erased it okay okay it’s working anyway so notice how jump

less than and jump below are basically doing the same thing but there’s one difference one of them

One of them works on signed operands and one of them works on unsigned operands.

So keep this in mind.

If you’re comparing two signed integers, you want to use this group up here of instructions.

But if you’re using unsigned integers or just bits, then you want to use this group of instructions down here.

And you definitely want to know what kind of data you have that you’re comparing.

Notice though that jump equal and jump not equal, they don’t really care.

not equal they don’t really care if the operands are signed or unsigned that’s because if you want

to check to see if two things are equal you just look at all of their bits and if all of their

bits are the same then you just say they’re equal you don’t even care actually if it’s a signed or

unsigned integer if it’s a float if it’s a whatever you just you just go are all the bits equal or are

at least one of the bits unequal then we’ll say it’s equal or not equal that’s it so keep that in

mind for all of your jump instructions where you’re trying to see if things are equal or not

or not equal you’re going to definitely be using these whether you’re using signed or unsigned

integers or floats or anything else like that but when it comes to actually you know integers that

are signed or unsigned these are the instructions you use for signed and these are the instructions

whoops that you use for what have i done that you’ll use for unsigned i keep confusing the on

off button for the red button is what i’m doing oh okay whatever i guess we’re done anyway

I guess we’re done anyway.

So keep that in mind.

In this video, we’re just going to be using the signed integer instructions

because that’s the example that I have set up.

But just imagine you could very easily translate this to unsigned integers or floats.

Okay, so let’s see.

We’ve got jump less than, we’ve got jump less than or equal to,

then we’ve got jump greater than, and then we’ve got jump greater than or equal to.

And when you combine those with jump equal to or jump not equal to,

jump not equal to that’s pretty much all the comparison that you need and if you want to do

something much much more complex well then you can just you know start stacking logic on top of

logic and and branching on top of branching to do something that’s like this is what i’m talking

like if you want to do this expression and expression or expression and then maybe like a

expression, right? If you want to do something super complicated, like we can do in a higher

level language, you’re just going to have to make a bunch of mini jumps or find another

way to reduce your logic. But in this video, we’re just going to be taking a very simple

comparison. All right. So I think that’s everything that I can show you inside of this book. Let’s

go to the code now. So here’s a little empty code, source code, a page. I’m going to stick

all my code inside of it. Another reminder that if you don’t know how to write assembly

you don’t know how to write assembly at all you should see my other videos because i’m not going

to cover the basics of assembly in this video if you want to learn how to make a make file or compile

or assemble or like do all the basics that i’m not talking about in this video i’ve covered them all

in my other videos up to this point so for now we’re just going to focus only on conditional

branching conditional jumping inside of an assembly module so i’m going to start off by setting up my

and i’m gonna say paste and again you know this is covered in other videos but long story short

i’m just going to be printing out a bunch of strings while this program executes so

i’m going to announce that the branching test is going to begin and then i’m going to ask the user

for some input and then i’m going to based on whatever the user inputs i’m going to just print

out a message that sort of you know understands what the user inputted so if the user inputted

something greater than zero it’s going to output that if they entered something that was less than

10 it’s going to print that if they entered something that was equal to five it’s going to

print that and then it’s going to say we’ve ended the branching tests then i have like a crlf again

all this stuff is explained in other videos but we’re just basically printing so i’m going to

start the text section of my program which is where all the instructions are and i’m going to

a function that I can call on. Again, this video does not cover a bunch of other extra stuff. I’m

just going to show you how to branch. Just trust me when I say that this helps me easily print

numbers and things, or I guess in this particular case, it’ll help me input a number from the user.

But for you, if you’re trying to run this at home, you can just start hard coding numbers just to

make sure that you can branch correctly and then eventually work your way up to a library that can

videos in the distant future. I don’t know years from now. I don’t know.

I might release the library or some other stuff to the casual viewer.

So now here’s our entry point. Again,

I mentioned that there’s going to be other parts of this program that I’m not

showing. So this is a hybrid program where a C++ driver actually will call on

my cool function. So just imagine from somewhere else in the program,

you’re calling on the cool function. How do we know it’s a function?

a label called cool and then it has a return statement at the very end.

That’s pretty much all we need to know right now.

Let me get rid of that load.

I don’t know why I always have the word load in all of my things.

I think I put it in there on an early example

and then I just kept copy pasting to my heart’s content and never stopped.

We mark the function cool as global so that other modules can call on it

like the C++ module that I’m not showing you.

But if you’re writing a pure assembly module,

you don’t really need to mark your functions as global.

if everything’s within the same piece of source code it’s totally fine so then I’m going to make

a function call to a function called branch test so very quickly before I actually add branch test

I’m just going to add another function that we’re not covering in this video called crlf and long

story short all it does is just it prints a new line in the terminal and that’s it like it’s just

it’s a convenience function I like to be able to call crlf and have a new line okay so let’s start

our branch test function so here’s the signature it is just branch test with a

void in front of it I’m gonna put a ret to say that this is a function that we

will return from and I left myself a little note here saying that I’m gonna

use register r12 as the number that the user inputs so that means I’m gonna have

to preserve that because you have to respect the ABI and the ABI says that

The ABI says that R12 is a Kali saved register.

Again, see my other videos if you don’t know what I’m talking about.

But I’m just going to preserve it in a section that I call the prologue, or actually the

book calls the prologue.

I do that now though too.

And, you know, restore it in a section called the epilogue.

So we have prologue and epilogue.

We can have a push-pop pair.

And then in between, we can have, you know, the meat of our function.

Okay, so for the introduction, I’m just going to write a few instructions that just print

out a message.

print out a message. So we’re going to print out that intro message and then call

CRLF to print a new line and then return. So maybe actually at this point we could

probably check to see if this program works by trying to run it.

So let me say clear and make run.

Okay. So now the driver just prints hello. The driver is

elsewhere and we get that welcome message that says begin

branching test and then the driver retains control after that. So

let’s do let’s do a goodbye message real fast so we’ll do our goodbye message

it’s just another string that I’m printing it’s no big deal right now but

if I run the program again you can see that begin branching test and end

branching test okay so far we’re not really doing branching yet the next thing

we need to do is ask for a number so this is how I’m going to do it in my

this is how I’m going to do it in my program. In your program it might be different or you might

have a hard-coded number or something like that. So for now just trust me when I say that I’m going

to print a prompt basically saying could you please enter a number and then the next two lines

are going to be just calling on one of my custom functions that will input a number from the user

so the user can type at the terminal and we will receive their number through REX which is the

return value register for integer return values and we’re going to store it in R12. So that’s why

And we’re going to store it in R12.

So that’s why I had to preserve R12,

because I’m actually going to start,

you know, messing with the value of R12 now.

Okay, so we ask for a number,

and then we sort of don’t do anything after that.

If we run the program again,

it’s just asking for a number,

and I can just like type some stuff and hit enter,

and then the program ends, nothing actually happens.

We’re building, we’re building.

So now let’s ask ourselves,

is the number greater than zero?

So let me copy paste some code here.

some code here so right now we’ve just finished inputting a number from the user and we’ll ask

you know is that number that they inputted greater than zero so again the first thing we do is we use

a compare instruction cmp we give it two operands the order doesn’t necessarily matter um for

instance uh right now i’m asking is r12 greater than zero so i can do a jump less than or equal

to like a different branch or i can jump greater than equal to if i switch the operands or if i

in a different order, but I’m just choosing to say, let’s compare the two and then let’s jump

if R12 is less than or equal to, which basically means not greater than, this label right here,

which is just branch test after greater test. So I’m going to do a print statement right after that

and then I’m going to draw out what the code is kind of doing. So let me make a label here so

actually will compile. Whoops. I’m in the wrong window. Okay. There we go. So what am I saying

here? Okay. Do the comparison. And then if the condition seems to be satisfied, then we’ll jump

to this, which means we’ll just say goodbye and then exit the program because we’ll return to the

caller. But if that condition was not satisfied, then we’re going to end up executing this stuff

in the middle. So think about this. This is kind of the idea. Let’s see if I can remember how to

idea let’s see if I can remember how to draw this right now off the top of my head suppose we have

like some sort of an input I’ll call this in put and then maybe the input is going to be you know

whether r12 and r0 are equal or greater than or whatever so I’m just gonna say r12 and 0

god that’s awful I really need to practice this draw pad I spend like a whole week practicing

whole week practicing with a different draw pad and then when I come back to

this one I’m even worse than when I started so we we come in and we kind of

look at our 12 versus zero and then we will jump in one direction if that’s not

you know greater than or equal to or less than or equal to and we’ll jump in

another direction otherwise so basically here we’ll say jump less than equal to

um less than or equal to whoops maybe i’ll do r12 uh i need to somehow adjust the pressure on this

thing r12 less than or equal to and so this is sort of uh has to do with you know this branching

path that we take like if r12 was less than or equal to zero then we’ll take the right branching

to after, I’ll just put the word after,

we’ll jump to the after greater test sub label.

And otherwise, if R12 is, sorry,

I said less than or equal to, yeah,

if R12 is greater than zero,

then we jump to this other thing,

which is gonna be the fall through.

So it’s gonna be line 96, but I’ll just say,

I’ll say fall for fall through.

basically the jump won’t happen if it’s greater than or equal to so you could imagine if you

wanted to reverse the logic so you can use a jump greater than instruction you could but I’m choosing

to do it this way and then both of those will eventually reach let’s see will eventually

actually yeah the fall through instructions those will eventually reach the after instruction I’ll

here and then the after instruction will just kind of like finish the program

and exit and all that stuff. So if you think about the control path here,

we have an input we’re looking at R12 with the zero with the compare instruction

and then we use a conditional branching instruction. So maybe I should write,

what do you want to write here? Maybe I’ll just put JLE up here because usually the compare

usually the compare instruction and the conditional jump or branching instructions

kind of you know come as a pair so both of these combined mean let’s look at r12 versus zero and

if r12 is less than or equal to zero meaning if it will jump if we’re less than or equal to the

the right operand r12 less than equal to the right operand then we go down this path on the right

to the after label if that is false meaning r12 was greater than zero then we’ll fall through

this stuff right here and then whether or not we actually fall through will always end up at the

at the after area because we’re either going to jump directly to the after area or we’re going

to fall through and then the fall through falls through to the after area anyway as well let me

just show you that real fast oh man i’m having a hard time with this okay so let’s pretend that r12

less than or equal to. So that means instructions are coming, you know,

instructions are getting executed. We’re going down and down and down and down and down.

Once we see jump less than or equal to, if that’s true, then we jump to the after label,

which means we just kind of jump around this message. And so we’re not going to exit,

sorry, we’re not going to execute that code. So in the case where that is true,

where it is less than or equal to, we’re not going to execute those instructions.

So we’re not going to say their number was greater than zero. We’re just going to simply

We’re just going to simply say goodbye.

However, on the other hand, if that is not true, meaning if R12 was indeed greater than

zero, then we’re going to fall through because this jump less than or equal to instruction,

it will only jump if the R flags, if the comparison instruction thought that R12 was less than

or equal to zero.

If that’s not true, if it’s greater than, then instructions, the control path is just

the control path is just going to fall through.

So that means we will actually execute these.

And then when they’re done,

execution will continue to fall through to the rest.

So that means we’re either going to see a message saying

their number was greater than zero or not,

based on whether their number actually was greater than zero.

Okay, hopefully I explained that somewhat clearly.

Now let’s run the code and see if it works.

Hopefully I didn’t forget anything.

This is kind of a partial program at this point.

program at this point I’m gonna add a bunch more stuff to it so hopefully

this actually compiles enter an integer five notice how it says your number was

greater than zero and if I run it again and I just type zero it does not say

that it was greater than zero if I run it again I type like a negative five it

also does not say that it was greater than zero you know a huge giant number

here it’ll say your number was greater than zero you could probably type a

number that was just absolutely huge and have it overflow I actually don’t know

nines I need to type and I don’t even know what the behavior is going to be.

I don’t know if it’s just going to crash the program because this also relies on my ability

to input a number which is happening in a different library.

Let’s see if that even works greater than zero.

Okay.

It probably overflowed and went to a very, very low negative number.

So okay.

I guess at least I know my library will probably work sort of.

Okay.

So let’s go back to the code here and let’s upgrade it.

how to to check for jump less than or equal to um we’re going to say goodbye right there so now the

next thing we should do is check to see if the number was less than 10. so after the greater test

it’s going to be here so again the same thing like we can just reuse r12 because we’re not really

modifying it and we’re not calling uh well i guess even if we were calling a function r12 was supposed

supposed to be Kali preserved so we’re just comparing it and then maybe

printing a message if we want to and regardless we’re going to end up at 103

this after greater test label so then we’ll compare again r12 with the number

10 and we’ll say jump if it’s greater than or equal to branch test after less

so now at this point we’re saying compare r12 with 10 if it’s greater than or equal to 10 then

just skip over the message so if it’s greater than or equal to 10 then wait a minute wait wait

yeah yeah if it’s greater than or equal to 10 then skip the message otherwise the message

that is printed is going to say that their number is less than 10. so again you could imagine a

want me to write it out for you I don’t know I think once is probably enough but let me just do

it again we’ll do input is coming in and it’s just going to be you know comparing and then

jumping greater than or equal to the input is going to be where we’re just looking to see if

R12 how it compares to zero god the number one is awful my entire penmanship is awful okay one

we’ll do r12 and 10 and so that’s just sort of what we’re comparing with the compare instruction

and then the jump instruction and so if we go on the left i’m going to say that’s the fall through

path again and if we go to the right it’s going to be um r12 greater than or equal to 10 is going

and then here this is going to be after less I’ll say the after label the after less label

so if we fall through it’s just going to print a message maybe I should do another little bubble

here that’s just like print p for how about p for print p for print it’s going to fall through and

then it’s going to print and then it’s going to go to the after label so you can see that

the print instructions are only reached if r12 is not greater than equal to 10 which is the same

to 10 which is the same thing as saying it’s going to fall through if r12 is less than

10.

And then after we finally get to the after label, then we’re just going to do, you know,

the rest of the instructions.

We’re going to exit the program.

We’re going to say goodbye.

We’re going to do whatever.

Okay.

So say there never was less than 10.

And then regardless, here’s like the ending label that we were conditionally jumping to.

Let’s see if this works.

Make run.

So we’ll enter five.

we’ll enter five notice how it says your number was greater than zero and your

number was less than ten let’s do an 11 I guess it says your number was greater

than zero but it does not say that our number was less than ten because 11 is

not less than ten if I do a negative three here it says that our number was

less than ten but it doesn’t say that it’s greater than zero so we have like a

lot of decisions that we could make right like imagine if instead of just

based on something happening, you could call a full function or skip a bunch of extra code,

you know, whatever you want it to do.

So I’m going to go to the next condition where we’re going to compare R12 to the number five.

And we’re going to ask, you know, is R12 equal to five?

So this is going to be the jump not equal branch.

And again, you know, if you wanted to say jump, if it’s equal to the place where we

and then maybe like right after that fall through and just do an unconditional jump you can

I just think there are less jumps if I do it this way so uh here we’re just going to print you know

your number was equal to five and so basically if it was not equal we should have another label here

that allows us to skip that so all right so same thing I’m not going to draw the diagram this time

R12 with 5 and if it’s not equal to 5 then jump to this label down here which just means

let’s say goodbye and not actually say that their number was equal to 5.

But if it was equal to 5 then this JNE conditional branch won’t actually jump anywhere.

Execution will fall through to the next statements which is just printing the message that their

number is equal to 5 and then when that’s done it’ll fall through to this other label

and eventually fall through to the return statement.

the whole thing already nice that was easy um let’s do another run and um let’s enter the

integer one it says one is uh greater than zero and one is less than 10

greater than zero and less than 10 is there any way i can get nothing to print out

greater than zero and less than 10

you don’t think i can do it let me try it nine no

why did I even put 9 okay yeah it’s always gonna say 0 or 10 okay so let’s

do a 4 we’ll get both of those greater than 0 and also less than 10 let’s do a

5 now we should get all those messages your number was greater than 0 your

number was less than 10 your number was equal to 5 and if I just do a 6 in there

again it doesn’t print your number was equal to 5 and we have to enter an

actual 5 for that so that’s the that’s the basics of

conditional branching oh there’s one other thing that I wanted to make sure

in my previous video where we only talked about jumps bear in mind that

these conditional branching statements or instructions you know je j any all

these things they have a limited range of jumps of where they can jump to so if

you have a gigantic program and you’re trying to jump very very very far away

based on a condition you might have an assembler error where your program won’t

even compile won’t even assemble telling you i think the message is i wrote it

I wrote it down somewhere jump out of range coming from the assembler that basically means that these

instructions can only jump about 128 bytes away from whatever instruction they are at or whatever

memory location they are at so you know after your assembler assembles your program and after

your linker links your program and you just have like a binary you know if you were to inspect

all the instructions inside of your executable your binary you would see that they have offsets

offsets, right? You know, like one instruction is basically eight bytes away from the one that

comes right after it. But some instructions are a lot further away. So if you’re trying to jump

to an instruction that is 100 is more than 128 bytes away, it won’t work, you’ll get that error.

So how do you solve that problem? Well, maybe I’ll just write this down real fast. I’m not going to

make this part of the code example. But just imagine we have, you know, jump equal to some

and maybe I’ll do a comment very very far away and here’s the label some label right

so if your assembler says hey you can’t jump to some label because it’s too far away it’s a

jump out of range assembler error then basically you can just make some other labels here you can

say uh you can say short jump true and short jump false you know just make up some sort of a label

label and basically say if it is um well false yeah okay i guess this is the way i’ll do it this

is not super efficient but instead of jumping to the very far away label in the case of true you

can just jump to the true label so i’m going to say jump uh to the short jump true label otherwise

To the false label. So now you’re definitely jumping in either case and both of these labels are close by

So then I can pretty much just have the close by true label do an unconditional

Jump to some label and that overcomes the limitation of branching instructions

So, you know JMP the regular jump instruction

It has an unlimited jump that it can do it can go just to like very very very far away instructions

And then for the false, you know, I don’t know, do whatever you want and then jump wherever you want.

It doesn’t really matter.

I’m just trying to show you that if you make a short jump to a label that will only have an unconditional jump,

so it’s sort of like two jumps, you know, like a short jump and then a long jump,

then you can overcome that limitation.

Again, bearing in mind that some label is supposed to be very, very far away and sort of unreachable.

Okay, so let me just double check that I talked about everything that I wanted to.

We looked at the branching instructions, the sign in this, I drew a diagram for you.

We solved the jump out of range error.

Okay, so that’s, I think that’s basically it.

Hopefully you feel like an expert now at conditional branching and how to make decisions.

In future videos, I’ll talk about how to implement an if else block and how to implement loops

and all that stuff.

decisions in yasm x86-64 assembly and conceptually you can apply this to other assembly languages too

so thanks for watching my video i hope you learned a little bit of stuff and 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 uh if you could do me a please a small little

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.

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

or followed it just wakes me up and I get filled with joy that’s exactly what

happens every single time so you could do it as a nice favor to me or you could

you control me if you want to just wake me up in the middle of the night just

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

you look at the middle of the screen right now you should see a QR code which

you can scan in order to go to the website which I think is also named

somewhere at the bottom of this 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

all the videos i published and the services and tutorials and things that i offer and all that

good stuff and uh if you have a suggestion for uh uh clarifications or errata or just future videos

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

you know just send me a comment whatever i also wake up for those in the middle of the night i

get i wake up in a cold sweat and i’m like it would really it really mean the world to me i

appreciate it so again thank you so much for watching this video and enjoy the cool music

as as i fade into the darkness which is coming for us all

Thank you.

The post Learn Conditional Branching in x86-64 Assembly (YASM/NASM) – CMP, JE, JNE, JL, JG & More appeared first on NeuralLantern.com.