So, this bit's being added in post. During editing I discovered that there was a small problem with my microphone and all my audio sounded like this. And that is just not right. I did manage to fix it to a certain extent using audio processing, but it's still not great. Apologies for the poor audio quality. And now, back to our main feature. So last time I got to the point of getting the calibration tool running, but then ran into lots of issues with crashes and weird things with the multiplication and so on. I think I've managed to sort those out. I've switched to a different libc, this is libc mini. This produces TOS binaries which are much smaller than the ones at the min-tool chain was producing by like a factor of 10. These do seem to run. I've also discovered an issue where emuTOS gets confused if there are long file name files on the SD card, so removing those has made things better. I think what I was seeing last time was it was failing to load binaries properly due to this issue, which was why I was getting the crashes. And with that done, I managed to fix another bunch of things, one of which was the fact that the actual calibration coefficients are long, 32-bit wide. The coordinates we get from the touchscreen are 16 bits, so this multiplication was overflowing and causing bad things to happen. The solution there is that since the values we get out of the touchscreen are 12 bits, but we're actually reading 16, we just drop the bottom 4 bits and that keeps everything in range. So now I can actually show you if I do ctrl-z and run the calibration routine. This is now dumping, it's full of debug information, but these are the calibration coefficients. This is what the kernel is seeing, this is what the calibration tool is seeing, so the data is actually making it through intact. So exit back to gem and you should be able to see the last pointer moving with stylus. Unfortunately, if we move towards the edge of the screen, you may notice that it drifts away from the stylus somewhat and starts moving rather glitchily. Notice it's going diagonally even though I'm moving the pen up and down, and likewise if you go over to the left, that movement is not right. If you look over at the console here, x and y are the raw values from the touchscreen shifted right by 4 bits. So you can see that these correspond directly to the voltage, so you can see it increases going left, x, up to about 1200, and then it starts dropping back again. And that is just not right. So the screen appears to be somewhat non-linear. In the middle of the screen it's more or less alright, like I can open menus and things, so that's nice with a certain amount of difficulty, and I'm trying to get down to the bottom screen is hard, so I can't actually click on the cancel button, it just doesn't go down, go that far down, so I have to press return a bit. However, anything on the left is not working, and anything on the right is not working, and you may notice that if I touch repeatedly, the pointer is jittering around quite a lot. So if you remember looking at the decompiled touchscreen code from the Palmer Throm, there was a lot of logic in there, and I think that was all due to smoothing the touchscreen in order to get reasonably accurate touches. I could certainly take multiple samples and average them together, that's not very difficult. But I'm more worried about the left and right side. You see, if I throw the switch in the keyboard to reset, this then boots up Palmer's. So then we go to the Palmer's calibration, which is the same as my calibration, it uses different targets. So here, here, here. Oh look, it's asking for the top left target again, and again. So it does eventually accept it. So I've actually been trying for several minutes to make that work, and not. So it's not behaving at the moment. This used to work. I think I have managed to somehow damage the touchscreen, probably by disassembling things. I have taken it apart and put it back together again, trying to reseat everything. And it's still not behaving. I did manage to make it skip the calibration at one point, but I can't remember how you had to reset it at the right moment. So that's a bit of a problem. Yeah, okay, it has now skipped the calibration, but of course the pen won't work, because it doesn't know how to map the coordinate. So this touchscreen code here, I mean there's some stuff I could do with it. I could take like three samples and average them that might help. But it's not going to do anything with the non-linearity of the screen. So I am not really sure what else I can do with this. Let's actually just do that. So let's take eight samples and this is going to simply be like so. And let's give that a try and see what it does. If the middle of the screen works reasonably well, then it should at least be usable. So let's go back again. The switch, just see there, controls the line that tells the 6-8, 3-2-8, whether to boot into debug mode or to do a normal palm off boot. That's not working. There we go. Just a small loose wire problem. But let's see if this works and then I'm going to call the touchscreen driver done. It needs work. I'm not sure what work remains to be done there. I would like somebody with a different device to test it, to see whether it's actually a problem with my screen or not.  I hope that I haven't damaged the screen by miscontrolling it. That shouldn't be possible, really. I mean, if I have to configure the touchscreen controller for things like voltages and I'm using the wrong ones, it's possible, but very unlikely. But anyway, let's see how this goes. And then there is only one remaining piece of work needing to be done. And I can call the first alpha of this finished. So let's get on to that and I'm just trying to fill time while the download happens. OK, I've turned the backlight on because it makes things easier to see. So what was I called it? Dana-Cal. So now how does the mouse button really use the answer? It's smoother. It's not really smoother. That's glitching about horribly all over the place. It occurs to me that if the pen has come up while taking out eight samples, the values we're getting back are going to be garbage and are so going to pull off the position. So I think we want to do. So if... Let's try that. So what we're doing is we're sampling the pen down line before and after taking our coordinates. And only if the pen is down both times do we trust the sample we're getting. So that if the pen comes up while doing a sample, we ignore it. Yeah, let's try that. I have in fact done a bit of refactoring so that the sampling code is now in raw read, which should help a bit. Let's see what this does. OK, well, judging by the way that the printer icon bottom right has been selected, I don't think that smoothies working well as I would hope it won't. It's pretty jerky, but the main reason for that is all the tracing that's being produced. That's interesting. That has in fact just read fire. So these values are actually the addresses of the state variables, not the result. So let's just put this here instead. So the x equals y equals is actually coming from here. x and y are the values that we've fetched. And sx and sy are the screen coordinates. I mean, these are clearly wrong. That means that the pen is up. So OK, if the pen comes up before any of the samples, then it will return 0 and 0, and the state will be not pressed. So let us do this. So we check to see if the pointer is down. If it is, we try to do a sample. This will then return whether the pointer is whether the pen is still down afterwards. So that will tell us whether the sample we've just read is valid. OK, so let's try calibrating. Why is the raw read not now returning then down? It is possible that this is actually connected to the touchscreen chip's interrupt line. So this may not be returning whether the pen is down. It may be returning whether the data is pending. It's not the same thing. It's not that one. This one, this is the datasheet. So the output pin is pen IRQ, pen interrupt. Pen output is connected to the Wiper input. When the panel is touched, the pen IRQ output goes low. During the measurement cycles, the output diagram will be internally connected to the ground, and the Wiper is disconnected. And that's power download. So as far as I can tell, pen IRQ will be low while sampling or when the panel is touched and high otherwise. So that should work as far as I'm aware. So have I got something wrong here? State here is the U word. This would want to be this. Actually, we'll put this here. We know what the problem was. I think I know what the problem was. No, that was not the problem. So what I was thinking of is that bools and words are not necessarily equivalent, depending on the version of C. If it's a real bool, then values will be coerced to 0 or 1 when they're assigned. If it's just an int, and of course state here is now a pointer to a word, then it won't be. So this will return either. This thing will return either 0 or 2. Not will then produce either 1 or 0. Yeah, yeah, I'm getting this confused with complement, which is wrong. So yeah, that should work. Interesting. So let's run that again, shall we? State is always 0 being returned from the, well, then we get the 0. I do not think that this line is behaving the way I think it's behaving. Given that we seem to be getting, we're not getting 0s from as samples, if depends up. We're getting 0s because this condition is failing, and it's not actually reading anything. And so the initial values here are applied. I'm just going to deploy this. But I think what's happening is that we're reading the, is that doing the read is somehow causing state to go high. So it thinks it's not pressed. OK, so we run it, shall we? That's as far as the next one. OK, that does seem to be behaving now. And we're not getting, it's still a bit jittery. It's still quite a lot jittery, actually. But it's not highlighting the printer icon anymore. Yes, we still have terrible results that are right inside the screen. Moderately bad results in the center. And the left-hand side of the screen is garbage. Fabulous. Well, I think that's better, so let's just stick with it. I'll just turn off the, so not that tracing. I do want to turn off this, and I'll try that again without tracing at all just to make sure it behaves the same way. OK, I'm hoping the mouse point will be a bit smoother now. Calibrates, yes, it's smoother. Not very well calibrated, I have to say. This is probably due to a glitchy press when I actually did the calibration. The calibration tool could probably be enhanced to be more outputty. Try that, yeah, that's better. You see, this bit is all right. Going up and down, it goes sideways hugely. Anyway, I think that's fine. It's not very happy, but there we go. All right, well, this takes us on to the other part, and I shall just tie this thing back up in Parmos. The other thing, the last thing remaining to do is I don't really want people to have to rig up a development board like this and solder stuff onto their device in order to run Emutos. So I'm going to try and do some Parmos programming and try and write a very simple tool that will load the Emutos kernel from the SD card and run it. So believe that resetting here will take it to the... We'll skip the calibration. No, that takes us straight into the calibration. Hey, it calibrated. That's a stroke of luck. Good, well. So I have here Hello World in Parmos code. No, that's Hello World in VDI code. Here is Hello World in Parmos code. So we run it with or we compile it with Parmos GCC minus C minus OS minus G Hello dot C. That does the actual compilation. We then need to turn the object file into a resource file. Let me go and look this up, shall I? OK, here it is. I did actually have the right command line. This wants minus O Hello. This wants, ah, I need an executable. So no minus C. Right. That then turns this executable into a resource file. I'm not quite sure what a resource file looks like. Hello dot Gruck. But then we run build.prook here that reads that in. Right, these are the resource files created for which there is a number. Build.prook then reads these, and it turns it into a Parmos Prook file, which is one of these. And we then put this onto the SD card in the right place. So mount the SD card. We then need to create the directory structure needed that's annoying. And then we copy the Prook file into the launcher directory. Then we unmount it. And then when we insert the card into the machine, it should use an error message. So it's supposed to understand DOS file systems on SD cards. But this has been configured for the emu DOS. It's possible that Parmos doesn't like it. But Parmos does appear a little bit flaky. Let's try the other card slot. Fantastic. Well that's a lot of help. I'm going to have to figure out how to produce a card that both emu DOS and Parmos understand. That's going to be annoying. I'll be back in a moment. Okay it took a while, but here we go. There is our hello application. So if I run it, there it says hello world, which is good. So what I eventually did is the emu DOS card is in the right hand slot. And the emu DOS card, and that's the Parmos card. Because of course this machine has two card slots. That's nice. So we are now running code in Parmos. So let's try and turn this into something a bit more useful. So let's copy this into tool. We can call this data run.c. This is going to be really, really hacky so that we don't actually need a event loop or anything. What we're going to do is attempt to open a file on the SD card, which will contain our ROM image, load it into memory, and then run it. So I am going to go and have to have a look at the Parmos. Actually I've got the Parm SDK here. So version of Parmos we have probably four. So in here there should be some file handling code. This looks plausible. Probably don't want Parm compatibility.h. Yeah, I'm actually going to have to go and look this up I think. Interesting that these do not actually need to be defined anywhere. Possibly the years. I wonder if there's stuff missing. Okay, I am going to go and look this up. So I found this PDF of the Parmos 5 API, and there's a nice set of BFS functions. So I think the one we want is the FS file opened. This takes the volume reference number. So we're going to have to call this to enumerate the volumes. We're going to try and look for our kernel every volume, because that means that we can put it on in either card slot. So the FS volume enumerates a pointer to the reference number, pointer to the variable that holds the index. Ah, example code, perfect. U, okay. Let's use the Parmos types I suppose. U in 16, volume reference number. U in 32, volume iterator starts at the FS iterator starts. And then we have a loop. While VI is not equal to the FS iterator. Dot equals pfs volume enumerate volume reference, volume iterator is not equal to none. Okay, so if we get here, then we have a valid volume. So let's go to the FS file open, taking the volume reference path, the open mode is one of these, and we want the FS mode read, and that's all we need. Back to here, and we want a return file ref. So if E, hang on, we have enumerate gone, this is the wrong sense here. So if E equals power none, as it's found a kernel.image file, then we are going to try to load it. So first we want to figure out how big the file is. So E equals bfs file size, file reference followed by 52, followed by the size. If E is none, that succeeds. Actually if it doesn't succeed, we're going to fail. When we fail, we are going to close our file, and the only reason that this would fail is if the file was unreadable, at which point we want to loop round, or to close the temporary file reference, loop round to the next volume. So we should here now have a correct size.  Right, I was going to say that we would use this to allocate the size of our size block of memory, but it looks like we can't, because there's a limit of 64k for a block. Um, is there a way to get more memory than this? I don't think this is it, that's not relevant. Okay, this is a little bit of a problem, because if we can't allocate enough memory for, to put our kernel in, then we can't load it. It's got to be contiguous memory block. I wonder if we're allowed to use large chunks of bss, so could we just do, computing uint8 is correct. So 256k, so we can compile this with dena run to dena run, integer overflow. That makes me think that these are using 16 bit ints, which is, yeah, it looks like our bss can only be 64k. That's a bit annoying. Okay, more research is required, I think. Okay, so this is actually a little bit more interesting than I was really expecting. There seems to be no way to allocate large chunks of memory. So I'm going to have to work with, uh, it says maximum size of a memory allocation is a bit under 64k, so let's work with 32k. So block size is 32.24. Now we are going to need to allocate enough blocks to load our file, and then read the file into these blocks one at a time. Then, once we've finished with parmos, return interrupts of, so that now none of the parmos code is executing, and then we have to reassemble this all of our blocks into one contiguous chunk and jump to the beginning of it. Luckily, I've already done the work so that the ROMs are position independent code. So what we're going to do is, uh, so for, so let's say the biggest kernel can be 300k, say. So that will be, we will need this many blocks. So we now know how big the file is. So let's calculate the number of blocks, that can be a unit 16. We are now going to allocate them. Okay, there's this compile, that's the unit 8, par 0, unit 4 block, unit 16 is a time. Wait, this compiler doesn't know C99? Yikes, okay, that was a shock. It's not going to be unfailable either. Okay, um, inflicted 2, actually blocks 5. Okay, so the crypt value is neither a rain or pointer. Uh, okay. Now, we are actually going to sort our list of blocks by pointer so that they are in ascending order. This will make it easier to reassemble them again later. So the size of, I don't know, the number of members is lock count. The size of each member is that, and the comparator is comparator cb. Now I'm not sure yet where the parmos has a, has a Q sort, but 1, 0.2. The first element is less than 10 minus 1. It's greater than return 1, otherwise return 0. Okay, no Q sort. Do we have a sort? I also found this, which is palmloader.c. It's the UC Linux loader for starting UC Linux on palm devices. However, this works rather differently than my code. So cursors, I cannot see a sort in the index anywhere. Ah, sysq sort. Excellent. Let's go here. Starting arg for from, that's the comparator. This was to be in 16. You are not const. Excellent. Okay, well that will sort the blocks into ascending order. We can now go through and actually read the data, vss file read, number of notes to read, point of destination, block, okay. So this would be vss file read, parreference, block size, blocks, pi, and we don't care about the number of bytes read, that still builds. Right, so at this point we now have our entire file in memory. We want to reassemble it into a continuous block. Now it is possible that our code here that we're running from is actually between two of the blocks. So we can't just overwrite random stuff because we might overwrite the code we're actually running. So what's a good way to do this? We could have a piece of position independent code do the work, which we copy into one of our allocated blocks, the allocated extra block. That way we know that we won't be overwriting it. Because of course, our blocks are now in numerical order so that we know that between blocks zero and blocks however big our kernel is, there will be at least that much memory. So how do we do this? I think we're going to need some position independent code. We're also going to, however this code will need access to our array of blocks which again might be between the two of these. So yeah, we are going to need to do that. Can I file this? No we can't. So we're going to have to write machine code manually. Okay, so if we do that, that means that we'll allocate one extra block. This is going to contain our actual boot code. I wonder if I want to try and load the boot code from a file as well through use of development. Actually trying to write it in here would be tricky. There is inline assembly. Yeah, let's do that. So close the current file, load the new file. At this point we can't really clean up. I mean we could free all blocks but we're pretty much into it's going to work or the system will crash territory. So let's just read in our boot block into the last block. We want to make sure that is included in the sort list. We are going to define a function pointer which is going to be our boot code. Let's assign it to the last block and execute that compile. Oh yeah. And it's taking as parameters the pointer to the list of blocks and the number of blocks. Excellent. So does this what does it look like if we just assemble it? I did do my minus g. So here's our main function which is this, which is quite small. These are where we're calling power mile system calls. Each one is a track followed by the number of the system call you want to call. We are here calling Q sort which I think is this. We are now calling, it's probably the loop here. This is a multiplication by four. These three calls here will be file closed, file open, file read. So after file read we, so this is this file read because it's then got the bottom of the loop in it. So file closed, file open, file read. Oh yeah. And this is our code here. Here is the indirect jump being done. Okay. So I think that code is possibly right. There's nothing resembling tracings. So we won't know if anything goes wrong. And we also need to write this. Let's do a little bit of rearrangement. This needs to be a directory. So move to your run.c run tools on loop.s8 equals to this blocks or equals number of blocks to be for zero equals turn address. So first thing we need to do is turn interrupts off. So that's going to be, we're going to steal the code from here. More wx2700 into sr. Okay, almost now it doesn't get the chance to do anything. We are then going to load what that should be a 32 bit value that pointers to 32 bit value. So denort is the number of blocks. Okay. So we're actually going to want to loop until denort until we've run out of blocks. We're actually going to start at block one. Of course blocks, okay. Let me just back up a little what we're going to do. So we have blocks like zero, one, two, and three with gaps in between. What we're going to do is we're going to copy block one. This would immediately follows block zero. Block two. So it immediately follows the new location of block one, etc. So that way we will end up with all the blocks concatenated together and we know that there will be enough memory for them. And they were not overwriting anything we care about. They're only overwriting like Palmer stuff. So this is going to be the current block we're working with. No, we don't need to do it like that. First, we need to find our destination address. So this is going to be the thing pointed at a zero. So what we are going to do is we need to figure out whether we run out of blocks. So we're going to compare our block number with one. If it is equal to one, then we are finished. We could put this comparison at the end, but if we did that, then we wouldn't be able to support ROMs that were in a single block. We'd always end up copying at least one block. So we now, this plus will cause a zero to be incremented by four as we read it. So it is now pointing. So it is now pointing at the pointer, pointing at the current block. Oh, blast. This isn't going to work because this block address array is going to be in unsafe memory. We could be overwriting it. We're going to have to copy that into safe memory. We know we've got 32k in this in the block that this code lives in. So we can just put it there. That's lots. Okay, so the first thing we need to do is to copy the entire block array. So that will be, let me do that. So DBF is a little bit odd as you need to subtract one from the loop counter. So let's just do it the old fashioned way. So that will be subq1 from d1, grand shift not zero to one. Okay, so this then picks up the address of the first block. Okay, so we should be ready. We now want to compare the entire main loop. We want to pick up the address of the block that we're going to copy. Actually, there's an easy way to do this. So this will write a zero after the list of block pointers. We now no longer need the number of blocks. So all we're going to do is to pick up the new source block if it's zero we've finished. Then we are going to actually do the copying by copy from the source to the destination DBF11 back. Right, that's copied. It has advanced our destination address. So here all we need to do is jump back to the loop. Right, once we have finished we just need to get the first address which is going to be that's the address of the first block. So this is the address of the first array slot which contains the address of the first block. This gets the address of the first block. This jumps to it. So this should be our reassembly code. I think I'm actually going to use the Atari assembler for this as it's rather newer. It doesn't matter. It's going to be creating a simple image like this. 46, jump to 0. Okay, so now let's just assemble it to see whether it looks sensible. I did put that in the wrong directory. Okay, so now let's assemble it. So interrupts off. I'm checking for any absolute address references because of course they will work. Number blocks, block address array, this is program counter relative so that's fine. Okay, it does occur to me that we could turn this into data that then gets embedded into our program here. That would probably be better than having a separate file to be honest. So we are going to want to make danerun.prook which will depend on obj danerun and our command line for community experience. This is the application ID which is a four character identifier. I'm keen on that in this. One of the problems of make, one of the many, many problems of make is trying to deal with rules that generate multiple files. And this is one of them. So let's actually do it like this. Let's take a parmas of res. Doesn't have a destination directory. Okay, cd obj and so this will then spit out all the .grc files which this will then consume. So now all we need to do is do this. Okay, it has compiled the xe but this hasn't found it. Okay, so that has now created a executable which is danerun.prook I believe. All right, so that compiled the program. We now need to compile the loader which we're going to be using this Atari Mint As. All right and we do also need an image and we create this with, I'm actually doing this in the daner code. We're doing it here. So this will be m2k, Atari Mint, LB, obj, pmp, position independent. So I don't think, I do need to tell it that I wanted to generate an output file. So I think I want this. Let's just stick this in to make sure it gets built. Let's see what happens. Okay, we have, what is it? 989 is big. Right, that is in fact generated in Mint Executable which is not what we want. Yeah, this specifies the format of input files. If you want to specify the format output files, there may not be an option for this. Here we go, oformat. Oformat binary. Let's see what that does. That's better. That looks about the right size. It shouldn't matter what the start address is because it's position independent. So we've got 46fc, 46fc, yep. At the bottom we've got 40d0 and then 0 is good. Right, we have built our bootloader. We now want to get it into our Dana Run program. The simplest way of doing that is to use xxd. xsd does a hex dump. We've got an option that will emit a cnt file. So we can do that or we can do that. h depends on palm boot dot image. Okay, so this depends on palm boot dot h. Okay, all right. So here we have our bootloader. This means instead of this code, all we need to do is to copy. Destination is blocks, block count. Source is bootloader. The length is size of bootloader. We can get rid of this. What doesn't it like about that? Maybe, all right, implicit declaration of built-in function, men copy. Let's take a look to see whether there's a system functions. It doesn't look like there's a men copy. So probably we just want to include string.h. And there we go. Okay, so here is our proop file. So to make sure we have a working Dana. Okay, the card is in the slot. So if we copy the Dana run dot proop into mount palm launcher and enu task dot image into mount kernel image. So that will copy. So we insert the card, wait for it to be mounted. You'd have noticed it does not actually appear to be showing the application. Did I remember to change everything? It should be called Dana run. So let's just see whether it actually made it onto the card. No, it didn't, peculiar. So we insert the card, we wait for it to mount. And there is our Dana run program. So we run it and it doesn't work, which honestly I was expecting. Okay, so the next job is to figure out why it doesn't work. And to do that, I'm probably going to need to get out a Plamos emulator debugger attached to it. So I am going to leave that till next time. So I hope you enjoyed this video and please let me know what you think in the comments.


