Learn how to write your own strlen function in x86-64 assembly (YASM) that finds the length of a null-terminated string using a simple while loop.

We preserve the proper registers, follow the ABI, compute the length safely, and then use that length to print the full string efficiently with a single sys_write call.

Great for anyone studying low-level programming, operating systems, or wanting to understand C strings at the assembly level.

00:00:00 Introduction to implementing string length in assembly
00:00:25 What are null-terminated strings and why they exist
00:01:59 Pre-computing length vs using null terminators
00:02:53 How the null byte (0) actually works in memory
00:04:14 Naive approach: printing one character at a time
00:05:20 Goal: efficient printing using computed length
00:06:00 Program structure overview – two main functions
00:06:32 Data section: defining null-terminated strings
00:08:19 Additional strings for output (prefix, CRLF)
00:09:15 Text section start and global looper function
00:10:44 Preserving callee-saved registers (ABI prologue)
00:11:28 Calling print_null_terminated_string
00:12:43 Simple crlf printing helper function
00:13:10 print_null_terminated_string function signature
00:14:31 Prologue for print_null_terminated_string
00:15:44 Saving arguments and calling strlen
00:17:12 Using sys_write with computed length
00:18:19 string_length (strlen) function begins
00:19:20 Prologue and fake return value testing
00:20:44 Planning the while loop in C-like pseudocode
00:21:33 While loop initialization (pointer and counter)
00:24:23 Loop top: check for null terminator
00:26:23 Loop body: increment pointer and counter
00:27:37 Done label and return length in RAX
00:28:29 First successful run – full string printed
00:29:30 Adding direct strlen call and length printing
00:31:02 Final run showing both string and its length (54)
00:31:53 Summary – benefits of computed length printing
00:32:59 Improving loop structure (better jump pattern)
00:34:07 Final improved loop verification
00:35:03 Closing thoughts and thanks
00:35:27 Outro, call to subscribe, website mention

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

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, I’m going to show you how to implement the function string length.

So you can find the length of a null terminated string in a Yasm x86-64 assembly program.

Although if you’re using a different assembly language or different architecture, this video

will probably still be useful to you because the concepts are going to be the same.

So what am I talking about?

I’m not going to be around here with this.

So in a previous video, I discussed null terminated strings.

I should also point out that a lot of basic knowledge is going to be skipped in this video

because I’ve explained it in other videos.

For example, if you don’t know how to compile, link, assemble, write a basic assembly program,

write a make file and so forth, then you should see my other videos first.

I’ve also already published a video about null terminated strings, but I’ll just do

it again here since that’s in the title of the video.

of the video so imagine you have a string and it’s hello right so under the hood uh the string is

probably a collection of characters on some level so we’ll just say this is h e uh l

l o right um when you’re printing

it’s unlikely that your entire memory stick is just done like it just you’re at the very end of your memory by the time that O hits

So that means you need some way of understanding when the string ends because if the memory is not over at that point

There could probably be some junk data at the end of it

You know like a bunch of other random letters or you can even imagine these as just you know

One byte that’s not one byte one byte numbers that just go on and on and on forever for the entirety of your RAM stick

of your RAM stick and you have to know how do we actually stop at the O. One thing that you can do

is just pre-compute the length of the string so we do that in assembly a lot before we know how

to scan for null terminators. We’ll say all right well that string is just five long so I’ll tell

the system I want you to print five characters starting at that memory location wherever the H is

and then the system knows okay I’ll just you know print the H-E-L-L-O and just stop after that.

null terminated strings are a lot more convenient because you don’t have to pre-compute the strings.

I mean, maybe your user entered a string.

Maybe you have a lot of strings or they change quite often.

Maybe you have like a multinational program that has tons of translations,

or I think multilingual is probably the better word for that.

But it can be a pain in the butt to constantly compute the length of strings in advance.

So with a null terminated string, you basically just say,

that I want to print and I’m just going to stick actually the number zero at the end of the string.

I’ll leave the junk data there just to let you know that there is some stuff happening in memory.

Notice how this zero, it is not actually the character that looks like a zero to a human.

That’s actually a totally different code than just zero. So you can imagine just an actual zero here.

You know, each of these characters that a human would look at has a number underneath it.

You know, this H is not really an H.

It’s just some number between 0 and 255 if we’re talking about ASCII.

The E is a different number and so forth.

So if we just put the literal number 0 in our data,

or if you want to quote this inside of a single quote,

you can do, I think, slash 0 just to let the compiler know

that you intend to have the number 0 there

instead of something that looks like the number 0, you know, the character.

you know the character but anyways the point is we just have to stick a zero at the end

of the string we call it a null terminator because zero is also you know an alias for null

whenever you have a null pointer or you assign null to a memory location or a pointer or something

you know it’s zero basically under the hood so a zero will terminate it’ll be like a token to let

us know that the string is finished and so since zero is also considered null we’ll say it’s a

we’ll say it’s a null terminator.

It’s a basic idea for null terminators.

Now the question is, how do we actually know when to stop?

Well, the first thing that you could do if you’re trying to write a program that is highly inefficient,

which I’ve definitely done before, is you could just print one character at a time.

You use a for loop.

You start at the very beginning of your string, you know, a pointer,

whatever the user gave you as like this is the first character.

We’ll just print that letter, and then we’ll go on to the next letter.

the next letter and before we print it actually before we print the first letter even before we

print this letter we’ll uh we’ll say is this like a regular character or is this a null terminator

is this a zero if it’s not a zero we print that character if it is a zero we terminate the loop

and then we go through every character one by one just you know checking and printing checking and

printing checking and printing unfortunately that’s kind of inefficient because every time

you call a print you know you’re you’re calling on a function you’re asking the system to do some

for you and it would be a lot better if we could just flush the whole string at

the same time but but know how long the string was that would increase our

efficiency so the program that we’re going to write together is basically

going to use our knowledge of a while loop which I’ve explained in other

videos already so see those other videos if you don’t know how to do while loops

in Yasm we’re going to use our knowledge of a while loop to sort of scan the

string real fast just you know kind of scan it and figure out how far into the

far into the string until we see a null terminator and use that to determine what is the length of

