Live coding a bootable 6502 processor simulator in x86 assembly: LDX with all addressing modes

hey what's going on guys coming against the year welcome to this live coding session where i'm writing a 6502 processor simulator absolutely from scratch uh in x86 assembly language so currently i have the ld instructions instruction being implemented for all the addressing modes available and also i have a bunch of unit tests here to test every single addressing mode and separate and just to give you an idea of how this works i'll show this for uh the very first uh immediate addressing mode i've been showing the previous ones in the previous videos so nothing really new here so the idea is uh the following so we have the addressing mode so instruction then this immediate value so we have the machine codes uh so this is the up code for immediate addressing mode the value to load here we get this value being loaded um flags has not the flags has been affected here so initially we have this kind of value for flags right and we do reset the flag for uh the negative flag because this uh value doesn't have the most significant bit been equal to one it's it's not it's zero it would be if it was like eight not eighty four ninety four f four e four so if the first bit is set in that case would be the negative black bean set so we do reset the flags as well so all i check for is whether the value has been loaded correctly whether the flags has been adjusted properly and whether the program counter has been ingested by the number of bytes that we need to walk through so in case for let's say absolute addressing that would have been three bytes so but uh as far as we're going to be doing this for the the rest of instructions from now on uh starting from ldx i believe then we're gonna be walking through this process and reusing the task go from from here so this file is not is not the part of the project it just i've dumped all of the tests here so we're gonna we're just gonna be altering them slightly a little bit and then just providing this um a new task set okay so here we have the test set for lda and then we're going to be dumping them here well potentially probably would it be possible to run all the tasks for all the instructions but that takes enormous amount of memory to be honest and don't really want that so but now it's okay to just to run all this all the tasks for a single instruction and i have 10 tests for a single instruction so for all the dressing modes and a couple more tasks in the beginning to make sure that the flags are working properly but i believe i don't need this any longer so i can just have the only test for immediate mode as well okay so uh let me uh yeah i will probably leave this test to to alter it for ldx instruction all right so here in uh in the execute i have a a very big this would be a big equivalent of the switch case statement if this was a written c programming language so depending on what kind of opcode we have so these are the op codes without the values for like the labels for up codes or to be replaced with the up codes and we you see like we're handling the ld immediate lda zero page lda zero page and x offset ld absolute and the absolute x offset absolute y object uh index indirect and indirect index for lda so let's have a look uh what's the next so here i have the upper case uh letters for those i didn't yet process and lowercase for those i have processed already and yeah probably the only thing that i've taken from someone else's code is are these definitions well organic they were defined in c plus plus i took this from dave pooh who has created his series on emulating 6502 processor uh on youtube so yeah i just i just took this for the values of the up codes from there just to make sure that i'm not messing things up and that's kind of pretty much all about it uh and here uh i have the list of up codes just just to verify just to make sure it's still kind of working nicely and that's pretty much all about it right so let's start our journey so uh the next instruction to implement is ldx immediate value so we want to load the immediate value to [Music] uh x register so i set this to lowercase a because we're now working with this and i grabbed this one and i'm going to execute all right um sort of just getting distracted by my cats walking around here okay so execute right and uh yeah so right over in here so i want to compare real with this value so this is ldx uh immediate dressing yeah immediate address and up code all right and if so i want to jump to ldx uh a i m ldx we don't yet have this label we'll create this just in the moment so [Music] if so then execute it so this is really uh i wasn't preparing for this this is just how i work uh on the real deal right so it's not a tutorial it's just uh a video footage of how cool my game is developing his own exposure simulator right okay so ldx immediate and this is gonna be exactly the same as the lda immediate uh and i have the lda immediate here so uh what i want to do here i just want to grab the entire code i know this goes for lots of duplications which potentially might not be that greatest ever case but this is simple and straightforward and i think this is good enough for me because i don't really want to i'm not looking for saving the code size i'm not not not looking for optimizing the code size i would rather have this application but uh crystal clear distinguishing between every uh next instruction so i could have reused the code from here but i really wanted this i really want this to be like to have a piece of code for a single instruction well if i if it turns out that uh some of the addressing mode contains an error then all the instructions using this addressing mode would be uh bundled together so i would be it would be easy to to change to quickly uh kind of fix this in all the dressing modes but i really hope that i don't have that situation so yeah okay so i'm loading uh ldx so loading single byte a on how's the immediate data to load okay opens the look of the local variables clearing the flags uh this happens every time okay adding the byte two bytes to program counter too yeah this is okay and now i want to move the byte not to the a register but to the x register and that's pretty much all about i believe yeah comparing so if this is zero we set in the zero flag right if this is uh if this contain if the most significant bit is equal to true then we want to set uh then we want to set the negative flag all right and yeah we don't even use it we're not getting anything from memory so this should be fairly enough i believe and now i need to adjust the test case because if i run the code now all right uh it should be uh yeah it still uses the previous uh just loads just loads 24 to a register i don't want this instead i want to load a2 right yes i want a2 so ctrl f test 0 1 uh hold on a sec oh here i just set in the yeah i'm just setting the flags well that might be fine so here i want to have a2 oh thanks man thanks for commenting that's my good old friend octopi okay check out his youtube channel if you didn't do it yeah if you didn't yet do that okay very amazing one all right so here uh ldx and some value okay actually it's not really zero zero it's on the x 24. and yeah by the way i have the some issues in the calc in the commentaries here on the a24 uh yeah and here actually was zero zero and here lda yeah uh all right so this code is equivalent to ldx and 24. uh do i need to change the commentaries i try to make them so i don't need to change the commentaries later on um yeah let's have a look let's have a look so a2 24 all right and we have the value of 24 uh being equal to yeah 224 which is correct it just says register failed because i didn't yet update the uh i didn't yet observe the test so let's just get rid of them so first in the first run what i do um in the first run i just check everything manually so that i know that what the values should be eventually whoa whoa what's not supported oh whoa whoa whoa whoa some uh it says that some instruction is not supported okay hold on a sec okay so it's a bit strange uh so it usually prints this if the instruction is not supported but um i'm just wondering oh hold on a sec just command it out uh yeah all done yeah just was as i was probably pointing just to the wrong place in the memory okay so what do we have here so to a to x register so a2 this is really a2 uh it should be because yeah ldx immediate a2 sorry guys just just want to double check this yeah a2 control f okay so uh the up code okay means to load to x register the value 24 of 24 gets loaded to here okay and it's not a zero hence the hands the zero flag uh okay let's reset it gets reset okay and it's not a negative value so it doesn't have this most significant bit been set up hands it just drops back to the default processor flags value which is 20 hexadecimal okay it seems to be seems to be just fine and it takes and it takes two bytes to increase the program counter by yes it's really similar i'm just double checking myself so it's really similar to what the lda did so the difference is that just a different up code and just loads the data to the different register so this is pretty much all about it so now i just need to uh say here i want to update the test cases so not comparing uh with the a register just says register failed but because it tries to compare the a register but i want to compare the x register and here i want to test x register save and now it should be okay all right so the next thing is the flags so flags should be just fine from the previous case and they are okay and the program counter increased by two which it is so yeah uh i think that we can claim that ldx immediate mode has just been implemented so congratulations great okay yeah congrats on that so we're done with this sort of a thing so now we can jump to the test number two uh and here we're gonna have the test number two uh i just grabbed the second test um uh okay okay so i'm not going to be doing this really i just i will go straight away to to the zero pages um a5 a9 yeah uh fetching the value from the xero page um okay let's just uh grab this test it's gonna be test two instead of test four it's gonna be a task two all right so not jumping anywhere for now um yeah let's just try to run it would fail because it doesn't match but only even fails in the program counter it's interesting uh oh well actually yeah it's quite pretty predictable because the the place of our test is not correct but yeah let me just uh comment out uh most of the parts for now because i want to check everything uh okay so so so so here i brand the program right so what's gonna be what's gonna be the program well i didn't get any uh uh yeah i didn't yet actually implement that so probably it's a little bit so early but anyway so zero page addressing uh machine code and what's the code gopro number range here so here it is okay i will need to alter this this is not the right up code the right of code is a6 a6 save control f test2 a6 and let's have a look okay a6 and it's supposed to be fetching the data from the zero page address zero four okay well no let's actually you know guys uh let's actually uh be sticking to tests first and then for an implementation i think that's just a better way to go so here what i do i'm setting the value at the zero page uh plus four and that would be the value of 45 so let's quickly check if that is going to be the case so and the zero page address four there should be the value of 45 uh but i didn't yet print that so uh monitor memory range rate so look okay so uh so the so uh it's kind of it's the zero pages this e stands for just stands for so don't get fooled by this it's just the matter of the absolute address of where the simulated 652 random access memories live in it starts from address e000 so but from the emulated memory perspective this is address of 000 like the zero page uh the first 256 bytes as deserve page all right so what we've done with this lines we've just initialized the memory and now we have the value of 45 at the zero page uh plus four so zero one two three four and now we want to load this value to the x register right okay so let's print what we have uh so yeah before executing anything so here is the state of the registers so we have 24 uh being loaded to x register from the previous example which is which is okay these are uh the flags which is okay as well so um the program counter yeah just like as it was previously literally this is the previous state and now uh so the next step is to execute this uh yeah so before executing this uh we need to yeah i just need to grab uh this label uh lda instruction lda ldx0 page and go into execute rate um okay and probably not guys uh i just thought that it might be a good idea to separate the instructions so we once we are done with lda i just want to put the separator here so we know that these are the lda related and here starting for ldx okay so uh i want to compare al with and yeah by the way l holds uh the first up code uh the upco for the following operation oh that's clear um and we're saying ldx uh zero page address and up code and if so i want to jump to ldx uh it was lda that p so ldx that so i want to jump to so uh then executed yeah then so uh ldx zero page so let's start by looking for so with this lda immediate okay ldx egg so ld zero page and we just grab this code and here we'll have ldx that repeats addressing mode so l hoses every page to load data from okay so cool uh so it's here i want to set this to x which is okay but i also need to check so well actually actually this guess every page value should be working perfectly for because it doesn't rely on any registers to get their page value against the repeat value yeah it should be working just out of the box i really hope for that so it now actually it should be fairly enough so let's quickly check that out so if i call the execute and print the debugging info after then i expect to have uh expect to have the value of 45 being loaded to x register and the flags should remain the same i believe right let's have a look okay lda is that p redefined yeah i just forgot to uh ldx is that p sort of a page okay and yeah it seems like it's working so we now have the value so a604 right uh we have the value of 45 from zero page uh address four zero four this address it's here is the value within this address the zero page mode 45 goes to x flex do not get affected well but yeah let's try to change the values so it for instance sets the uh just to have a bit different values so it says for instance kind of like um what negative flag for instance so let's try instead of 45 let's try e5 and now it should be e5 and the negative flat being said which it is perfect so uh a is like one zero one zero in binary so this most significant one has been set to true because uh e in binary is one one one zero then five zero one zero one right so yeah seems to be working perfectly well so far okay um so i think we can go further on yeah so far so good it feels it feels really really piece of cake for now yeah let's go and adjust the values so the register value uh should be e5 takes from here which is correct so let's set this to e5 then the flags should be a0 because we do set the negative flag rate because of the e x register so this should be a zero okay um this should be a0 we test the x register hold on a sec uh we have tested the a register and this still was working hold on a sec what the heck is going on um what the heck is going on e5 okay now the extra page yeah it moves to the x register which is correct well this should result in a failure yeah and it does all right uh yeah so i need to chat to compare with the x register okay now it's okay e5 yeah uh i just i've been testing with the run register i didn't even notice the error okay now this and now the program counter fails okay and this should be zero four okay two bytes since the last instruction two more bytes zero four zero four and it should be okay so again um e5 goes to x negative flag gets set program counter increased by two yeah it seems like it seems like everything is okay here okay so let's move to the next to the next test uh this is gonna be test three all right save um and the test so absolutely hold on a sec okay zero page with okay so now things are getting a little bit different guys so yeah not so fast now things are getting a little bit different so if we have a look at the ldx uh thanks man okay uh let's go to ldx [Music] so we've covered the immediate a2 a6 uh a6 a2 okay so ldx immediate zero page now it doesn't have um yeah it doesn't have the zero page x instead it has the zero page uh plus y so unlikely the lda which had the zero page plus x and it but we didn't have zero page plus y which is interesting yeah so only plus x but here on the country we have zero page plus y so we need to build a test case for this and also not forget to uh implement this uh addressing mode as well so this is gonna be just like uh zero page and x but instead of adding the offset of x we're gonna be adding the offset of y okay so we can use this example as the basics this one um copy and we'll now start paste we'll now start reworking it so this is test three not going anywhere we'll actually scan out everything yeah a bit of a code monkey job but what would you expect from cool monkey king range all right so uh i want to say ldx uh whatever we have and the zero page of okay so was it it was initializing the next one so and here plus y offset okay so uh the very first thing to consider is [Music] ldx zero page yb6 uh and i grab this one copy and b6 uh okay um [Music] v6 so this is the test program okay now to the register y i want to put the value of one that would be serving as the offset so you need offset of one in y register now the test program label um [Music] yeah now it's a little bit uh [Music] wrong for having the zero page plus x actually this is going to be zero page plus y so this is another ish here so zero page y and we'll just add one more here so it doesn't matter really but zero page and y so this is only uh ldx specific but yeah and test 003 okay [Music] so let's see what we got okay is there a page y addressing which is correct i'm sorry [Music] okay and let's bring the program okay so b604 so we want to have uh zero page of zero four and plus the y offset zero page of zero four yes so far so good okay now uh we're gonna be initializing the value next after uh zero page four so now in this case plus five okay so we had plus four here for initial value in here plus five and we just uh put the value whatever value there it doesn't matter f8 in our case okay and also we want to print that so let's have a look now we should have two values uh okay so e5 this was from the previous example and now f8 so f8 is going to be the value we're going to be loading into the x register and the zero page address of four plus one uh which is the offset for the y register so let's have a look so so far uh i had to initialize y register to one already so let's quickly check that out okay and yeah we have this one in zero one in the y register which would be serving as an offset okay good so now it's time to implement the instruction itself so let's go to execute um here down below so compare real with zero page y so ldx [Music] page plus y offset up code if so then execute it so jump equals to ldx0 page y okay if so then execute it okay now things are getting interesting so uh ldx or page one so i want to find the lda zero page x and here uh i'll make copy page paste this is going to be ldx uh zero page why hold it a sec did i ld uh ldx zero page y like this yeah ldx then page y ld a0 page x ldx ldx0 page y so this is going to be ldx 0 page plus y offset addressing mode uh and it should be all the same but we want to add so we do get uh let me get a room data program counter so to al uh yeah so a l at this point holds the value of h from the memory the next byte after the up code which is 0 4 and i want to add the offset of y now it gets 0 5 now and then i want just to get the value from the zero page and al already holds that address so yeah this should be fairly enough um this should be fairly enough so let's see if this actually works so executing and see the output okay um i'm sorry just got to sleep for a while uh okay so hold on a sec we have this value but in the run register we have this in a register we should have this in x register so that's the first issue um ldx 0 page y yeah so 1 2 load to x register so i'm adding the y register as an offset but i want to load the value the eventual value that gets stored into al after calling this routine to x register now we have f8 in x register which is correct and this f8 comes from here so we have zero page plus y offset op code so zero page is four so zero one two three four so this is the value of zero page four but we do we add y so it's four plus one it's going to be five now there are page points here so there are one two three four five and the value here is f eight and this value gets stored to the x register rate this should be just okay uh the flags has not been changed because f still has the most significant bit being turned to true and uh the flags are not getting affected well actually they do get reset under the hood but then it sets the negative flag again so this is correct um the stack pointer didn't change and it only took doesn't really take too bad yeah it took takes two bytes uh just to double check this it takes two bytes yeah only absolute takes three bytes yeah so it takes two bytes which is correct right so yeah i think that from now on we can go and fit the test cases so uh the value at the register racks test the x register uh should be equal to actually it's already equal to f8 because i reused the example rate [Music] okay so f8 uh so it doesn't stand here right okay then now it starts on the flag oh no it doesn't stack on the flag flank is still still flat fine just text on the program counter as always or is it yes fail so 0 6 should be zero six okay yeah okay zero six well seems like it seems like everything is now okay okay so i think we can move further on from here okay so um yeah the next the next dressing mode so yeah thankfully uh ldx doesn't have the indirect address in so the absolute should be trivial and three bytes okay and absolute with a y offset which is the same like lda with a y offset should be the case okay so the ldax absolute um yeah let's go and go and grab the test case for that so the next test would be test for save so yeah this one this one [Music] okay now things are gonna be a little bit different but still hopefully working all right so just comment out everything at first yeah what i'm doing things like this uh i really feel like it would be something easier to do in the vim editor which i've been using for quite a bit of time but yeah i'm not using this all of the time okay so um the next test uh we want to initialize so what was i doing what i've been doing here the test program okay so yeah probably let's kick start with the up code [Music] so we've covered this one okay now ldx absolute address and so a e a e okay grab this one a e [Music] okay so this is our program uh and this is the address we're gonna be writing uh the value to right yes uh loading the test program so this debugging strength should be still on the cards and we should see our program being printed screen so instruction absolute addressing mode uh machine codes a e yeah in the little andy and this is zero four zero one and the absolute address in big endian is zero one zero four all right uh so far so good so the next thing is to at this memory address we do set up a value right which is correct uh this is going to be ldx okay all right and let's bring the memory um didn't do much sorry yeah like this now it should run the value yeah so we've stored seven to three at uh you can ignore this e so from the six to emulate the memory perspective this would be 0 1 0 1 2 3 4. so 0 1 0 4 right and this here we have the value of hexadecimal 73 so we're going to be uh loading this value to the x register from the absolute address okay so let's have a look at the state of the register is just right from the previous from the previous iteration sorry just clean up my mouse a little bit it doesn't slide that well on the table sorry okay um uh yeah so f8 goes from the previous so now it should be loading the value of 73 to x register okay now let's implement uh let's implement this one so compare al with uh instruction ljx absolute addressing mode uh so this is ldx absolute addressing up code right jump equals to ldx abs rate just like lda abs yeah so if so then executed okay um all right so ldax absolute absolute uh yeah so right here copy and paste so this is going to be ldx absolute so ldx absolute and the logic should be all the same so adjusting the program counter by three because we have three uh bytes uh being involved in order to represent this instruction so one byte is up code and two bytes the absolute address and here we want to load the uh data to the x register this should be fairly enough really save let's have a look uh yeah we can't see anything because we didn't get call execute so execute and let's see what we have after what we have after okay so 73 from the absolute address of 0104 gets stored to the x register which seems to be correct uh it does reset the flags because uh seven has the zero as the most significant bit right uh it's ins and it's not zero hence the zero flag is not affected so just uh strip the negative flag zero it's not affected okay um yeah and the program counter increased by three so this should be this should be this should be fairly correct so at the value of 73 still match uh the flag should match as well so it's really handy to reuse this test cases however if there is a bug somewhere yet it's gonna be very horrible because uh everywhere would be cure in the same bug but let's hope for the best really um register what the heck is register fail let's because i'm comparing with again like i don't even see that i don't even see those uh labels for some reasons i obviously want to compare with the x register okay next register 73 goes here all right and the flags are okay and the program counter would now fail but um it would now fail but uh 0 9 should be 0 9. and all done okay so double check ourselves so zero one zero four uh is the absolute address so uh yeah just uh yeah zero one two three four so no offsets for now okay um no offsets for now yeah i guess that's the next this would be set in the value after so yeah that's okay all right so um yeah uh 73 flex adjusted program counter didn't touch the stack really okay so that should be okay this should be just okay okay great so what's the next one uh so we've just covered the absolute for ldx well yeah uh we'll probably go for this absolute y and we just drop there and the next live coding session will cover the ldy so um absolute y is just like the zero page y about using the absolute address and this should be similar to absolute x for lda but instead of adding the x we're going to be adding the y all right so the the up code is b e all right but just want to watch that okay um yeah let's so uh i want is this the case by the way lda and the x yeah this is the proper test case so i can grab this test case um i can grab this test case so copy jump to [Music] test five test five here we have task number five hopefully the last one yeah definitely the last one for this uh [Music] yeah not the most exciting part of the video but if i do copy paste my own code at feral list i'm going to make sure i'm doing this properly right so um so here ldx and the y offset okay i remember this was b e and let's set b e and grab this one and test zero zero five okay so we'll start by yeah setting up so yeah the code would be almost the same uh but we're going to be using the offset okay so move test program uh [Music] okay now here uh another then so test uh a ps absolute y and we need to find test absolute hold on a sack why do i have this um [Music] i should have the previous for the zero pages it didn't didn't i oh yeah and now i'm already getting lost here okay so uh okay let's have a look so what was before the absolute dressing mode yeah there was a uh it's a minor issue which doesn't oh hold on a sec guys i probably probably uh yeah i guess i've done this intentionally before to avoid doing this in the future so there should be zero page y and zero page oh okay yeah so we have the repeat is our paycheck so page y yeah i just preserved this uh earlier yeah totally forgot okay um in this case uh this should print this stuff already and let's have a look at the circus so b e okay and so it's pretty similar to the the previous one but the up code is different which means that we're going to be adding the whatever we have in the y register to this absolute address okay um this is good this is good so just don't need this anymore uh ldx okay now yeah what i've been expecting previously so we're loading the value of 92 to the next one to the next memory so now see how this looks um yeah so now we have this 92 after 73 and we're going to be fetching this 92 using the subcode this address and plus one which would be stored in the y register okay so let's see what we currently have in the y register uh if there is one already then just okay if not yeah we already have one in y register from the previous zero page uh plus y offset addressing mode so yeah we don't need to re-initialize it okay good so now let's go and implement this addressing mode so [Music] um compare ao ldx absolute y so is this the ldx absolute addressing absolute address and plus y offset up code okay is it and if it is i want jump equals to ldx abs y so this was lda abs x and here is ldx absy so if so if so then execute it yeah great so now we need to implement this ldx absy so we're going down looking for lda absx and this is going to be serving as the template so here we want ldx absolute address and plus here uh l d x abs y okay holds the value okay so far so good so we add the value from register y and we load to the register rex and the rest should be working the same so get an absolute value should be working the same so just uh altering uh from where to add the offset and where to load the result okay guys uh yeah we're pretty close to the end of this kind of ldx addressing mode implementation let's have a look uh okay so it loads 92 to x register which is correct uh it sets the flag says the negative flag because 9 has the most significant bit equal to 1 or true and it should add three um [Music] nine a b c yeah add in three bytes to the program counter one two three yeah should be should be okay as well okay great so is it uh was nine plus one a plus two b yeah plus three c okay so this seems to be just what we're supposed to be having here okay so zero one zero four zero one zero zero zero one zero two the zero three zero four plus one in the y and we have zero one zero five so fetch the data from so we are fetching this 92 and put this to the x register yeah everything seems to be working properly so uh we test the x register it has the x register should be equal to 92 okay [Music] and we don't need any tests as well uh yeah all but the program counter should be working so 0c okay and one more test so 95 92 goes to x 0 1 in y uh processor flags negative flag being said because 9 okay and the program counter has been adjusted yeah guys this seems to be like uh it seems like we have just uh successfully implemented all the dressing modes for the ldx for ldx instruction rate and the next thing to consider would be to cover ldy all right okay and once i have i believe once i have well ldy is not essential for that sort of purposes i just just want to recall what i what kind of order i have here so we have lda ldx ldy and then sta okay sdx and uh we we even have less instructions to handle for set x so only zero page zero page and y offset oh we don't have the immediate near and absolute and absolute does not go in with hold on a sack uh maybe they've just didn't implement those addressing modes i'm just wondering because i've grabbed this up cause from there so does it does it really have only sdx sdy only three interesting modes i can't believe my eyes hold on guys just really want to check this out probably just has some incomplete information there i'm just wondering so let's say sda uh oh really to zero page okay so yeah sta can be yeah using this this fancy offset for sda but for stx and sty it's really only only three addressing modes per instruction this is so cool yeah that what that's why i like that's why i love 6502 architecture because it's very simple okay so yeah no here it's all working properly okay so all the correct number of instructions to consider yeah and i just want to say that once we have uh all the load and all the set instructions being implemented we can try to play around with the input and output and bearing with the fact that i'm getting getting inspired by the apple one computer i'm gonna mimic the way how the input and output was done there for ultimately ultimately i want to have the comfortability for at least partial accountability for the programs written for apple one including the monitor the hex monitor which is the building into apple one rom but at very less i want to be able to print strings um yeah using so to print the string i only need to load the value to the accumulator and set it to the absolute address so literally that's enough to print the strings so yeah uh and for keyboard input and for user input that's yeah so load and save should be enough to play around with the io with the input and output and we will already be able to run a very very simple uh trivial programs written in six five or two machine codes well definitely currently the simulator doesn't do handle the input and output so if you write the address to the specific byte in the memory nothing happens really so i need to implement that uh that additionally which is going to be interesting but just yeah i think yeah just just to motivate um motivate myself a bit more that might be on the cards okay guys yeah uh thanks for watching i think this is it for this session uh and in the next live coding session we're gonna implement the ldy instructions well if my wife is not gonna be cooking and if i just be able to record that video okay guys so this is from my site thanks for watching until the next time and take care

Channel: Code Monkey King

Views: 24

Rating: 5 out of 5

Keywords:

Id: DR955qPdvGM

Length: 65min 45sec (3945 seconds)

Published: Tue Oct 05 2021