Hello everyone, this is Dr. Manohar K.N, concept and physician, Manipal Hospital Bangalore. The whole world is in the grip of COVID, but if you look at the recent data which has been immersed, the non-COVID related problems have been neglected and have shown increased mortality and morbidity due to non-COVID illnesses as compared to the COVID itself. Well, to take precautions is very important, but to suffer from the fear of it is even worse actually. So, we at Manipal Hospital have gathered for this situation. We have our infectious disease control protocol in place and we encourage physical consultations in many patients who require it. So, urge everyone to consent physically. Of course, there is an option of video consultation, but then in many instances physical consultations could be of importance and never neglected and suffer another issue apart from the fear of having this COVID contracting during this episode. So, urge everyone to visit us. We are well prepared to deal with this situation.


Hi everybody, Joe for jatsby's casewrakes.com coming at you with a random number block randomizer for this big group of teams right here Nice teams to Yankees raves gnats Cardinals Orioles Phillies Pirates Cubs Mets and Houston This fills up a Mac of baseball picker team 28 coming up in a separate video That's how the number blocks work if you need the instructions for that for future random number blocks But I think everyone here has a good idea of it. Thank you for the late-night rally. All there's the numbers right here Let's roll it randomized names numbers five and a six eleven times for names numbers one two three four and 11th and final time Patrick down to Justin and then let's assign you a number after 11 times one two three four five six and 11th and final time and remember the mac video will be in a different video talking to me in this one Six down to eight after 11 Lot of numbers here, but I appreciate everybody giving this a go Patrick with six Brian with one Justin with zero Carl was seven and two Jeff with five David with three Jeff with nine Jason with four and Justin with eight Remember Justin zero gets any and all redemptions for that big group of teams right there on the bottom tab Including one of one redemptions Brian you'll still get any live one of ones that are pulled out of here So good luck to both of you. Let's sort this numerically and again coming up in the next video We'll be the break itself Jasper's case breaks.com. Bye