the string. At that point, we can use a system call in YASM, in assembly, to just say, I want you to

print this sequence of characters and here’s the length and then let the system worry about

efficiency. So with that said, let’s look at some code. Okay, it’s just going to be a simple while

loop. What we’re going to need to do is break this up into two parts. The first part is going to be

the first part is going to be a function called string length which you’ve probably already seen

in c if you program in c or c plus plus the second function is going to be called print null terminated

string which will just ask string length what the length of the string is first and then actually

print it with the system call so let me uh i guess let me start off with my data section here

to print I’m gonna copy paste that for my solution again this is not a not an

assembly basics video so if you don’t understand what I’m doing you should

watch my other videos first I’m assuming you know how to make a data section by

now we’ll put some C strings I’m just gonna make one null terminated string

actually I guess I’m making two but the focus of this program is just the first

one I’m calling it null terminated string and in assembly it’s pretty easy

you just make it a you know a character array just like a sequence of bytes with

a sequence of bytes with this DB meaning data bytes.

And I can just put a quoted string like this.

No problem.

As many characters as I want.

I can start injecting specific ASCII values if I wanted to

or byte values if I wanted to just by putting a comma

and then a number.

So I could do something like this.

I could do like, you know, 47, you know, 49, you know, 50, whatever.

If I knew the ASCII codes for the characters,

fortunately, I don’t need to.

normally into the double quoted area but then i need to be able to put a null terminator at the

end of my string because it’s not going to happen automatically so then i am going to do comma zero

and you’ll end up with something like this like if i guess if we look at the previous example real

fast i’ll call this a hello string just so that you see some similarity from what we just looked

a notepad thing would just be typing the word hello and then putting comma zero.

So it is now a null terminated string and it looks just like this inside of system memory.

Well, not just like that.

There would be numbers where the letters are, but you know, that’s basically what we have created.

And then of course there’s junk data afterwards, but we don’t really care about that.

You know, we’re just going to ignore it with the null terminator.

So I’m going to erase that since we’re not just going to print the word hello.

We have a null terminated string here and then after we print the null terminated string

I’m just going to print out what was the length of the string.

So this is a prefix string where it’s just, you know, it’s a prettier program.

The program is going to say the null terminated string’s length was something.

And then we’re going to use the null terminated string printer to print that also.

Convenient, right?

And then I’m going to actually print the number.

Then we have this down here, crlf, which is just printing a new line in the terminal.

That’s character code 13 and then 10 and then a null terminator so that we can use the null terminated string printer again.

And then we’re going to use system call code 1 to print a standard output right here.

If you don’t understand that, then see my other videos.

But let’s move on to the text section where all our instructions will go.

Okay, so now the instructions begin in our text section right here.

section.text and I’m using an external symbol this video is not about this

library here but basically I have a library that will help me print integers

you don’t need to worry about that you could imagine well I guess in your

example when you’re practicing if you don’t have this library you could just

not print the length of the string and just use it only and it all should still

work or you could hard code the thing that you’re printing if you really

wanted to. Okay, so I’m just going to continue on here. Now let’s do our entry point. So again,

this is not a video about hybrid programs. Just assume that there is another module in my program.

It’s a C++ module. It’s got the main function, you know, for the entry point for a hybrid program,

and it’ll just call on my looper function. So that’s why I’m marking a looper as global.

So my other module can call it. And well, it is a function that needs to return. So I’m going to

to return so i’m going to put ret at the end of it and you can see here i left myself a note saying

i’m going to use r12 to remember the length of the string so that i can print it back to the user

so that means i have to preserve r12 for the caller because the abi or the application binary

interface says that r12 is a callie saved register and if you don’t respect the abi

the abi is not going to respect you your program is going to end up crashing eventually

So I’m just going to do a push pop pair to preserve R12.

Oops, prologue and call that epilogue.

Okay. So we got a push pop pair. We got a return statement.

This program should probably do nothing so far. So let’s run it and see,

just make sure that it at least compiles.

So I’m going to say clear and make run running the program.

Hello from the driver. You don’t know that the driver has that.

that the driver has that. This is not a driver video. And then the driver regains control because

nothing happened inside of the assembly module. We just basically looper got called and then we

preserved R12 and then restored it and then we did nothing. Okay, so now let’s make a call to

print null terminated string. We have to make another function for this, but right now this is

just the call. So the name of the function that we’re going to write is called print null terminated

it it will call on the string length function to figure out how long the string is then it will use

a simple system call to print the whole string giving the length to the system call it also takes

two arguments the first argument is a pointer to the null terminated string so that’s just that

symbol we defined up above remember when you define variables up in the data section then

these symbols tend to be pointers so that symbol is a pointer to the h basically or just the memory

that h is sitting in ram then the second argument that it wants is uh is where we’re going to print

it so we’re just going to print it to standard output um which is just file descriptor number one

so again if you don’t understand arguments or you know file descriptors or function calls

see my other videos because i’ve explained those already anyway so we’re going to call

print null terminated string then we’re going to call on crlf which will just print a new line

So now maybe we should implement, well, let’s copy paste crlf so that I can implement the

other function a little bit more slowly.

What does crlf do?

It literally just asks the print null terminated string function to just print a crlf for us.

So it’s very, very simple.

Here’s the signature.

Nothing much to it.

Okay.

Now, a little bit more complicated is the print null terminated string function.

So in our looper, we’re going to print the null terminated string.

We have to have a function that actually does that.

So that’s going to be this one right here.

Here’s the signature that I’ve chosen for my print null terminated string function.

Basically, I want to receive a character pointer to the first character in the string that we’re going to print.

And then a file handle designating where we’re going to print it.

The reason I want to receive the file handle is so I could print a standard output or standard error.

or standard error, or I could print to a file,

like whatever I want to do.

You don’t have to have that in there, but it’s nice.

Anyway, so we have this function set up.

Notice how my notes that I left for myself

is that I’m gonna use R12

to remember the incoming C string pointer argument,

and I’m gonna use R13 to remember the file handle.

Remember, it’s probably not a good idea

to just let the incoming arguments

stay in their original registers,

original registers because those registers tend to get overwritten as you do system calls or

calls to any other function. So I’m just going to grab them real fast into R12 and R13. And then R14