Hey everyone, I am super excited to announce our upcoming contest for all the details just go to NavigationTrading.com Ford Slash Contest so here's what we're going to do We are putting fifty thousand dollars in an account and the winner of the contest gets to trade our account for three months and Keep fifty percent of the profits. How cool is that? So let's take a look at the details if you scroll down on this page You'll see the contest rules and like I said, we are going to fund an account with fifty thousand dollars The the winner will be chosen in drawing to participate The actual contest starts October 1st and that's when the actual trading starts and it'll last for three months As I mentioned the winning participant that's trading is awarded Fifty percent of any net profits at the end of the contest at the end of the three months now To be eligible you have to qualify by meeting all of the following criteria Okay, you've got to complete the application by September 14th. I'll go to the application just in a minute and explain that Next you've got to complete at least two courses from navigation trading, okay? You've got to understand our methodology. You've got to understand how we open and close trades how we adjust and roll trades so you have to have completed at least two of our courses and Next you've got to be a current subscriber to navigation alerts This is the only way that you really understand what we're thinking why we put on trades and you and you get the Weekly video updates to understand our methodology and exactly what we're doing Next you have to have a good working knowledge of the thinkorswim trading platform That's the platform that we'll be using during the contest to make trades now If you don't currently use toss as your broker, that's okay You simply need to download the the paper trading platform and Make sure you are completely comfortable placing and Managing trades using the toss platform, okay Next you've got to be able to you've got to be available to trade during normal market hours And I don't mean you have to be available all day But you have to be available for at least 15 to 30 minutes at some point during the day When the markets are open and then next you've got to be available for a for one call with with us At least one time per week, okay? So not only is this a contest, but it's actually doubling as a private coaching session So we're going to do one call a week It's going to last 30 to 60 minutes So you've got to be available to do that call and lastly you've got to be a current resident of the US Unfortunately, we cannot open this to all the different countries of our membership So you've got to be a current resident of the US Now some other questions that you might have what types of strategies will we be trading during this contest? And it's it's our typical income strategies that we teach in our courses. So we've got iron condors calendar spreads butterfly spreads Strangle straddles Put in call verticals and puts in calls. Okay, so you've got to understand those different strategies How much time is required? I already mentioned you've got to be available for at least 15 minutes during regular market hours And then be available for a 30 to 60 minute phone call once per week Okay, so can the winning participant place any trade they want? No, this is going to be like I said It's going to be a coaching session. You're going to be trading We're going to be working through trades and coaching you through the different trades to place And so all the trades that you place have to be authorized by us before you make the trades in the account And then what happens at the end of the three months? Like I mentioned you keep 50% of the profits We'll send you the winnings and and then along with a 1099 form. So you will be responsible for paying taxes on those winnings And then lastly, what if the account loses money during the contest? Well, that's on us The participant is not responsible for any losses during the contest Okay, you get 50% of the profits, but don't incur any losses if they occur So I mean the whole reason that we're doing this is to show you that we're so confident in our methodology and our Strategies that we're willing to put in $50,000 into an account and let you trade it Okay, so all you have to do is click on the yellow button that says go to the application When you click on this The form will pop up and you just need to provide your name email phone number Click on the different courses that you've taken from navigation trading And then you've got to agree to the following criteria that you are a current alert subscriber And and that you'll be available during market hours to trade You obviously have to own a computer with Skype video microphone High-speed internet available if you don't have that currently you need to get it to be eligible to participate Because we are going those those once a week calls. We are going to be recording those. Okay, so you have to be Able to do that you have to have the technology available to do so and then as I mentioned You've got to have basic knowledge of trading and skill to place trades on the thinkorswim platform Click submit and that application goes to us and then some time before the contest starts, which is October 1st We will announce the winners probably a week or two before that. We will announce who the winner is So I hope you guys are excited about this. It's gonna be a great contest It'll not only help the winner learn how to trade, but we'll be recording those videos So what it'll help all of our membership to see how a newer Trader can actually make money using the strategies and methodologies that we teach So good luck to everybody. We'll talk to you soon


Okay, so you all heard that, right? Yes. Or not? You heard recording in progress? Yes. Okay, good.  But good, at least I won't be the only one. Okay, so the notion here is to put randomness into our simulations. And we already know a lot about this just from the homework you've been doing. Why do we want randomness in our simulations for, because there's complexity in the world. Things aren't constants in the real world, and so they shouldn't be constants in our simulation. But if we know, that's a different question, but if we know the distribution that our data or input data follows, that's great. Then we can sample from it from this distribution. Not for this class, but maybe next week or the week after we'll be looking at how do we know what the distribution is how do we know that our for example that are into arrival times are exponential. Okay, it's a different question. Right now all we know is we need randomness. You saw that when you, for those of you, well, even when you did the uniform distribution. And for those of you who did your the Excel using the exponential distribution. It was all based on random the random number generator and Rand, which gave you a random number between zero and one from not mistaken. So that's the first thing and that's what this lecture really is all about. It's about the base randomness, not about generating various from a particular distribution. We could, although we don't. We could use real randomness in our simulation right if you if you haven't thought about it, you could think about it now. We could use and is in fact the the checkout stand started out that way, where we were using something that was really random, tossing a die chips in a hat, labeled one to 10. And you can see there are other other ideas a roulette wheel. Generally speaking, when you have a truly random number. There are some real physical process that generates the randomness radioactive decay bumping electrons off of a wall, or towards a wall. That sounds as often measuring the distance from the center from from an edge. Something that results in randomness, and that can be measured. That's sounds extremely messy and extremely expensive. So you can understand we don't do that. However, we might do that to generate random numbers right. If you haven't you can look at look it up when you get you get home or you are home probably, when you get to a book in either probability or statistics at the back of the book there'll be a random numbers table. You probably used it before and your undergraduate studies. What, what were these, where did these random numbers come from. Well, we know where they came from they came from the Rand Corporation, which actually used an electronic simulation of a roulette wheel for the randomness true to randomness attached to a computer to generate the measurements, the values. That wasn't good enough, even though it was truly random. So they had to also test it. And perhaps there was some filtering going on to make sure that extreme values, let's say, you know weren't left in certain parameters that they needed to match your book of random numbers comes from or the table of random numbers at the back of your book comes from a book that was put out in 1955 by Rand with those random numbers and in addition, between and you know the late 1940s and on the Rand Corporation made these random numbers available to people on a magnetic tape. So that, you know, you don't have to actually key in the values from the random number table. And what you see there on the screen is just a clip. A piece of the random number table. And it's in its grouped in in units of five digits. And it looks two dimensional, but it's not two dimensional. It's just a one long stream of random digits. So if you look at the top left it starts with seven, seven, three, seven, three, five, four, five, nine, six, three and so on, across the across the row and then in major row order. And all that was was a convenient way of arranging one long stream of random digits. We don't have anything to do with each other it doesn't matter it doesn't matter that they're in groups of five, or that this looks like it's in two dimensions none of that is none of that is important. It's just a stream of random digits. So, we could use true randomness. These digits are truly random, we could still get access to it on an electronic, an electronic form. We could still get a file with it. Think about why we don't. And I'm not asking people to contribute because we're recording, and I know people may not wish to, but please do feel free if you don't mind to just unmute yourself anytime and jump in, either answer questions or ask your own. But if we have a file of random numbers or in this case random digits. How do we access it for our simulation program. We would have to read a digit from the file. Maybe we'd have to read a sequence of 10 digits from the file if that's what we need. And then go to the simulation, discard it, and then go to the next one and read another number and use it in the simulation. And you may not realize this, but reading from an external file is extremely expensive it takes a long time. It takes a lot of computer time. It's the the probably the most expensive thing that you could be doing in the context of, if you're paying for computer time for example. It's very inefficient use of your time. So it we could do it, but now let's move on to look at something that might be almost as good, and sometimes maybe even better. What we actually use are not random numbers, even though the function in Excel is called Rand. They're really pseudo random numbers and if you look at the diagram on the slide. That's exactly what a pseudo random number generator does. It outputs a random number and then uses that random number as input in order to generate the next number and the next number and the next number. So there's a stream of random numbers, each one generating the next. And naturally, it's booted up externally before you get into that loop by a single random number that's used once. And that's called the seed. SEED that should probably be, I should probably put that in the slide shouldn't I. So that random number that's used once as input to the pseudo random number generator is the seed, which then produces the entire stream of random numbers that comes after it. It's nice to know because if we ever want to duplicate what we've done before. What we have to do is use the same seat, and it will produce the same stream of random numbers every single time. And if we don't want to duplicate what we did before but we want we want true randomness. We just start with a different seat, which has its own issues, of course, as we know. Not only are truly random numbers inefficient and more expensive to use, especially when we're talking about computer time, even many simulation programs are, you know, take a very long time. Some of them even have to be run on a supercomputer. However, they're still doable. In addition to that reason, pseudo random numbers are better. Because, well, it's faster, which not only means that I don't have to pay for that lengthy computer time but it's faster. I don't have to wait such a long time for my computer program to run in the programs we've been doing that's not an issue. But but in other cases it is. But even more, probably the best reason for using pseudo random numbers is because I can actually not to replicate I can duplicate what I've done before. If I have the same model and the same random numbers, I will get exactly the same thing that I got before. So you're going to say why would I want that. Why would I want to get the same thing I got before. And there are cases when you would want that suppose I'm planning to renovate my hospital emergency room. Wouldn't it be nice if I could take the customers I had yesterday, do the renovation, and then run the same customers with the same illnesses through the emergency room tomorrow, after the renovation, and look at the differences. I could do that by by this, this feature of reproducibility. If I use a pseudo random number generator, as opposed to truly random numbers. Certainly, if I use a pseudo random number generator as opposed to just experimenting in the real world. Truthfully with truly random numbers as long as I have saved them in some format, I can reuse them. Sure. A disadvantage of pseudo random numbers, and especially a disadvantage if we want to keep on using a different seed. To not have the same, the same entities moving through the system at the same rate and at the same time, each time. Every pseudo random number generator has what's called periodicity. There is a finite period during which every random number generates another new random number but after a while, it's goes back it cycles back to the beginning. And you have the very same stream of random numbers from that point. Obviously, clearly, that's a problem, especially if you don't know what's going on. All right, so everyone wants to see what a pseudo random number generator looks like. Here's one. It's a simple one and as you can see it's also an old one. It's presumably not what we're using in our calculators in programs in Excel, because there are better more efficient ones. But the nice thing about this is it's simple to do by hand and it's simple to understand. Okay, let's see how it works. It's called middle square. We start with, as always, we start with a random number of a certain number of digits. In this case, we're looking for an end of is even so, you know, whatever it is, whatever you decide on that you you figure out what your seed will be. Some random number you can even start with a sequence of random digits and even number of them from the random number table. Take the random number do some arithmetic to it. That's what all of these random number generators do. They take the random number do some arithmetic to it and output spit out the next random number in the sequence. In this case, what are we doing we're squaring it. We're adding zeros to the left which we know is doable and doesn't change the value. Now we're going to form a sequence we add enough digits to form a sequence of two and digits. So if we have, let's go to the example. If we have 1111 as hard as a wonderful seed right we have 1111 as our as our first random number. We square it. Get 1234321. That's seven. Zero on on the left, which doesn't change things but makes it an eight digit number. And the center is 2343. We take the, the middle four digits to create the new random number of four digits. Okay, and the more digits you use obviously the better you'll be especially if you're doing this for cryptography. This is one that's probably not going to be used because the the periodicity is very small it starts to repeat very quickly. Why couldn't you preview my file. See if I get it now. Yeah. Okay good. What should a good pseudo random number generator have since this is pretty much common sense. I think you could figure all of these out on your own. But let's take a look let's go down the list. They should be random. Of course they're not going to be random. How do we know that pseudo random numbers are not random. How, how, how do we know they're not random. Well, if I give you a pseudo random number. I'm going to the generator. I can predict what the output will be. That's the very definition of relatedness of, of not being random. If you can predict what your random number will be clearly it's not random if you can compute a random number using a bunch of arithmetic. Clearly it's not random. So our pseudo random numbers aren't really random. That's why they're called pseudo random. They behave like random numbers. I see a chat flashing. Is that okay. And if any problem with that. Oh, okay. All right. I should learn my lesson. If you see something in the chat, somebody check to see if it's important. And give me Morse code or you could even send me an email I have my phone right here. If you don't want to speak. Okay. Basically pseudo random numbers appear random. They act random. Clearly they should be reproducible because one of the things we liked is the fact that as long as we have the seed. We can produce the same stream of random numbers each and every time every single time. That's not only something we like it's critical because there's no point in using pseudo random numbers otherwise over truly random numbers it's a huge advantage. We want the algorithm to be fast we want it to work quickly we don't want to have to wait to get the random numbers as you know from working with Excel. Once things get a little bit complicated. Even a few seconds of a delay when things are recomputing a noise us. We want to make efficient use of computer resources so it's not only time. It's also space in other words how much storage spaces use where the storage is. Whenever we say efficient in relation to computer resources we're talking about issues of time and space. We want to make sure that even though we know there will always be cycling there will be periodicity. We want to make sure that the algorithm we use has a long period. It doesn't cycle too soon because it's pretty much useless if it does. And we want to make sure that not only do we want numbers to be random but we don't we want them to be distinct we don't want to get the same number over and over again. That if that happens that means the whole thing just degenerated. How can we test random numbers. I think that the matter is that pseudo random numbers are tested when when when when someone, let's say we tests a pseudo random number generator for goodness to see how good it is. They're going to be it's going to be tested to see if the numbers are quote unquote random which basically means do they act like random numbers. We know they're not random, but we want to know if they act like random numbers. These the pseudo random number generators do test well. They act like random numbers for the most part is a little bit of an issue with Excel, at least in the 2010 edition. The interesting thing is that if you do higher level testing, which, of course, we're not doing in this course, but if you ever find yourself in a situation where you are doing higher level testing and by higher level. I mean multi multidimensional hyperplane testing. So in other words when we test the stream of random digits or a stream of random numbers. We're testing something linear. Right. But if you take these numbers and look at them in a hyperplane very often patterns emerge. And the people who the mathematicians who study this have basically said, there's no such thing as a truly random pseudo random number generator. In a way is what we're looking for is good enough we're looking for it to be good enough random enough. If it passes the tests of randomness, we're happy, then we're good. Okay. So, even though, so I'm going to move on to the next lecture on generating random variants. This one does happen to have a narration, but I'll continue recording and then at some point when we all get when we feel we've had enough I'm not going to do the whole thing. I'll stop and I'll pause the recording or I'll close the recording. And then we can move on to other things. Professor I'm the one that message you I just have to leave like around like five or 10 minutes. I won't even I won't even notice.  But thank you. Thank you for letting me know. Okay, people are so polite. I'm really I've been teaching undergraduates and I'm really not used to it. But thank you. Okay. To some degree we're trying to straighten out terminology. And quite frankly, I don't think that's what we should be doing in the lecture. It's not not that important and it's also not going to directly affect what you're doing in the homework. So I will just say, in general, when we sample from a distribution, we will often maybe even usually call it Monte Carlo sampling or Monte Carlo methods. And we were generating the inter arrival times in Excel for 20 or 50 or 100 customers. That was a Monte Carlo method. So whenever we're sampling values from a distribution, a particular distribution, getting random variants that can be called Monte Carlo sampling. Some people will consider it simulation. I think simulation should have a time element. And Monte Carlo simulation is just a numerical analysis. It doesn't have a time element. It's a static sampling, right. All right, the, it's interesting to note that Monte Carlo methods go back to. Well, the technique goes back to the 18th century. But it wasn't called Monte Carlo then the name Monte Carlo goes back to the Manhattan project in which many physicists from different countries got together to create that thing called the atom bomb. And naturally it was, it was a big secret, which was why it was called the Manhattan project and not the atom bomb project. And anything connected to it was kept secret. And so the, the code name Monte Carlo was used for the method of sampling for this methodology. All right, this you can read on your own. I'm not going to read, you know, reading slides is boring. And again, it's not relevant to what we're doing right now with our homeworks, but you should you should do it on your own. Okay, when do we use Monte Carlo. Sometimes there were other reasons okay one thing that I said earlier is that we want to sample variants from a particular distribution. Sometimes we want to compute things that are best computed with numerical methods, iteratively like the value of pie. Or like repeatedly sampling from a distribution where the mean is, is either too difficult or impossible to compute using expectation.  So here's how Monte Carlo methods work in general, not all the same obviously. So we have a random number somehow generated by some method like getting getting it from a magnetic tape, a table of random numbers, a roulette wheel, a computer program like a pseudo random number generator. Somehow we need a source, we need a source of random numbers or pseudo random numbers. We also need the cumulative probability distribution, and I'll show you why on the next slide. See that little picture.  Let me just use my pen. Okay. So, if just to just to draw a very common distribution, the normal, right. The normal distribution goes to plus infinity on one side negative infinity on the other side. Here's the mean. The mean is equal to the media and is equal to the mode. The cumulative distribution comes from taking our probabilities for as we go along the x axis and accumulating them. By the time we get to the very last place where we could be. It's 100% of the distribution, wherever that is. And we start out with zero the distribution. Take a look at what happens we keep increasing and increasing and increasing which is very much like what you see down here. And then we not only are increasing but we're jumping. In the middle, where we have the most concentration of the frequencies or the proportion of the data in our distribution. All of a sudden there's a jump, and then it peters out again. As we go to the other side the values on the higher side. So this S shaped curve is very typical of a cumulative probability distribution for a symmetric distribution, where the mean is equal to the median is equal to the mode. And that's practically the definition, but certainly one of the properties of the normal distribution. Okay, so why do we want it's, why do Monte Carlo methods depend on having a cumulative probability distribution well look at this. We have a number between zero and one. Isn't that great. And our random numbers come to us as numbers between zero and one. The median at the 50% mark is point five, the probability the cumulative probability is point five. Suppose we want to know what that corresponds to in our original data. We can horizontally go till we hit the curve at point five, and then drop down. And hopefully if it's a normal distribution or some other very symmetric distribution will be at the mean. But whatever x value that is it's it's corresponds to the 50% market in the cumulative probability distribution. So it's very useful to be able to look at a distribution not in terms of the the x not in terms of the relative frequency of any particular value or group of values, but in terms of the cumulative frequency or the cumulative probability. So how do we, how do we do this. Okay. We get the probability distribution we get a random number between zero and one. We get it randomly so randomly will find a number between zero and one. We project horizontally, we drop down vertically, and we sample our x variable. That's how we would do it graphically, of course as we probably could figure out we don't want to do it graphically. So many reasons, the not the least of which is the fact that it's very hard to get a very fine tuned value of x. You know we should be able to get something like 3.5 or 3.67 but to get 3.63241 would be difficult. Okay. So this is the, an algorithm instead of a graphical approach. And this is the algorithm that you've, you've used, you found it, you either found it here, or you found it on Google or you found it. Well, that's probably it. And it's called the inverse transform methods. And it's exactly the same as getting a number between zero and one a random number, hanging a horizontal hanging a vertical and finding that value of x. It's exactly the same as the graphical approach. I just want to make a point. This is cumulative distribution that's more for symmetric distributions like the normal. And this is probably closer to an exponential. Anyway. Oh, here, yeah, the formula for the cumulative exponential distribution. Okay. So if we want to use the inverse, inverse transform to get to generate random numbers from an exponential distribution, which is the same by the way as what we would use for a Poisson only in the inverse. Okay, f of x. That's our function that gives us the cumulative probability distribution. The cumulative probability distribution for an exponential is one minus e to the negative lambda x where lambda is the parameter. If we add one to both sides. We haven't really changed anything have way, because what f of x and one minus f of x are both numbers between zero and one. Now all we do is replace one minus f of x with we're getting a random number from a pseudo random number generator, and we want to generate a random number that's between zero and one that's what that ran means. And what we're left with on the right side is e to the minus lambda x. Remember all of this is going towards solving for x. Well, if we take the natural log of both sides, the natural log of the random number on the one side, the natural log of e to the etc, the natural log on the cancel. And we'll end up with negative lambda times x on the right. And if we want x. So we take negative lambda and divide the right side and the left side by negative lambda, and we end up low and behold with what you've, what you saw our two presenters using in Excel. So negative one over lambda times the log of the random number between zero and one. And just, you know, writing it more neatly here, but it doesn't really matter how you write it. All right, this is what we were talking about earlier I said this in response to a question during one of the presentations. And so it's just a repeat. The Poisson and the exponential are inverse of each other. If you want to prove it to yourself just make sure you keep track of the units. Okay. The exponential distribution is in times in terms of time. And you generally are talking about time per entity, like into arrival time between successive entity service time per entity. The Poisson is actually because I was an interesting distribution it's considered a discrete distribution, but it's this it's a discrete distribution. It's a distribution of a discrete random variable that's inside of a continuous interval, which is the only one that I can think of that's like that it's very unusual. So the Poisson distribution would govern let's say, number of defects in a square yard of material. And in this case, what we're looking at our rates. Number of customers per time interval that's a rate. And that could be the rate of service or the rate of arrival. Number of entities per time unit. If you turn it around time unit per number of entities then you have an exponential. Okay. Again, I'm assuming that if you have questions or if you want me to go through something a little slower, you will let me know somehow. I'm going to do a couple of more slides. We already did the part that was relevant to the homework. I just want to show you that there are other distributions and there's other things we could be doing but the process is usually the same not always but usually. Suppose we have a different discrete probability distribution we looked at the Poisson. I mean you could do it with I suppose with binomial to we haven't. Here's a general probability distribution where it's just enumerated. There's no formula. Okay, and we've seen problems like this and you've seen problems like this in other classes I'm sure. In this case, this is the distribution of customers that are arriving in 10 minute intervals the number of customers to arrive the probability of the particular values of customers arriving in a particular time interval 10 minute interval. So, in any 10 minute interval, we can expect zero customers arriving with probability 40. We expect one customer to arrive with probability 25 two customers would arrive with probability 20 and three customers with probability 15 the cumulative probability you just accumulate. Okay, the probability of zero customers arriving is point four, the probability of zero or one is point four plus point two five or point six five. The probability of zero or one or two is point eight five and the probability of zero one two three well that's got to be 100% because there's nothing else left. And if we graph the cumulative probability distribution. It would look like this graph. Thankfully, I learned to do this in Excel by by this point so it's a little bit less ugly than the others. And so here's a simulation, suppose our first five random numbers came out this number between zero and one remember point oh nine point five four point four to point 80 point 20. Okay. Well, for the point oh nine. There's nothing before. Point four. Anything in any random number between zero and point four is going to be zero on the x axis, right. So you can take each, each one of these random numbers. Find where it is on the y axis. And then go horizontally until you reach. The value you're looking for and then hang a vertical down, and you get the value. So doing this using the graphical approach of course you don't have to use the graphical approach we could use an algorithm to for these five random numbers you get zero one one two zero customers in 50 minutes. There are other ways of doing it, obviously, but this is a simple way and it's using the same principle as we used with the exponential. Now here's something a little different. What if we want to sample from a normal distribution. We know what and here you see this is the same one as before the famous S curve. We know what the cumulative distribution looks like for the normal. And we know what the formula is. And we really don't want to solve for X. It's, it's a it's kind of thing that would give us nightmares probably it could be done, or maybe not. I don't know. I have it's been a long time since I had calculus. At any rate there are approximations which which I'm not going to go into now. That's again it's not relevant but you should look at look at it. There are approximations that are based on sums. You know that the central limit theorem is based on the notion of averages which is basically the same as sums that says that no matter what the underlying distribution is, if you keep repeatedly sampling from it. It's going to end up at some point looking a lot like a normal distribution. This is an example of a uniform distribution, the distribution of a die that after several tosses ends up looking like a triangular distribution. And if you keep on going you'll end up with something very much like a normal distribution. Okay, so that's just the theory behind it. You know perhaps we'll come back to this one day in the class perhaps not. There is a method by which to use this for, it's kind of cool. Okay, but we're probably not going to need it. If we do make sure you let me know if you need it for some something that you're doing, make sure to let me know and then I'll go back. We'll go over it in class. Maybe I'll use a marker board. Okay. Oh, this is still. Oh, this it ends up being, you know, this is just simplifying the algorithm it ends up being not too bad. If you don't have to worry about why you're doing it. Okay, I'm going to stop the recording now just in case people want to contribute. If I could figure out where it is.