is the string’s length, which I’m going to compute with a call to the function called string length.

So just three things to remember. And that’s it. So that means I’m going to have to preserve those

Okay, so we’re going to do a prologue to preserve those registers.

And then at the very end, we’re going to do an epilogue where we restore those registers.

Oh, I think I already overwrote my return statement from the previous function.

I think I did that in the last video and I was a little confused as to what was wrong.

So make sure you don’t accidentally overwrite or push down your return instructions.

Let me just double check here.

Looper’s got return.

Print and alternated string has got a return.

string has got a return.

CRLF has a return.

What the heck did I do?

Oh, I think I copy pasted in a bizarre place.

That’s probably what happened because the epilog for for print null terminated

string is like down in CRLF already.

That’s not good.

Okay, that would have been a crashing program.

Although sometimes if you omit the return statements, execution will just fall

through down to the next label and maybe your program will survive accidentally.

accidentally but for now it’s just crlf is supposed to be very simple it doesn’t preserve

any registers so we’ve got a prologue and an epilogue here notice how the push and pops are

in reverse order you want to know more about that see my other videos but now that we are preserving

the appropriate registers we can actually grab our incoming arguments so first thing i’m going to do

is i’m going to say r12 is going to be the first argument that i received and then r13 is going to

okay no problem then let’s rely on the string length function to compute the actual length of

the string i didn’t feel like having print null terminated string compute the length of the

string it’s a good idea especially in assembly or any language when you have multiple distinct

jobs happening within the same function you probably want to break that function up into

multiple functions just to reduce you know strain on your brain right cognitive load

So I’m going to use this function strlen string length to compute the length of the string.

It’s only going to take one argument and it’s going to take the pointer to the null terminated

string which is now in R12. It’s going to take that as its first argument so that’s why I’m loading

that up into RDI. When string length returns it’s going to give me the length of the string in the

RAX register which is the usual return register for integer or pointer return types. So I’m just

So I’m just going to save that in R14.

And that’s the usage of all those registers R12, 13, and 14.

We still have to implement string length.

Don’t worry.

Although if you were linking a hybrid program, you could probably just call

STRLEN in the C libraries and be fine.

But this is an assembly video.

We want to do everything in assembly if we can, or at least more of it.

So then finally, when we know what the strings length is, we can just use a

system call to actually print the string we’re going to say load up call code one to say you

know mr. system I want you to print a string and then r13 is going to be the file handle so we’re

going to basically say wherever the caller of print null terminated string said to print which

is probably going to be standard output we’ll just tell the system we want to print to the same place

and then r12 is a pointer to the c string so we just give that to the system call as well

system call wants to know how long the string is that’s r14 now now that we have used strlen

to determine the length of the string so not really that complicated of a function we just

kind of like grab some arguments preserve those registers and we ask another function to compute

the length of the string and then we actually just print it once we have the length this is still not

getting to the point where we’re going to use our while loop knowledge to compute the length so i

That’s probably all I need right now.

And I think we’re ready to use or to start the string length function.

Okay, so now let’s make another function called string length.

Hopefully I’ll paste in the right spot this time.

You’re cringing at home.

That just tells me that you care.

So the string length function, at least the version that I’m making right now,

just is going to take one argument.

It’s going to be a character pointer to the string that you want to compute.

It will expect that the string has a null terminator at the end.

the end if you accidentally didn’t put a null terminator at the end of the string then this

function definitely won’t work it’ll probably give you some huge number because it’ll go through ram

until it accidentally finds a zero um and then it’s going to return to you as its return value

and uh assigned a 64-bit integer actually this should be unsigned but i’m just putting long for

now um to indicate the length of the string okay inside the notes we’re going to use r12 and r13

So that means I should probably preserve those registers first before I do anything else.

So in the prolog, we’re going to push R12 and R13 so that we don’t break this program

for others.

And then we’re going to do an epilog.

Whoops.

Then we’re going to do an epilog to restore the registers.

And this is a function.

So it’s got to return to the caller.

If I didn’t put a return statement here, then execution is going to just go all the way

down to CRLF.

And this will be an infinite loop.

and this will be an infinite loop because crlf will end up calling null terminated string,

which we’ll then call string length, which will then fall through to crlf,

so the whole program won’t even work if we don’t have return.

And, you know, you don’t want to omit return statements anyways,

because that’s always a bad idea.

So now string length will just not do anything right now.

Maybe we could return a fake value for a second before we start implementing the loop.

the number five into RAX so that string length will always trick the caller into thinking that

the length of the string is five let’s see if that actually works we should get a portion

of the null terminated string unless I screwed something up

hello from the main driver notice how it just says hello here that’s kind of confusing let’s

let’s hard code the five to like a nine we should see more of that null terminated string

I sound when I wake up sometimes hello okay so let’s finish the str len function so again you

should know how while loops work if you don’t see my other videos but we’re going to use a while

loop to count the length of the string so we’re going to start with a little portion up here

think the string is and a running pointer so rdi is already supposed to come in as a pointer to the

string that we’re measuring so i’m going to save um the pointer into r12 so that we can have a

pointer that points to a character we’re going to use this as a running pointer so it’s going to like

sweep through the whole entire string until it hits a null terminator and then r13 is going to

keep track of uh how big we think the string is so when we first start we’re just looking at the

first start we’re just looking at the first letter and then we think the string has zero length.

So that’s the initialization part which will not be repeated as we continue looping. Now we’re

going to implement the top of the loop. I don’t know should I should I write this out as c code

for you? I don’t know if I should maybe let me do it. I didn’t prepare this so if it’s slow sorry

Maybe this is like a long strln, something like that.

And then we’ll do if my code is wrong or doesn’t compile, I’m so sorry.

I did not, I did not prepare this.

We’ll say character pointer s and then we’ll say, uh, maybe we can actually just leave

s alone because it’s coming in as an argument and in C plus plus you can just continue to

use that symbol.

It’s not going to get destroyed.

So imagine we’ve saved it already into R 12 and then we just keep using it.

using it so we’ll say while a let’s say a dereferencing of s is not equal to zero meaning

if we look at the value that the pointer is currently pointing to if we assume it’s just

pointing to one byte is we’ll keep going as long as that value is not a zero so that means

if the user called this function and gave us a pointer that was already looking at a zero

we would just return whoops we would just return that the length was zero so

that means I should probably keep track of the length here size type actually

long just to just to match the return signature long we’ll put size equals zero

and then at the very end we’ll just return the size and so again if the user

gave us a pointer that pointed to a zero already nothing would happen inside the

while loop we’d break through it right away and we would just return the number

the number zero that makes sense so then as long as it is not pointing at a zero

we’ll just increase what we think the size is and then we will increase the

pointer we can use s plus plus in C++ that’s just pointer arithmetic that’s

just going to tell the pointer to advance you know one memory location

further or whatever the data type is but in this case the data type is a

character so it really is going to be one memory location one byte so we’re

going to sweep through the string until we see a zero and then we stop and every time we see a

character that’s not a zero we increase our our measured length of the string by one and then

advance the pointer. So I haven’t tested this I don’t know if there’s an error in it but I hope

you get the basic idea of what we’re going to do. So that means up here you know this is the

initialization part that we were just talking about so we just set the running pointer to look

okay so then after we do that we are going to make the top of the while loop

so at the top of the while loop where we evaluate you know like right here this

is the top of the while loop it has to have its own label just like we explained

in the other videos and it is basically where we decide if we’re going to keep

looping or not are we going to jump into the body the loop or are we going to do

a long jump after the body to say that we’re done so the top of the loop is a

label. We compare the value that R12 is currently pointing at. We say that we only want to look at

one byte. We dereference R12 because remember R12 is supposed to be a pointer. You put the

brackets around it, it’s going to go to the memory location and then check what the value is that

the pointer is pointing to. That’s what dereferencing is, right? So we’re just going to

compare the byte that we’re looking at with a zero and we’ll say if it is equal to a zero,

jump to the done this is actually kind of a poor design pattern on my part usually we should jump

if it’s not equal into the body meaning we’ll always take a short jump into the body and then

execution will fall through on the next line to a long jump which has the ability to jump further

out of the body i’ve said in other videos that the conditional branch instructions they can only jump

about 128 bytes so if your if your loop body is too big then they won’t work but it’ll work for

But it’ll work for this example.

I don’t know, maybe if I have the gumption, I will fix up the loop for you if you want

me to after I copy paste my existing solution.

So for now we’re going to say, all right, I’m not going to do it.

I’m not going to do that.

Maybe in another video, if somebody requested, I might post another video in like five years.

Anyway, so we’re going to jump if it is a null terminator to the done label.

Otherwise we will fall through to the loop’s body where we’re just literally going to increase the pointer and also increase our idea of how big the string is.

So remember R12 is the pointer.

Integer arithmetic doesn’t, sorry, pointer arithmetic doesn’t really work here, but it accidentally works here because we’re looking at a byte array.

So if we just increase by one memory location, it will literally just increase by one memory location and we’ll be fine.

Just keep in mind that if you were sweeping through an array of, you know, quad words or some larger data type,

then just a simple ink wouldn’t actually work.

You’d have to increase by the appropriate number of bytes.

But hey, the number of bytes in one item is just one byte, so it’s easy.

So we’re making the pointer go forward by one on line 134 and then in line 135.

line 135 we’re increasing our idea of how big the string is and then we will unconditionally jump

to the top of our loop and so if you just kind of look at this what did i do i pasted that twice

oh god okay sorry guess i lost track of what i was doing so then we will unconditionally jump

to the top of the loop so basically you can imagine this loop is gonna it’s just gonna

continue forever just moving the pointer and increasing the counter and moving the pointer

finally when it sees a zero a null terminator then it actually breaks to

the done label and the done label is just doesn’t really do much it’s just a

label to get us out of the loop so the top of the loop says if we are done then

just jump to the done area notice how that skips over the the top jump and then

of course under that is going to be the epilog and then we can we can take the

we can take the return value and set that up now because at this point R13 should contain

the actual length of the string. So if we move that into RAX respecting the ABI for return values,

then the caller should be able to get the string length just at that point by itself.

So let’s see, that might actually be the whole entire program already. Let me

double check here. All right, let’s run it and see if it actually works.

and then do a make run.

What’s up with those asterisks?

Did I put that in there?

Oh, I wonder.

Okay.

So the driver comes in,

it calls on our function,

and the whole null terminated string gets printed out.

It says, hello, this is an example

of our null terminated string.

Notice how it printed the full length of the string,

not any less,

and it also didn’t print more than the length of the string,

i.e. junk data,

because it knew exactly how long the string was.

was and this is way better than printing one character at a time in terms of efficiency we

just pre-compute the length and then print exactly that length and then we’re done i think there is

one more thing i wanted to do here let me see up at the top yeah okay let me go back up to the top

of the program here so in the looper function we called on print null terminated string and we

didn’t do anything else so what i would like to do is just make an explicit call to string length

explicit call to string length inside of the lubr function just to get the length of the

null terminated string so we can just print it to the caller or print it to the user

and then I’m going to use my special library function here actually just just for your

information notice how I’m calling string length just like the the print null terminated string

function did and I’m just giving it as an argument a pointer to that null terminated string so then

So now I can just print r12

Well not yet, I’m gonna print a prefix if you look at the prefix here, it’s just

The null terminated strings length was and then I’ll print a number after that

You do it this way, you know your program is more pretty it’s more

It’s more nice to the user and so forth so I’m going to do this

we’re printing a nice prefix, a hard-coded string to the user to let them know that I’m about to

show them the length of the string. And then I use my external function that just prints a number to

the user. Again, this video is not about this library. You can use some other library if you

want to print something, or you can omit that part if you don’t have one set up yet. But

so I’m going to tell, I’m going to do first argument is R12, which was the length of the

I’m going to call this function and say I would like you to print r12 which is the length of the string so

After that we’ll print a new line to make things a little bit tidier and then I think this program is actually finished

Run it again now it says here’s the null terminated string and then on the next line it just says

The null terminated strings length was that was the prefix and then when I called my library

the number it says 54. so i don’t know was it 54? let’s just double check to make sure that it