Yesterday, I was entering the lift and I was shocked by what happened. Watch till the end because there's one very important investing lesson I want to share with you. Hello, this is Chloe, and welcome back to my channel. The only one place for you to learn about stocks investing as well as options. If it's the first time of you coming to our channel, remember to hit the subscribe button as well as the notification bell so that you will not miss out any of my future investing insights. An early thumbs up is also appreciated because it will tell you to algorithm that you find this video helpful and it will actually help to push out to more people to inspire them to start investing safely. So yesterday I was going to the mall and to send a Christmas present to a good friend of mine. Yeah, I know Christmas always comes early. So I entered the lift and wanted to go to level 5 where the post office was located together with a few other people. As I entered the lift, I was pretty surprised that the lift actually went down to basement 2 and basement 3 instead of going up. I could send some impatience in the end so I just cracked this spontaneously and I said, it's okay, it's definitely going to go up. We just have to be patient. And to my surprise, a calming voice came from the back. Yes, exactly. We just have to be patient in everything in life. And as I followed the voice and turned around, I saw this very old lady in her disability kit and she was pretty unstable in her walking and that's why her husband even had to help her on one hand in case she fall off accidentally. But despite the fact that she looked weak on the outside, she actually gave out a sense of peace, calmness and tenacity from her aura. She said, it will sure go up, patience is all we need. And apart from patience, we need other values in life too, such as love and kindness. And as she finished speaking, the lift door has opened and voila, we are on level 5. Once we reached the destination floor, I said thank you to her kind sharing and part of goodbye with this old couple. So what's the point, am I trying to drive a course? I know lately there's so much volatility happened in the market and your portfolio is definitely being affected. You may be feeling anxious every single day seeing your profits being wiped out or suffering even more losses depending on when did you start investing.   Your life shouldn't be just about investing results. There's so much more for you to appreciate apart from your portfolio return.  You never know, you may just bump into me. My point is, I know the stress that you are going through and even my big pimple is screaming out loud in desperation. But the truth is, whose portfolio is not going down during this period of time? My portfolio went down, my mentors' peak portfolio went down, even Warren Buffett's portfolio is coming down. But does it mean that we are not good investors? If you are suffering losses right now, it doesn't mean that you are not a good investor. If you know exactly what you are doing, you should totally just let it go and stick to your game plan. But if you are feeling stressed about your portfolio performance, then you got to ask yourself, are you indeed investing in solid businesses at a good price? Remember, investing is not gambling. You have to make sure you study the companies and really understand what does it do before making any form of investment decision. And when you study the company deep enough, you will have this sense of peace and conviction in these companies that even during volatile times like this, instead of trying to panic sell, you actually want to allocate more money into buying great businesses like this at a discounted price. So if you are losing your beauty sleep at night, then maybe it's time for you to re-examine your investing approach and re-look into the companies that you are holding on right now. If you don't know what to do, then make sure you get the right form of guidance and you can even watch some of my investing insights over here for you to see how deep dive do I go into the companies that I investing in so that you can get a sense of what you should be doing for your own homework. Lastly, investing is about being optimistic about life and the betterment of the human society. So ask yourself, do you believe that in the next 10 years, 20 years, 30 years down the road, the economy will continue to do better because we humans strive to become better? Do you believe that technology will continue to advance and the world will actually become a much more developed place than it is today? I personally believe so because I'm long-term optimistic about the human's desire to strive for the better. And for that to happen, the market can only go one direction, which is go up. So although your portfolio could be at B2 right now, but with some time and some patience, I truly believe that as the lift door open, you will have realized that you have reached level 5. So the key is stay invested, be happy about your life and have fun investing. Last but not least, don't forget to subscribe to my telegram channel as I constantly update more investment insights over there as well. And we'll actually have to push out to more people to inspire them to start investing.