actually was 54. 54 should not include the null terminator so i’m going to go 1 2 3 4 5 6 7 8 9 10

1 2 3 4 5 6 7 9 20 1 2 3 5 6 7 9 30 1 2 3 5 6 7 9 9 30 1 2 3 5 6 7 9 9 50 51 52 53 54 was it 54? i can’t even remember anymore.

So we have basically proved that this works.

We have leveraged our knowledge of while loops to implement a string length function, which

will let us have a printing function that is very smart.

So we don’t have to hard code string lengths up at the top anymore.

As long as we’re working with null terminated strings, everything will just work out now

with less variables or less defines.

Okay.

Let’s see.

I think that’s pretty much everything that I wanted to talk to you about.

I don’t know. Could I do,

could I do this easy, easily?

Loop top.

Okay. Yeah. I think I could probably do this reasonably.

So at this point,

you are satisfied that you understand how to implement this and you’re happy just cut the

video the rest of this video is going to be me sort of like improvising trying to figure out if

i can rearrange the logic in a fast enough time for a video uh just to show you that you know you

should you should probably write your loops a little bit better than i did so here we go but

this is this is just redundant stuff so we have our loop here and we have our initialization

The loop top, it should compare R12 to 0 and it should break the loop if it is a 0.

So that means I’m going to comment out this.

And I’m going to do jump not equal to 0 to the body.

And I just need to make a label for the body here.

So I’m going to say str lane loop bottom.

So there’s a label, which is the body.

Maybe I’ll do a comment here just to remind us that this is actually the body.

I guess I’ll do another comment right here.

So that’s the loop’s body.

So I’m going to say if R12 is not a null terminator, jump into the loop’s body.

Otherwise, we fall through to the next instruction,

and that will just be an unconditional jump to the done area.

Okay, and then when we’re inside the loop’s body, we’ll jump back up to the top.

I don’t know why I thought this was going to be hard.

Let me run this to make sure I didn’t break the program.

Yeah, it still works.

Okay.

I guess I overestimated the difficulty there.

The point being, the body is a lot closer to the top of the loop.

So that should be the thing that does a conditional branch.

You should conditionally branch to the body because it’s a shorter jump and therefore

much less likely to be out of bounds of that 128 conditional jump bite restriction.

And then when we fall through to the next line, because we did not do that jump,

because we did not do that jump then we’ll do an unconditional jump to the done area and you know

our loop is small so it didn’t really matter the first time we did this but um again imagine your

loop is huge that you definitely want an unconditional jump that goes to the done area

at that point and that’s also what we’re doing an unconditional jump to the top here when we get to

the end of the body so when you’re jumping large uh you know spans you want to use unconditional

Alright, so I guess that’s it.

I’m going to erase maybe this comment.

Well, I’ll leave that in there just for posterity.

And now I will officially say that I hope you had a good time watching this video.

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

I will see you in the next video.

I’m going to go play some video games.

Maybe I’m going to eat some soup first.

Hey everybody.

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

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

a small little favor, could you please subscribe and follow this channel or these videos or

whatever it is you do on the current social media website that you’re looking at right now.

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

So we’ll be able to do more videos, longer videos, better videos, or just I’ll be able to keep making

to keep making videos in general. So please do me a kindness and subscribe. You know, sometimes

I’m sleeping in the middle of the night and I just wake up because I know somebody subscribed

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

time. So you could do it as a nice favor to me or you could troll me if you want to just wake me up

in the middle of the night, just subscribe 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,

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 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 would really mean

the world to me. I would really appreciate it. So again, thank you so much for watching this video

and enjoy the cool music as, as I fade into the darkness, which is coming for us all.

Thank you.

The post Implement strlen for Null-Terminated Strings in x86-64 Assembly (YASM) appeared first on NeuralLantern.com.

Quick practical guide showing how to implement a classic for loop (i=0; i<n; i++) in x86-64 assembly with YASM. We break the for loop into init/check/update parts, convert it to while-style logic, then build it with compares, conditional jumps, inc, and unconditional jumps back to the top. Includes real working code, user input, and printed output.

Great for students learning assembly after C/C++, OSdev hobbyists, or reverse engineering beginners.

Introduction to For Loops in Assembly 00:00:00
For Loop Structure in High-Level Languages 00:00:28
Breaking Down For Loop Parts: Init, Check, Update 00:01:04
Converting For Loop to While Loop 00:01:52
Why While Loop Style Helps in Assembly 00:03:16
Program Overview and Setup 00:04:12
Data Section – Strings and Messages 00:04:40
External Functions and Hybrid Program 00:06:11
Entry Point – Looper Function 00:07:12
For Test Function and Register Usage 00:07:42
Preserving Callee-Saved Registers 00:08:05
Printing Welcome Message 00:09:00
Prompting User for Number 00:09:48
Getting User Input 00:10:25
For Loop Structure in Assembly – Comments 00:11:12
Initialization – Setting Counter to Zero 00:12:50
Loop Top Label and Condition Check 00:14:28
Conditional Jump Setup (jl) 00:15:07
Handling Jump Distances 00:15:34
Loop Body – Printing Current Number 00:16:58
Update Part – Increment Counter 00:18:40
Unconditional Jump Back to Loop Top 00:19:14
Loop Done Label and Exit 00:19:55
Printing Goodbye Message 00:20:23
Testing the Program 00:22:08
Final Results and Demo 00:22:24
Outro and Call to Action 00:23:25
Thanks and Subscribe Request 00:23:45
Website and QR Code Mention 00:24:38
Closing Thanks 00:25:16

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

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 I’m going to teach you how to implement for loops in YASM x86-64 assembly.

Although if you’re using a different type of machine or a different assembler,

this video should still be useful to you because it’s mostly about the concepts involved in implementing a for loop.

Okay, so for starters here, what am I even talking about? Let’s do…

are you even talking about dude imagine in a higher level language we have a for loop here

and so we have like four size type i equals zero i is less than 99 i plus plus right probably most

programmers looking up assembly uh on the internet probably are interested in uh or probably already

know how to implement for loops in c plus plus so let’s just pretend that you do and so inside of

your for loop we’ll do stuff and what happens here is uh well you know this for loop is going to run

Well, you know, this for loop is going to run 99 times.

It’s going to start at zero.

And, you know, so we have like an initialization part right here.

Maybe I should copy paste this and kind of break down the parts.

We have an init part here for the for loop.

We’ll say init part.

And then here we have a check part.

We’ll continue to loop as long as this expression is true.

You can make a big complicated expression if you want to,

but we’ll just keep it simple for this video.

So I’ll call this the check part.

And then we have sort of an update or a maintenance part.

an update or a maintenance part. So I’m going to call this the update part where we increment our

counter variable, move pointers, even call functions, do whatever it is you think you need

to do to update the loop so that it runs it, you know, so that the loops don’t actually have to be

integers. But in this case, I think it’s better, it’s easier to understand what the loop is doing

if we just kind of break down these parts. Anyway, so what is really a while loop? Sorry,

but a while loop that breaks and has break has like a nit logic and breaking logic and checking logic just in specific places.

Imagine this. What if I said before the loop starts, I’ll let’s let’s say we’re going to do a while loop before the loop starts.

I’m going to initialize a variable size type I equals zero, right?

That’s the initialization part that’ll only happen one time.

And then when you have a while loop and it checks to see if it should keep going, that’s

the check part of the for loop.

So I’ll just say while i is less than 99.

And then for the update part, we just have to stick that inside of the while loop somewhere.

Depending on your logic, you might want to put it at the top or the middle or the bottom.

I’m going to put it at the bottom because I’m going to expect that it happens right

before we do the next check.

So I’m going to maybe do a comment here and call it the update part and I’m just going

So maybe if I update this code to print something, it’ll seem a little bit more clear.

Value of I is, and then I’ll just say I end L, and then I’ll copy paste that to here.

And then I can also put this inside of the while loop.

And now we have transformed our for loop into a while loop.

transform your for loop into a while loop it’s pretty easy to implement in assembly if you

already know how to implement while loops so i should again say that there are lots of parts

i don’t know if i said that during this video but there are lots of things in this video that i’m

not going to that i’m not going to explain specifically because i’ve already explained

them in other videos so for example implementing a while loop is in another video so if you don’t

already know how to implement while loops if you don’t know how to use conditional branching or

If you don’t know the basics of assembly, hybrid programs, make files, all the basic stuff that I’m going to skim over in this video,

then you should probably check out my other videos first.

But for now, I’m just going to assume that you know how to implement a while loop.

And really the lesson is, hey, just take your for loop and convert it into a while loop.

And then you can implement the while loop pretty easily.

That’s the secret as far as I’m concerned.

So imagine this now. Let’s do some assembly code.

I have a source code file here called looper.asm for assembly.

And you can imagine that I have a hybrid program running under the hood.

I’m not going to show you all the code involved.

I’m not going to show you the make file or the C++ driver that calls on this module.

We’re just going to write the assembly here.

So, you know, if you’re writing pure assembly at home to practice, that’s fine.

Just keep in mind, there’s like a few things under the hood that I’m not showing in this specific video.

So first off, I’m going to copy paste my data section.

paste my data section of my assembly program. The first thing to note is we have a bunch of

C strings here. We’re basically going to be telling the user, hey, we’re going to begin

the four tests. Maybe I should have capitalized for, I’ll leave it. And then we’re going to prompt

the user for a number. We’re going to say, please enter a number. The loop will print from zero to

the number minus one, which is like the typical four loop that you usually write in the most

and then we’re going to have a little prefix we’re going to say you know like an arrow and then we’re

going to print the number back to the user that we’re looping through so if the user enters a

10 it’s going to print the arrow 0 and then arrow 1 arrow 2 all the way up to arrow 9

and then when we’re done we’re going to print an ending message so this is nothing new if you know

assembly already just c strings that will print with system calls see my other videos if you don’t

And then a CRLF string, just basically doing a new line, a carriage return new line feed

on the system.

And then we’re going to output using system call code one.

And we’re going to use file descriptor one so we can print to standard output.

Okay.

So now the real fun begins.

Let’s start our text section, which is where the instructions of our assembly program go.

So I’m going to do text section, section text right there.

And I’m going to use two external functions to just help me input and output numbers to the user.

If you wanted to, you could use a system call that just inputted a character.

And then you could just kind of like loop printing various characters.

And like, let’s say if the user typed A, maybe you could imagine doing a loop that increases the character that they typed all the way until it hits Z.

Or if they hit, you know, F, it’ll just print F all the way to Z.

to z you could do that without using an external library for printing integers this video is not

about this library right here so i’m not really going to go over it but uh you know you could

hard code the start and end points when you’re practicing um you could you could use a different

library or a different function call to get the inputs you could use a system call just to input

one character um or you could you know use a hybrid program to to utilize printf and scanf

f. Either way I’m just going to be using these two functions just to like get input and output.

It’s not really part of the idea of looping. So now let’s start our entry point.

Our function is called looper. Since this is a hybrid program you can imagine there’s a C++

module elsewhere calling on the looper function and so that’s why I mark it as global so it can

be called upon. And then I have another function called for test. I don’t really know why I chose

it this way but i wanted to make another function that was called upon by our entry point here

so the looper function really doesn’t do anything except recall the for test function

so now let’s start the for test function actually maybe this is where the fun begins

so i’m gonna put it down here and so you can see the signature it doesn’t take any arguments it

doesn’t return anything it just does stuff and then i have a note to myself this is how we’re

going to use the registers we’re going to use r12 for the user’s number and then we’re going to use

And then we’re going to use R13 to keep track of where we’re going.

So let’s see.

I’m going to start by saying let’s preserve R12 and R13

because you have to respect the application binary interface, the ABI,

and that designates R12 and R13 as Kali saved registers.

If I don’t preserve those and my program is even a little bit complicated,

I’m probably going to be debugging forever

debugging forever or I’m going to just crash my program for no reason. So I’m going to just

do a push pop pair. Notice how the pops are in reverse order. This is not a push pop video,

but just so you know, I guess while I’m here, I’m going to copy paste my crlf function,

which really does nothing. It just prints out the crlf string with a system call. That’s all

Okay, so do I even need CRLF in this program?

I think I just modified this.