You know, I've been an entrepreneur for about 15 years and the work that you and the entrepreneur magazine specially do I think have been very important part of my own journey. Thank you for being one of the first people to really celebrate this and you've been doing this for like the last many many years because I've been following entrepreneur magazine for a decade and you know it's a lonely journey to have somebody in your corner and that is very special.


What's up, everybody? Jason here for jaspyscasebreak.com 2021 break Kings basketball premium edition three box case big random teams number two just sold out And again guys, this is a 30 spot break Everybody gets a random team in the NBA three boxes per case one pack per box three cards per pack all cards from rookie years and at least two or Two PSA or BJ grade BGS graded cards per box So here you go. Here's a dice roller. Here's a customer names James down to global Hawks down to the wizards. Let's roll the dice Let's do one and six one to five six times. Sorry one two three four five six Bill down to daniel one two four five Pacers down to the clippers All right, so bill the Pacers global you have the bucks James with the 76ers paul the bulls Daniel the warriors chris with the rockets nick with the routers simon with an hornets, uh two with the T-wolves matt with the nuggets chris with the wizards matt with the mavericks was art with the spurs eric with the celtics Daniel the ox nick with the grizzlies alex with the lagers james with the heat scott with the trailblazers matt with the kings scott with the cows global with the jazz matt with the magic Sean with the pistons level with the suns candy with the pelicans Sean with the nicks scott black hole with the thunder matt with the nets and daniel with the clippers All right, if anybody wants to trade guys, I'll give you guys a quick minute. All right guys. I'm assuming no trades Here we go guys. Good luck. Last two slices of meat lovers. Go ahead everybody. That's bringing food We have mba hoops arriving now PSA 10 jamorat and again memphis grizzlies All right, that's nick stover We have a ps8 10 lonzo ball prism for the lakers It's global the last one here Is a nine five panini status orange tray young For the atlanta hawks. That's daniel Very nice one right there. That was a nice box all point cards eight five ben simons. Oh rough Ben simons, man Needs a change of scenery. That's for sure. 76ers. That's going to james Deandre hunter hyper pink ps8 10 for the atlanta hawks another one there for daniel Oh That's why there was a ben simons Because there's a yannis onto de compo rookie from pinnacle ps a nine Play that offset with that And that is for the milwaukey bucks and uh global last one mocha That last box we do have one more case guys Because i want to kill that tonight first one's a chumo kiki prism rookie ps8 10 for the atlanta magic What a mat We have a shea gilgis alexander. That's a rookie as well. Remember no rookie stamp on there They put josh part with a rookie stamp by accident ps a nine for the clippers it's gonna daniel and last but not least we have a Pascale siacom that is a rookie donner's optic signatures ps a 10 for the raptors winner nick there you go guys boom yannis Tray young mom's a ball jammer and Appreciate you guys again number three is the last one we have guys. It's in the store. Jaspy's case breaks.com