Maybe I don’t even need it anymore.

No, I guess I do.

The first thing we’ll do is we’ll print an introduction message to the user.

So inside of the for test, we’ll just use a system call to print out, you know, a welcome

message to the user.

And then I’m going to call CRLF, which will just give us a new line.

And yeah, you can hard code, you know, the 13, 10 at the end of these strings, but I

don’t really like doing that.

doing that. Okay, so we should have a working program at this point. Let me see if it actually

does work. Clear and make run. Okay, so the driver prints a little welcome message. You don’t see the

driver code, but that’s what it’s doing. And then the for test prints the welcome message that we

just added. And then the driver lets us know it’s retained control. And then it’s responsible for

returning to the operating system for us. Okay, so then the next thing we’re going to do is we’re

we’re going to ask the user for a number so that we know how many times to loop.

And again, you could hard code this number if you don’t want to do IO right now.

You could even print a character a certain number of times

if you don’t want to even deal with printing an integer.

But I’m going to ask the user for a number.

That’s going to be the prompt string.

And if we run it again, now you should see it asks the user for a number.

So it’s going to say, please enter a number.

The loop will print from zero to N minus one.

print from 0 to n minus 1. It doesn’t actually ask for the number though. It doesn’t actually

I guess take the number so that’s going to be my external library that this video is not about

where I just call a function called input assigned 64 integer and I’m going to receive that back in

rax and I’m just going to save rax into r12. So r12 is now going to be the number that the user

inputted and that’s why up here I have it designated as the user’s number. So really not a big deal but

a big deal but uh you know if we run it again it’ll ask for a number and then it won’t do

anything else it’ll just kind of quit okay so now we can implement our for loop this is going to be

a little tricky so we’re going to start off with the initialization part remember we had several

parts here if i just kind of drag this off to the side maybe pin it up to the top so we can see it

aren’t we? If I move it a little bit to the side. So remember that for loop, it’s got an init part

and a check part and an update part. And I’ve kind of added that as a comment just to remind myself

of the way my mind is supposed to be wrapped around this concept. And so I made another comment

here with four and then empty parentheses just to denote that some comments that come below

I guess the top of the for loop

So now I’m going to make a label here and what I like to do with my labels is I like to

prefix them with the name of the function that I’m currently in and then an underscore and that kind of helps me keep track of

My symbols a little bit more easily, especially if I have a large module the symbols are less likely to overlap if I prefix them with the

The function names

to be Fortest underscore something and since I’m only doing one thing inside of the Fortest function

I’m just going to have a suffix only for the most part but you can imagine if you had more

parts inside of your function and it started getting a little cluttered you might want to have

you know another label you know that just sort of another I guess like part to your label that names

the part of your function you’re in although this is assembly it gets really hard really fast so

really hard really fast so if your function is even a little bit complicated you should probably

consider breaking it up into multiple functions if you can. We can’t really do that at this point

because it’s just a for loop but keep that in mind. Okay so we’re going to initialize. Remember

the first thing we had to do to initialize was you know setting i to zero or you know whatever

it is that we’re going to set up in the init part so I’m just going to do that here. I’m going to say

That’s the first part, the update part where we set size type i equals zero.

In fact, maybe I could do another copy paste of this.

Where instead of using a size type, we’ll just say that the register r13 equals zero.

I know that’s not going to make sense in a higher level language right now,

but just so that the for loop looks a little bit more like assembly.

We’ll keep going as long as r13 is less than r12.

and then we increase R13.

So I’m just going to put ink R13

so it looks more assembly-like,

even though this completely and totally

would not compile in C++.

I hope that this helps your understanding a little bit.

So yeah, we can do everything

except for just the increase part at the very top.

I’m going to choose to increase it at the bottom.

If you wanted to, I guess you could start off R13

as a negative number and then increase it at the top.

But I personally don’t feel that’s like very clean.

feel that’s like very clean it also forces you to use signed integers maybe you wanted to use an

unsigned integer so you could get like a gigantic um maximum number that you looped up to i don’t

know so we’ll just initialize here and we’ll say r13 is equal to zero the init part should not be

part of the actual like looping like every time you loop up to the top of the for loop you should

not repeat that part again it should only happen once so the next label that i have is called loop

have is called loop top and that’s just going to be the top of the loop that I

continue to go back up to every time I want to see if we’re supposed to

continue looping and then go into the loops body so maybe I should say that’s

why this is named to underscore loop top and I don’t know you don’t have to do

camel casing and your labels you know you could just do loop in it or whatever

but I’m just choosing to do it this way so at the top of our loop we’ll be

Remember that was the check part, right?

So we’re going to check to see that R13 is still less than R12.

If it is, we’ll continue with the for loop.

If it’s not, then we jump out of the for loop.

So that means probably the true case where R13 is indeed less than R12,

that’s going to be a short jump just into the loop’s body.

And the false case where R13 is not less than R12,

that should probably end up being a much longer jump.

on how big your your loop is maybe that jump is too long too far away for a conditional branching

instruction to reach if you’ve watched my previous videos you should know already that

the conditional branching instructions like jl like jump less than they can only reach about 128

bytes away if you try to go further than that the assembler will actually stop and block you from

finishing your compilation it’ll say i think it’s like jump out of range or something like that

So you want to try to keep the short jump points with your conditional branches.

And then in the false case, where the conditional branch doesn’t actually do anything,

then it falls through to the next instruction where you will have an unconditional jump.

And remember, the unconditional jumps, they don’t have a limitation of 128 bytes.

They can jump like all over the place.

Like they can jump anywhere, basically.

that means if you think about it, we come in to the loop top right here.

We immediately do a compare instruction and a conditional branch.

So if R13 is less than R12, meaning we should continue to for loop,

then we’ll just do a short jump into the loop’s body and actually execute its body.

And if not, we will end up falling through to line 92,

where there’s just an unconditional jump instruction that just says,

all right, let’s jump all the way down to being done.

Let’s jump all the way down to being done, which could be very far away for all we know.

Okay, so we’ve done that.

Now let’s implement the loops body because the first thing that we did is we wanted to

jump into the loop body to actually execute our instructions, which in this case, we’ll

just be, you know, printing a number every time we loop and then increasing that number.

So I’m going to do a little like new line there.

I’m going to paste the loop body.

little comments to help remind myself that this is actually the loop’s body. So for test loop body

that takes care of the branching instruction, hitting on that and actually going into the body.

And then later we’re going to have to implement a label for the loop being done. But for now,

we’ll just say the body. What does it do? It just prints a little message to the user.

If you look at the message for current number string, if I go up real fast,

message for current number, it’s just an arrow. So the user’s going to see an arrow and then

So the user is going to see an arrow and then their current number, I guess of the loop’s

current number.

And then every time it loops, it’s just going to continue printing that arrow with a number

on it.

So we’re doing that.

And then we’re going to say R13, which is the current counter variable, which started

at zero is going to get loaded into RDI, which if you watched my other videos, it’s just

the first integer argument for a function call.

So I’m just going to call this other function here, which is not part of the video to just

which is not part of the video to just say hey please print this number for me so the first

time this iterates it’s going to print zero because it’s going to print r13 and then it’s

going to print a new line so that the cursor goes to the next you know line of the terminal

so that’s all the body does it just kind of like prints the current number with an arrow and does

a new line and then at the very bottom of the loop body we just sort of maintain the for loop this is

for loop this is going to be the update part so like let’s see maybe scooch this up a little bit

the update part where we have let’s see on the very right side of the for loop which is like i

plus plus or in more assembly speak increasing the counter variable so i’m just going to increase r13

and then that way the loop can progress you know we’re always looking at r13

to decide if we need to stop or not you know we’re comparing r13 to r12

So we’re just increasing at the very bottom of the loop and then we unconditionally jump back up to the top.

Probably a better idea to unconditionally jump back up to the top because maybe the jump to the top is very very far and if it’s greater than 128 bytes it won’t work.

So the regular jump instruction doesn’t have that limitation. So now we’re jumping up to the loop top.

So you can imagine now that you know we’re not going to the initialization part. That would be bad.

We’re just jumping up to the top here where we immediately ask you know are we done?

If we’re not done, we jump into the loop body and print another number.

And then at the very bottom of the body, we say, all right, increase the counter and then jump back up to the top.

So this is a simple for loop, but you can see what it’s doing, right?

It’s just going to be printing a number over and over again as the number increases.

And then eventually it’ll stop when it hits the correct number.

The last thing we need is the loop done label.

If you look back up at the top here on line 92, if R13 was not less than R12,

less than r12 then execution would fall through to line 92 and there is our unconditional jump

instruction basically saying if r13 is not less than r12 then we’ll jump to the loop done label

which means we’re just totally finished with this loop so we have to make that real fast

and all it’s going to do is just basically say goodbye it’s just going to print a message to

to the restoration functions.

Oh, did I ruin my return somewhere?

Uh-oh, what did I do wrong?

I lost my return statement.

Did I accidentally delete that somehow?

That’s a bad program.

Or did I not even…

Hmm, I wonder if it like…

I wonder if I didn’t have my return statement

and it fell through into the CRLF function

and then the CRLF function returned to the caller

to the caller on behalf of the for test function I don’t even know only all only

the spirits know at this point I don’t know leave a comment or something if

you know what happened but every function has to have its own return for

sure so you know the loop done label is usually where you want to jump to when

you know the for loop is finished or the while loop is finished when it comes to

saying goodbye it probably would be a little bit more clear of me to add an

you know for test you know say goodbye just so that I that I remember that this

is this is the place where we’re done and this other place this is just

something else that’s happening maybe I’m doing more instructions or more

operations or calling a function or whatever so obviously if I did it this

way then the loop done label would just end up falling through to the goodbye

label and it would be fine but it’s just more visually clear I’m gonna take it

Anyway, so at this point we might have a program that actually works.

Let’s see if it does.

What else do I need to add?

No, I think we’re done with that.

Okay, let’s try it.

So we’ll do a make run and we’ll enter the number five and let’s see if it works or it

crashes.

It worked on the first try.

So I had a solution though.

Not fair, but I could have typoed.

Anyway, so it says we entered a five, the loop will print from zero to N minus one.

print from zero to n minus one so we should see from zero to four and so then every iteration of

the loop it’s just that little message we’re just printing a zero printing one printing a two you

know the number increases because we did did that little inc instruction the increase instruction

we unconditionally jump to the top of the loop where we decide if we’re supposed to uh finish

you know be done with the loop by jumping to the done label eventually after we uh let’s see

it prints this four here it’ll do the increase instruction at the bottom of the loop’s body

and then it’ll jump to the loop’s top then the loop’s top will see that it’s a five because we

just increased the four it will see that five is definitely not less than five so that’s a false

which means execution will you know fall through where the heck is that it’ll fall through to the

line 92 jump instruction which is just the loop being done so that’s here where it says goodbye

says goodbye and then we have successfully implemented a basic for loop

all right so thank you so much for watching this video I hope you learned

a little bit and had a little bit of fun I will see you in the next video happy

coding and happy studying hey everybody thanks for watching this video again

from the bottom of my heart I really appreciate it I do hope you did learn

hope you did learn something and have some fun. If you could do me a please, a small little favor,

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

current social media website that you’re looking at right now. It would really mean the world to

me and it’ll help make more videos and grow this community. So we’ll be able to do more videos,

longer videos, better videos, or just I’ll be able to keep making videos in general. So please

and subscribe. You know sometimes I’m sleeping in the middle of the night and I just wake up because

I know somebody subscribed or followed. It just wakes me up and I get filled with joy. That’s

exactly what happens every single time. So you could do it as a nice favor to me or you could

you could troll me if you want to just wake me up in the middle of the night just subscribe

and then I’ll just wake up. I promise that’s what will happen. Also if you look at the middle of the

screen right now you should see a QR code which you can scan in order to go to the website which

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 clarifications or errata or just future videos

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

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

I wake up in a cold sweat and I’m like,

it would really mean the world to me.

I would really appreciate it.

So again, thank you so much for watching this video

and enjoy the cool music as I fade into the darkness,

which is coming for us all.

Thank you.

The post x86-64 Assembly For Loops Explained – YASM Tutorial appeared first on NeuralLantern.com.