Hi, I'm Dr. Mokshi Kaul. I'm a senior orthopedic physiotherapist with Manipal Group of Hospitals based out of Kharadipune. Today I'm going to talk to you on a topic that I get asked upon all the time and that is, why does one get muscle cramps at night? So friends, the answer to this question is, there are many reasons why one get muscle cramps at night. Number one comes your muscle fatigability. So there are certain muscles in our body which are very tight and they get fatigued easily. So this is first reason why you land up having cramps at night. Number two is dehydration. So because of dehydration, you don't get the essential minerals in your body like calcium, potassium, magnesium and sometimes the vitamin A deficiency can still result in some sort of spasm and therefore you land up having again muscle cramps in the night. It's also seen a lot of pregnant women, they have muscle cramps which is quite often. So how does one prevent it? So first you can have a proper balanced diet include all the essential nutrients in your diet which will help in overcoming your muscle cramps. Number two comes hydration. Take lots and lots of water. Even if you do it, what is you can do it at night is you can just stretch that muscle. One very common area where a lot of patients have complained they have the muscle cramps is your calf muscle. So just do some ankle plantar flexion, dorsiflexion, try to stretch that muscle and the cramps will go away. So nothing to worry about it if you get muscle cramps at night, this is the answer to it.


Let's get rolled up and today everyone and welcome back to the conference session in the application development with the serverless and containerization track and yeah today we have with us three thumb board this being over the topic web exploiting and the offensive ways to hunt the bugs and if you have any of the questions in between the session you can just post it in the right side of your screen over the chat box. The speaker would be happy to answer all of your questions I would go ahead and start the session. Hello everyone. My name is Pritham Singh. I'm associate quality engineer with red hat, but security testing is really my passion. And as I learned about it, I realized that maybe it will be helpful for other people to know the things I have learned. So that's why I'm giving this presentation today. So let's continue with web exploitation, the offensive way to hunt bugs. Okay, so this is our today's agenda. So the goals of bug hunting or the goals of this presentation. Introduction to web application penetration testing. We call it as a VAPT vulnerability analysis penetration testing or web application penetration testing and some approaches to aggressive bug hunting or the tools that we can use to look for the security loopholes. Common attacks or the common vulnerabilities to check for in your project. So here with means of this presentation, I'll be referring the wasp top 10 project. So some of the common vulnerabilities I'm referring from wasp top 10 attacks in action. Some of the demonstrations of the POCs or the security loopholes that I have already reported in some different projects or websites, which was already fixed by the developers or the company. And at last Q&A. Next. So what is the goals of offensive bug hunting or goals of this presentation. So as I always feel feel a QA engineer or a developer, we have the power, the power to find new bugs or flaws with the code, which others could not find at the same time. To ensure that QA or development is properly done. So through means of this QA engineers can work proactively or a developer can work proactively to find some security vulnerabilities in different features of the website in functionality testing. The developer kind of after development when doing a testing normal testing in staging environment, they can also look for this kind of loopholes while doing a staging in different features of the website. So as I always feel, because as we are a QA and a developer, or sometimes the bug is in front of our eyes but as we are not security aware, we are not able to see that this is the security loophole because as a QE we are only looking for the featured bugs and as a developer we are So, yeah, after moving this methodologies and processes, we can even open source contribute in different security projects, we can collaborate even different projects as well in a different means of platforms like per crowd hacker one, scenic, etc. Next. So yeah, introduction to web application penetration testing. This is the methodology and way to look for the security loophole in web based targets or websites. So there are different platforms through means of web developer and C source inviting and encouraging different researchers to report and file a security loophole through means of those platforms, such as crowd scenic and hacker one. And there are some of the private programs, let's say red hat, Facebook and Google are some of the private programs which encourage and invite different researchers to look for the and find security loopholes and report those responsibly to those product security and information security teams different approaches to bug hunting or the tools. So, there are two tools that is available, which consists of many features integrated in single one. So the first one is Bob suit, which has integrated platform which consists of comes with the many different combination of tools, let's say spider scanner intruder repeater decoder comparator sequencer extended extenders and more. So it provides different rappers also can be written by different researchers, which you can combine and import in your Bob suit framework. And there is one more tool which is open source lay available that is as a zap, which was developed by open web application security project community who standardized and defines this was a top 10 security vulnerabilities project and standard, which helps different developers and security researchers and security engineers to minimize the security risk of their product on a website. Next. So, these are the some of the common vulnerabilities that need to look into our project or in a website. So, I have just listed 10 loop holes with the different categories let's say injection broken authentication session management cross site scripting I adore that is insecure direct object references. So, if you want to know more about this vulnerability is you can refer this link that I have added here at the bottom of the site, that is a wasp.org. So, you will get a different information from the site about this different categories of the loop holes and what kind of vulnerabilities comes under what category. So, at the end of this slide, this presentation I have demonstrated few of them. You can take a tutorial and different kind of documentation and read documentation about this different kind of flaws from this website. Next. So, let's directly jump into the demonstration part. So, now this is a tax in action, that is, I'm going to demonstrate some of the security loop holes that I have already reported in a different firms. So, yeah. So, the first bug is hosted or injection. So, sometimes we can change this vulnerability with cache poisoning web cache poisoning refer based accesses. And in real time we can also chain it with a password reset link. So, let's say we have a victim and the target is vulnerable with this attack hosted injection. So, what we can do we can directly jump into the password reset page. We can test this website that if that is vulnerable or not if it's vulnerable, then the token reset token will be sent over injected host, not on the legitimate host. Let's say if host is Google.com and attacker have injected fake host or its own host, let's say evill.com, then the token will only be redirected over evill.com, not on Google.com. So, let's see this in demonstration part. So, how to hunt for this bug. So, for just looking for this hosted injection bug just always check for the response code or different status code. Let's say two accesses and three accesses. So, approach one is if your request has host colon Google.com or a real web.com just change that host entry to evill.com and try to check the response code and try to look for and search for that the string that you have pasted or the host that you have pasted if it is getting reflected somewhere in your response. The second approach is set the host from real web to evill.com and then add ex forwarded host to real web.com. The third approach is set ex forwarded host to evill.com and then host to real web.com. So, let's now see this demonstration part, the video that I have added here. So, here my target is ftp.campaignmonitor.com and I am using Bobsoot tool to intercept its request that what request and response I am getting. So, I am added the proxy and my Bobsoot tool here in this scenario acting as a man in the middle. So, whatever the requests are going from a browser to the web server that Bobsoot tool is capturing all those and intercepting all those requests. So, let's jump into this demonstration. So, here I have just started my intercept on. I am refreshing my page. So, see here I got the request of that page here I am saying the get the get response and the host is ftp.campaignmonitor.com. So, what we need to do we need to if we need to test that if this website is vulnerable with hosted injection or not we need to try all those approaches that I have added there in the slide. So, I am trying the first methodology or the approach that I have added. So, before that I have sent that intercepted request to the repeater tab here we will get the request and response of the website itself in the single tab itself. So, I have changed the host from fmailer to triplezerowebhost.com. So, this is my one of the temporary site that temporary page that I have hosted on triplezerowebhost.com. So, we got a 200 status on the response of that I am looking for the fake host that I have added. So, see it is getting reflected here in the response tab or in the source code of that page of the website see fmailer.triplezerowebhost.com and with the complete path. So, it is reflecting somewhere in the logo company's logo see images slash logo dot svg. So, what I did I have just followed the same directory path where I have hosted my page and I have created the same directory structure and just imported one logo dot svg file which has a XSS payload. So, we will be going to see the show response in browser that how it looks like in browser. So, I am just stopping my interception. Let's refresh our browser with the original response that we got in a verb suit. So, see it is reflecting here in the company's logo. So, if we are opening it by clicking on a right. So, see it reflects me here by following the whole directory path and this page says this app is probably vulnerable to XSS attacks. So, meanwhile I change this vulnerability with host and an injection to XSS that is cross site scripting. So, through means of that attacker can fake victim to visit and redirect on our phishing website and ask for the different credentials, different assets, etc. So, yeah. So, let's hope you guys understand this. So, let's jump to the next demonstration or next demonstration of next vulnerability. So, our next bug is URL redirection or sometimes we can change this vulnerability with XSS that is cross site scripting. So, how to hunt for this URL redirection bugs. So, always look for the different one of the endpoint that I have added here. So, find any URL parameter having some kind of tendency to redirect anywhere like desk, URI, continue, window, redirect URL, return URL, something like this. The whole endpoints of the parameters I have added here or there is a second methodology is URL redirection on path fragments itself. So, the example is like this any.exampleany.com slash payloads. So, payload could be like single slash with evill.com, double slash with evill.com. You will find the different payloads in this link that I have added here in the payload link. So, let's look for the first POC that is on issue with on path fragment. So, this is the issue that I got in own cloud one of the websites scan.owncloud.com. So, here the reproduction step is visit the URL scan.owncloud.com add double slash and add bing.com or whatever the site you want to visit or you want victim to visit. So, we are just copying this link, opening it in a browser, it will redirect us to bing.com and our expectation is it should redirect or it should generate some error that this site not exist or something like that but there is a vulnerable from the server side that it is not checking or validating from the server side on a server header or a server host entry that where we are redirecting actually or if something like this exist in our code or not but there is no such kind of validation from the server side that's why it is vulnerable with URL direction on path fragment. So, let's jump over the next open redirection with redirect parameter. So, this is our second target that is repostnetwork.com. So, there is a parameter that is redirect is equals to admin.repostnetwork.com. So, looking for this loophole, always search for the different parameters that is redirect URL, return URL, next back URL something like this. So, I got this redirect is equals to parameter. So, this will redirect me to that admin.parameter after getting logged in into this website. So, I am just trying to change the mechanism. I just added the avail.com instead of legit URL and refresh the page and now I am trying to log in into this website. So, you will see that the URL is now looks like avail.com in the redirect is equals to parameter. So, I am just authenticating myself in the website. So, there is no server side validation for this website also that where we are redirecting actually. So, see, I am just trying to log in myself in this website and now see there is no such validation and this redirected me to avail.com without any server side validation or without any validation for the external behavior. So, this is one of the second URL redirection issue. So, let's jump over the next demonstration. So, the next vulnerability is application level doors that is denial of service issue. So, sometimes this impacts from the client side and from the server side itself also. So, let's jump over the background concept. Application level doors can affect the server and client due to no limit to the number of character input or due to lack of input validation. So, sometimes if we are passing enough number of data or huge number of data through means of any endpoint. So, if there is a no validation from the server side on the number of characters or the data that we are inputting on the different endpoints. So, sometimes it leads to memory exhaustion and same denial of service because from the server side there should be some implementation on mechanism should get implement from such endpoint that should restrict the different endpoints. So, the different endpoints let's say this command field user name, mobile number, password change options, etc. So, let's say there is an example any side.com we have some endpoints let's say let's take example of one of the endpoint let's say mobile number. And if there is no such restriction on a mobile number characters let's say mobile number usually having a 10 digit number right. And if we are specifying a 4k character of data and there is no such restriction from the server side that what data we are importing for the mobile number. So, this will leads to memory exhaustion and could also lead to denial of service. Okay, so let's check this demonstration part. So, there is a target is coels.com there is one e-commerce site. So, here I got this issue in the password reset page or a password reset functionality. So, I am already logged in into this website. Now, I am just going on settings page. I am trying to change my password. I just added my current password the legit one. I am just keeping my interception on. Now, I am trying to capture the request. So, this is my request ID this generated. I am sending this request to repeater tab. Now, I am just searching for the password that I have entered. So, this is my payload or the character that I am going to enter. So, this could also maybe 4k amount of data 4000 character or 5000 character something like that. So, this is a huge character that I am inputting through means of that new password endpoint and the same I will be going to entered on the confirm password. Let's see what it generates. See, it is generating the 200 status code, but it is generating this. We are sorry, the page you are looking for may be non-existent because it is happening because the server is not able to handle such amount of data from the server side. And this is happening and this is going down. Temporarily it is going down, but this code leads to denial of service for the other customers. See, we are getting this error. We are sorry, the page you are looking for may be temporarily unavailable or no longer exists. So, this is this issue or the vulnerability we got in password reset page of one of the e-commerce site. So, yeah, next. So, yeah, just to conclude this. So, just to conclude this presentation. The next step for you is if you are new to the tools like burpsuit or OASAP ZAP, I think ZAP, which was developed by open web application security project community. So, just check out those site and tools and start playing with those and the tutorials of the different web or the issues of the vulnerabilities, common vulnerabilities, OASAP top 10 vulnerabilities. If you are a QV or a developer, try out these approaches or mechanisms and include such test cases in your development or testing. So that we can work proactively to start hunting this security loopholes. Right. If you want to know more about different bugs or POCs, we can connect over below mentioned social media or my bug crowd handle profile where I have actively hunting for those security loopholes on this bug crowd platform. Yeah, that's it.


Okay, so they show up in the coroutine indeed as the return value of yield. So the coroutine calls yield, which is it returns back to the resumer, whoever started the coroutine, and when the yield comes back to the coroutine, its return value is indeed the resume. Okay, so these are return values of yields. Okay, so this is good. Now how about the return value from resume? What will show up there? Okay, exactly. Now yield, what are the arguments to yield? It should be all clear now. Whatever we pass into yield shows up as the return value in resume and vice versa, right? So we have the following picture. Resume, the argument here is the coroutine, but the value here shows up as the return value of yield. So the return value of yield and whatever we pass here, shows up as the return value of resume. Okay, so the two constructs are passing value between each other. Okay. Now, which of these constructs actually behaves like a procedure, like a function call, in the sense that when you call it, it returns where it was called from. All of them, some of them, none of them, right? So what is a function call? It has the property that you call it, some execution happens, but you can trust that eventually the execution comes back. Well, at least on a program that terminates without an exception. So let's go through one by one. How about coroutine? Does it behave like a procedure? You call it, does it return? Yes, this is a plain call. It doesn't actually do any transfers of control between coroutine. So coroutine indeed is a procedure call. How about the resume?  Yes, no. So indeed, from the caller resume looks like a procedure call. On the other side, it looks funny because you may return, not using a return statement, but using a yield. But from the point of your resume, it's beautiful. You can think of it as a procedure call. How about the yield?  Yes, no. Now it's not so clear. So who thinks it's both? In what sense it is like a procedure call? Okay. So in what sense is yield like a procedure call? Can you say in what sense it is like a procedure call? The caller is whoever invokes the yield, right? I think the way we want to think about it, whoever invokes yield to that who invokes yield, does yield appear like a procedure call? Does it behave like that?  So yield goes back to whoever originally resumed to that coroutine. Are we guaranteed to come back to yield? We are not. So if we do return back to yield, it looks like a procedure call most because you yield it and you wait there and when the control returns you continue. That looks like a procedure call, right? Except that are you guaranteed to return? Clearly, the program crashes you or not, but there are situations when in a normal program execution you do not come back to that yield. Can you offer one example when that happens? Okay. If you don't call resumed, then you don't come back to the yield. Then when could that happen? Can you think of a scenario when the resume would not be called at the end of a coroutine when you yield it? Okay. So that's a slightly different topic. We'll get to it on the next slide. But when would resume not be called back to yield? Exactly. So when the yield is sitting inside a loop acting as an iterator, the loop could decide, I don't need any more elements, I'm done iterating so you would not yield any, not the resume anymore and so yield would just be sitting there essentially unused until it is garbage collected. So the question is what happens with the return value of yield? So each time we resume, we go to a yield or the special case, the beginning of the coroutine, and the coroutine doesn't have to use the return value. It can ignore it. Sometimes the coroutine is just happy that the control was transferred to it and no value is actually communicated. But each time we resume, there is a return value, could be null and so the coroutine can decide to use it or not. But it never happens what I think you're asking, do we ever pass a return value to yield without actually transferring? Yes. Yes. So you're asking about this, I think, and what this says is that when yield returns when a coroutine yields, you supply an argument to yield and that becomes the value that is passed into the resume and becomes a return value of resume. So that's an excellent comment. The comment is that the prologue interpretation looks very much like a coroutine in that you go through all the permutations of stamps and you check for which of them works. In fact, in PA3, you are going to implement the prologue interpreter that is built on coroutines. So you will see actually how it looks inside. So we know that yield is not quite like a procedural for one reason that we don't have to resume to it and not only in the case of an error. In a normal execution, we just say, we don't need any more values from the iterator. So we don't. There is another reason why yield is not like a function call. This one may be harder. Well, so the answer is it doesn't handle stack frames the same way. That's true. But as you will see, neither does resume handle stack frames quite the same way. We still think of it as a coroutine.  But there is something else. Let's try. It behaves more like a return statement exactly, but in what way? So we are getting there. You're saying that instead of starting at the beginning, it returns to wherever the caller or resumer in this case left off. So we are getting closer. That's still not quite what I was looking for. So what arguments does a function call have? What arguments does yield have? Think of the call node in the ASD in your interpreter. What children does it have? So what's the child number one? Function name or indeed an expression that could evaluate to a lambda, right? What argument would yield have once we give you an ASD with a yield? How many arguments would yield have? How many children in the ASD? Just the arguments, right? Well, okay. So the part of the answer is what the arguments yield have is correct. It only has arguments that supply the value, whereas the function also has the function. It's not quite true that the yield is a statement because remember yield has returns of value, can say seven plus yield, and the second argument to the plus will be whatever is resumed to you. But here is the difference, right? The call has an argument that is a function, and yield does not accept an argument that tells you very true deal. So when you make a function call, you can say call this, call that. When you invoke a yield, do you have a choice where you are yielding? So in that sense, it is like a return, right? It just has to return wherever there is a humor stopped. So yield cannot control where it's going. In that sense, it is like a return statement, whereas function, when you make a call, you can say where it's going. So that's another reason why yield is not quite a function call. All right. So here, to make sure you understand, we'll play a little contest, corner cake contest, and there are a few corner cases we did not quite cover. One of them is, well, what if the yields argument is blah, and what if you do something else? So I want you to talk to your neighbors and find the craziest corner case that we did not specify. Let's resume in a, you'll yield to me in a few minutes. So to encourage you to think, I'll make one random, random resume, and then you can propose the craziest corner case. So spend some more time in case you haven't yet discussed it. I'll generate a subjective random number. Okay. So I'll first pick somebody. So I did try to count to the dates today, which is 1 slash 31. I ended up somewhere there. I'm not guaranteeing I'm correct, but I ended up at you. So can you suggest a corner case? Yes, you in the hoodie. Yes. So can somebody suggest a corner case? Okay. If you yield a lambda that has a yield inside, so well, what if I say that the value yielded is just a lambda? Okay. Well, who cares? Lambda is just a value, right? Like any other value. So since lambdas are values, they are so-called first-class value. You can pass them around just like integers. Now, it really depends on what the other part of the program, the resumer does with the value. It could say, well, I know by how the program is written that this lambda could be used as a body of the coroutine, and maybe it will use it to start a coroutine. So this is fine. In fact, this is why the languages are so, maybe I misunderstood. So what is the case again that? Okay. So this is the same as just calling. Now, I think we can, so the answer is what if you yield a lambda that has a yield inside? I can reduce this case to a much simpler case, which is you call a function that has a yield inside. The yield is superfluous there, right? But the really tricky thing you're asking is, if I call a lambda that has a yield, okay, so is this necessarily bad or not? Can we reduce it to a yet simpler case? Now, that lambda could be part of a coroutine in which case the yield just leads yields to resume, right? But what if that lambda is just called directly from main? In fact, what if yield is in main? So our program is as simple as it has a one line and we say this. So one line program, right? So is this bad? Should it crash? What should it do? This is clearly a case that we have not discussed. So we need to better define the semantics. Well, I don't know what we have decided, but we could feed it to you as a test case in PA2. Well, what do you think it should do? Should it throw an error? It should return, okay. So one proposal is it should just return. Should it return a value? I guess main doesn't quite return a value, right? So it could return. So essentially under your semantics, we are considering main to be the main coroutine, which seems fine to me unless you guys see a problem with that. If the yield one is followed by print two, then print is out of luck. Essentially, you have a return before print, and so print is never reached. That seems to be consistent with how returns and yields behave, right? All right. Or we could make the decision that the yield cannot appear at the main level, and then this should throw some sort of an error. But it seems easier to design it in such a way that the yields could appear in main and they just return, all right? How about some other corner cases? Okay, so, well, I'll try to reproduce it and then we'll reduce it really to the simple case. This is good. So a coroutine creates another coroutine, right? So that's number one. Is that, am I correct? So let's reproduce the steps. So this is our test case one, test case two. So first, a coroutine creates a coroutine, okay? Let's call it a, it creates a coroutine b. Now it yields b. Okay, now what happens in step three? The main, whoever resumed into a now has a handle on coroutine b, right? And it would resume to, let's say, maybe this what happens, right? This is actually b. So now the main perhaps resumes into b, which was created in a, right? Okay, this is interesting. So we have a main. Main creates a coroutine, resumes into it, that coroutines create another one, doesn't run it, returns it using yield. Now main has a handle on this new coroutine b, okay? So we have main here, it creates a using the call to coroutine. It does a resume, okay? This one creates a coroutine b, does a yield and the yield returns b to resume. Actually this should be, okay? So this handle to b is the handle. The handle appears here and now we'll resume into that thing. And now we wait until it yields. I guess we'll have to do with chalk. How about that, okay? So main creates a, so we create this call coroutine and we get the pointer to this lambda, this is now a. Now we'll resume into this, okay? So which means the control, this is just a pointer. Now the control goes here, goes here, okay? Now we'll create another coroutine b, okay? Now we'll do a yield. We'll pass to yield this value, returns here and now we'll resume into what? We'll resume into that, okay? Which is the value that we obtained here. So are you following? We create one coroutine from main, another we create from a. The handle to this coroutine is returned from a to main as the argument to yield.  And now main can do whatever it wants with it, including resuming to it. So will this resume to b work? Yes, if yes, why, if not why? So who thinks it should crash for some reason or not work? Who thinks it should work? So it looks like you get the right idea that this b was created from here, but it's not attached to a in any particular way. Essentially we just opened the file and so to speak. And the handle to this is a value that we can pass around store in a hash table, whatever. We return it to main and then main resumes to it and we go here and then the control continues. Main can resume to a, absolutely. It still has a handle on a, right? So it can resume to it. Except when it perhaps terminated and at that point it should not resume to it. So the rule for resume is as long as you have a handle to a coroutine and it is active, you can resume it like as if you called it. Okay, so that's a good question. Now we are talking about the states of coroutines, right? You could call a coroutine that is not terminated yet. You can only resume it when, after resume, it still can execute some statements. If it has terminated already, then, well, you can resume to it, but at runtime we'll catch the error and discover, oh, you're resumed into a terminated coroutine and that's an error. Now I will probably now go that far, okay? So this is essentially not a corner case. It explains that a handle to coroutine is a value which you can pass anywhere and whoever's got it can resume to it. The only problem is in what state that coroutine is. If it has terminated already, reach the end, then you can't do it. Okay, if a coroutine gets a handle to itself, so I'll try to be brave and actually try to draw again. So handle to itself, how could that happen? First of all, exactly. So when I create a coroutine, I resume to it, which means I started, I pass it a handle to itself. All right, so clearly it is easy to obtain a handle to itself, so that's not a problem. And that still should be legal, right? You can keep any value. What can it do with it? All right, so now we are resuming to a coroutine that is in what state? It's running, okay? So it looks like we are now reaching some understanding of, okay, we need to know about states of the coroutine. So in what states can these coroutines be?  So let's look at the example this way. It's the same, but I want to first make sure that everybody understands how the values flow, okay? So this is main, okay? And main creates a coroutine G, right? Where is this coroutine? It's right here, okay? And CG is a handle to this coroutine, okay? Could we create multiple coroutines with the same handle at the same time? See a reason why not? Definitely we can, okay? So now we resume, where does the control go? It goes right here, and it goes here. We create this handle here, just like we created the handle here, okay? Then we just continue. This coroutine actually doesn't run. We resume to where? To CK, right? It's presumably this value here. So now we go and actually, oops, okay? Did I make a mistake in how the control goes? This is actually the flow of control, what I have shown. Is everything okay? Just because I guess I try to save space and it was too aggressive. So let's assume there is, yeah. I can erase this, all right? It's good, or is there a mistake? A and B are just some arguments. Perhaps they should be X and Y. Yeah, I just wanted to focus on the transfer and understanding the states. So if you consider main to be a coroutine, at this point here, in what states are our coroutines? Are they terminated? Are they, right, after the resume to main. So when the execution reaches the point, what are the states of our coroutines? I see, okay, so let's simplify it, right? Well, I'll add one more print here so that it's clear that the end is here. So think about the main is still running, okay? So main is running. How about the other two coroutines? Are they terminated? Who thinks they are terminated, okay? Who thinks they are not terminated? So why they are not terminated? So you can still yield to these two coroutines and in fact the return statement at the end whether explicit or implicit is actually a yield. So you can think of this as return is an implicit, is a yield essentially. So both of these are still running. But are they really running? Well, we know they are not terminated. Are they running or they are not running? And now we can come back to the example that you posed. When I resume to myself, clearly I can get the value and I can resume to myself, right? Now what should happen? Exactly, so resuming to a coroutine that is running should be an error because it is running. So we need to distinguish between coroutines that are running and coroutines that are not terminated but not running, suspended perhaps, okay? So at this point here, these two are suspended. Suspended, this one is running. And if we did not have a yield in the middle one, it would actually be terminated, right? Because the implicit return at the end would return and it would actually terminate that coroutine. So another resume would be a problem, okay? Why they don't terminate? Okay, so I'll explain it to you by perhaps putting here another statement. Imagine I put here a print seven. So you see now you can think of it as the yield is not really the last statement in the procedure. You can think of it as having an implicit return at the very end, sort of invisible. So if I have yield and then nothing, it really is yield and return. So if I yield from here and somebody resumes to me, I will do a no, no instruction and return. So there is little something invisible between the last yield and the return. So it's an excellent question. Well, the question is do you need to resume one more time to really terminate the coroutine? And the answer is, well, if you really wanted to terminate the coroutine, if you really wanted to terminate the coroutine, you would have to. But usually in programming you don't really need to terminate the coroutine. After all, usually we don't really exhaust the termination. But if you wanted to, yes, you would have to. So the question is if I take out the middle yield, not everything terminates, just this middle one would terminate. That would still be, well, in principle, well, okay, it's a good question, excellent question. So if I remove this yield, after it comes back, it implicitly yields back here and it's terminated. The question is what happens with this one? Well, it is suspended because you could resume to it. But if nobody has a handle on it, nobody can ever resume it. It's as good as that, right? So garbage collection would collect it because practically it doesn't exist.  We'll talk about garbage collection later. That's an excellent question. So technically it's not terminated, but since nobody has that value of the handle, you practically don't know it exists and the garbage collector could indeed remove it. So I'd say it's neither of the three, it's not existent. Okay, so let's now look at the flow of values, which is what you're asking. So rather than timeline, let's look at value flow. I know people are itchy. We are starting to get into harder stuff soon. So two goes here. Let's assume this is X and Y here. So it will flow here. Now it goes here. We do the sum. So the result will be three, of course. Where does this value go? Yeah, so it is indeed a red wall of resume. We are doing nothing with it, so it's lost. Like ignore the return value. But you could just store it in Z and then you could yield Z here and then the value would actually propagate up to here. So let's go and do real stuff. So the states of coroutines, we now know it has three states. It's running, suspended, terminated. We looked at that. Okay, I want to now make a little distinction between the coroutines that we are looking at and general coroutines. So in our coroutines, we have a yield and we have resume. And we have discussed at length how resume is like a procedural, but yield is not. So from the side of the resume, it looks like a procedural. From yield, it does not, okay? So this part here, you should understand by now. In the general coroutines that we are not covering, there is only one yield statement. And it has an argument. So you can specify where you are yielding to. It is sort of like resume. Or in other words, you could say there is no distinction between yield and resume. You give it a handle and it resumes to it and it continues at the point where it left off. So you could have a bunch of coroutines in the generic, general symmetric case and this one could yield here, this one could yield there. This one could decide whether to yield here or here. And indeed, they could transfer among each other which way they want it. In our case, it's a bit different, right? Please. Well, in our case, you cannot even go to arbitrary places, right? How would you, yeah, in our case, so it's a little bit more complicated. You can emulate general coroutines on top of asymmetric ones. But the emulation is not as simple. If you're interested, I can point you to a paper that doesn't. What I think we want to remember is that in the case of asymmetric coroutines, those that have resume and yield, how does the execution look like?  Now, of course, here you could resume to another coroutine which can yield back to you. So the structure that you create is essentially a tree, right? This one is running here. Here it is running or suspended. Let's see. Now, okay, so let's talk about that. It's good to understand that. So clearly we are running here. Are we R or S? Are we running or suspended? So remember the rule we came up with that you can resume into suspended coroutines. You can resume into suspended ones, okay? You cannot resume into running ones. So imagine I'm in Maine and I resume here, I'm in a different coroutine, but if this one wanted to resume back here, is this legal or illegal? It's illegal, right? So when you are waiting in resume, as the one on the left is, it's sitting in resume for resume to come back. You are considered running. And as a result of that, this resume back to Maine is illegal as you want to. Right, it would need to have a handle to Maine. So pretend it's not Maine, but some other coroutine. So let's pretend that somebody resumed to us and this is not Maine, but some other coroutine. So you cannot get the handle to Maine, but you can get the handle to any other. So technically speaking, let's assume this is a different coroutine, okay? So this is actually running. And so if you look at it this way, we are really building a stack of coroutines. You resume, it can run. If it yields, you sort of pop back. But if this one continues further, you grow a stack of coroutines, right? This is coroutine C1, this is C2, and this is C3. We have a stack of calling context. C1 is waiting on C2 to yield back so that its resume can continue and C2 is waiting on C3. With these general coroutines, it cannot be like that, right? Because C3 could indeed resume into C1. Again, so in general coroutines, C3 could decide C1 will continue. Here you need to yield back, you return. You want to see you want to ask a question. So the question is how do coroutines behave from the scope point of view, right? When you call a new function, the function can create its local variable X. Where is that visible? The answer is from the scoping point of view, they are just like functions. So they're exactly like functions. They're a global state, they can access it. So luckily there are no special exceptions there. But you had a question, okay? So the question, why is this resume illegal? In other words, you're asking, we want to go from this coroutine back in here. Why is that illegal? Because we have made a decision that we have these asymmetric coroutines. I'm resuming to you. If you want me to continue, you yield. So there is a way already, we are providing a way for this coroutine to suspend and return to you, and that's the yield. So we are not allowing you to use also resume to continue. Well, or to put it differently. Where is this coroutine waiting? It's waiting in resume. How do we continue from resume? Well, the person on the other side yields to us. We are not allowing to continue from resume by somebody resuming. So when I call resume, I always start on the other side from where yield is waiting. Go to the end or to the next yield. Can you speak louder? Are we asking how do I get back from here to here? It would be a yield. So here we have a yield which returns back here. So when you are waiting in resume, you are running, when you are waiting in yield, you are suspended. For example, here, this is a suspended state. The question is, does the stack need to be independent? Now, which stack? So hold that thought. We are now going to transfer to how to actually implement it, and it's all about these stacks. So start paying attention because this is where the trickiest things start. But come back to it and look at it again. And remember, so resume looks like a procedure call that ends with a yield.  And so we can go left to right by making resumes, resume, resume and return with yields, and we'll form the stack of contexts so that when we yield, we know where to return. So it's a tree, it's a stack, it's a stack. So this thing here is important. It tells us where to return on yield. So if C3 yields, it will go back to C2, and C2 will continue from its point of resume, which is its current point of the execution where it was waiting, as if it was a procedure call. Okay. So now we are ready to provide a top-level outline of that interpreter. So each coroutine will have its own interpreter, essentially come here and say, this coroutine here when we started, meaning when we resume to it for the first time, we create a new instance of the interpreter for it. The same for this and the same for that. These interpreter instances will share their environment. So the lexical scoping works just like with functions. They can share the same variable. They can pass closures around anything as before. Each instance has its own call stack. So if inside the procedure, sorry, coroutine you do recursion, plain recursive calls. They need to be stored on the call stack somewhere. So I guess this is what we were asking. Does each coroutine have its own stack because recursion, in fact, just plain procedure calls or even recursive calls could happen inside each coroutine. So on the resume, what do we do? We call the interpreter of that coroutine, whose handle we have, and that coroutine will restart at the yield. Then it returns back to the resumer at yield. So at the resume, we come here and it restarts at this yield and it runs to the next yield at which point it comes back to the resumer. We go from yield to yield or from start to yield or from yield to the very end of the coroutine. So this is simple, elegant. It almost works. So think why you cannot take your PA1 interpreter. It is relatively simple and add coroutines to it. So ask me clarification about what we mean here by this high-level outline. The key thing would be that each time I create a coroutine and get the handle, I create a new instance of the interpreter. And then at the resume, I call it when that interpreter runs into a yield, it returns. When I run into another resume, I have a handle. The handle points to the interpreter internally. I'll resume to it again, and the thing continues. So think about why that will not work. I have an example to really illustrate it, but I would like you to think without seeing the example. Where do things break down? Okay? Exactly, right? So what you said is that when you return, meaning when you return from yield, you come to the first yield, and yes, you can return, and you return back to the first interpreter. But what is the state that you need in order to continue? Exactly. So let's illustrate this. But first, let's look at your PA1 interpreter. It essentially looks like this, right? It receives an AST abstract syntax tree. It's a recursive interpreter. And I just have the integer instruction and a call. And what happens here is in the case of the leave, we just return the value. In the case of a call, we look up the function associated with the name. I'm assuming that calls always look like this. ID expression, expression. So this is an ID rather than a general expression. I'm assuming that there are always two expressions. We evaluate one expression, we evaluate the other. That's it, right? This should be familiar. And the call itself does whatever it needs to do, but it calls itself recursively. Is that how you have it? Okay. So no magic here. Now let's see how we would extend it. So what would we do at the resume? Well, we presumably evaluate the argument, which is the coroutine handle. This is the handle. And this will give us the lambda, the code that we want to jump to. And we run the second instance of the interpreter. So far so good. Okay. Now at yield, I evaluate the argument. It should be easy. And I just return it to the resumer. You see a problem already? Well, I think where you are going, so let me paraphrase. You're saying eval is a recursive function. So when I call that return at the yield, the call stack could be full of recursive invocations of evals. So when I return here a deal, I'm not going to abandon the entire interpreter and return back to the resumers interpreter. I'm just making one jump here. So as implemented, this return is not yielding to the resumer. It is just yielding to high-level expression in itself. So if I had something like f yield 7, this yield will simply return and the next thing this function call happens. Inside the coroutine without any transfer. So this is clearly wrong because it does not yield to resumer. It only yields to whoever called it. Okay. So we could engineer it such that it does abandon the entire call stack and returns to the resumer, but then we are losing our state. Right? The entire stack is full of information that we need to continue. Right? So what is in the stack? So take a little piece of paper and assume that the execution is here. Okay? And let's assume that this is the execution stack, the call stack in other words for the f coroutine. This is for the g and this is for the k. And let's see what's on the stack. Right? The call, the entire frames including the variables that are created. This is important for us to see how we need to change the architecture of the interpreter in PA2 in order to support coroutines. So I want you to really work it out so that you understand what the state is that we keep on the stack. The two-minute investment will save you maybe hours during the project. So who is done with the exercise? So let's work through it. So how many stack frames do we have in CF? One or two? Who thinks it's one? Who thinks it's two? Both of them could be right. It really depends on how you look at it. So there are more people in two. What's in the first stack frame? The bottom one here. Both variables exist in it. Just pick up. So there is f that points to a lambda. What else? And other globals. Okay, fine. So f plus globals. What is here? c, g, x and y. Okay? And this is bound to one to two and this is pointing to... Let's show this way, right? It goes to this protein. Okay, how many frames are in the c, g? One. Who thinks it's one? Two. Three. Looks like it's two. So let's start with two. So what is in this level? So it would be x. This is the version of x in g. Yes, no? Is it this x? No. Okay, good. So this is that x. So then we would have presumably the call stack for h, right? So this is the call stack for the call to g and there is the x for... Sorry, x for y. Oh! Unbelievable. Of course we are losing everything. Thank you. Yeah, nice. It's all empty. Okay, I'll finish it at home. But we want to do... So this is the call stack for h. It contains x and y. This is then... Sorry, this is g. This one is h. X and y are here. And notice what I've done here. This one contains k. And it has, again, x and y. Okay? So what about this little piece here? What do we do with that? This is part of the execution that you should already know really well. Coroutines aside, your interpreter should be able to handle something like this. Meaning a call to m which returns provides the value. Then you need to do another call. Remember, resume is like a call.  Then you call this, it returns, gives you a value. Then you do the plus. Where will the value of m plus b be stored? Sorry, m of a and b be stored. On the cg stack somewhere. Okay, so is there going to be... Is there going to be an eval for a plus? Or are we completely confusing things here? So people are puzzled. Now I'll tell you what we need to consider. What are we drawing here, Avot? Are the frames of the executing programs, right? We create a new frame at each function call, right? And then the closures can carry it with them as the parent pointer. But when your interpreter runs, it's a recursive interpreter, right? It calls itself, calls itself, calls itself. And it is that stack that the interpreter uses for its recursion that maintains the stack that we have a hard time preserving. The frames are easy because they live in the heap, right? You just ask for another frame. That one is easy to preserve. The stacks that are important, Avot, how does the stack of the interpreter look like? When you come to g, what does it do? It has eval of some node. Then it recursively calls eval of another node and then eval of another and maybe eval of another node. So when we are here, what does the stack of this interpreter that runs gk look like? It blocks over the ast of the program, which program? The function g and it runs it, right? And it recursively calls itself as it evaluates sub-expression. So what is on that stack? Okay, so one of them is a plus, right? Somewhere, right? When we are evaluating this somewhere, all that call stack of the Python interpreter is an eval whose argument is the plus node of the ast. Its left child was the call to m, which we have evaluated. The right child is then the resume, okay? So how does the stack look like? There is a plus, there is a call to m with a and b, and here is a resume, okay? What is here? This here is a yield, right? The parent of plus is a yield. What is the parent of yield? It's inside a call to h, right? So what is a parent of g? Sorry, a parent of h, it's a call to g. Is that how your call stack looks like? You are in the process of handling a call to g. You handle then a call to h. You recursively call the interpreter. Then you want to evaluate the yield. Then the recursively calls evaluation of plus. So this is the call stack that we have a hard time preserving. If you wanted to yield at this point, you would lose the fact that you are somewhere nested in g and a. And that we need to maintain. So that call stack remembers the history of the calls. It remembers something else also. What does it remember? What if this was another call here? What if I did plus x here? That call stack also remembers the value of arguments that we want to add, right? In here, in this eval of plus, we are keeping somewhere the value of l, l, which is the value of m calls to b. So even the temporary values, the values of the left parameters of m plus b, sorry, the return value of m, b are on that stack. So here is how we do it. This is a problem with the PowerPoint. So why does it fail? Because all the content is on the stack. The content has actually two parts, the call stack so that the procedure, when it returns, knows where to go back. And there are also these intermediate values. If you do a of something and something, you evaluate this, you need to keep the value somewhere. So what changes do we make? The Python call stack keeps all the information that we need. We cannot keep it there because we would have no way to return and continue. But keep in mind that we can keep an external stack. Just build a data structure that is our stack and put all the information there. The way we do it in the assignment is that the information about calls so that we know how to return, we are going to put on an external stack. But these temporary variables, we are going to put into so-called temporary registers. These are essentially variables invented by the interpreter. So what is an AST? You know what an AST is? It's a tree that you evaluate bottom up. We'll have to translate our programs into so-called bytecode. Bitecode is nothing else but the following version of the AST. Here is our AST, a program represented as a tree. We rewrite it as instructions of the form, one argument, operand, another argument, and we store the value into some temporary invented variable. And then we can use that on the right-hand side. So bytecode is a translation of the AST into the sequence of such instructions. You see once you have such a sequence of instructions, you don't need the recursive evaluation of that AST because you are just walking through it straight and the temporary values are stored there. So the temporary value would be, say, the value of the left subtree in a plus. Once I turn the program into what looks essentially like assembly with new temporary variables with these funny names and I interpret them going through it step-by-step down, where do I keep these temporary values? Where is the value x plus z stored? It's in this register, but where is the register? Is it on the stack? We'll just put it into the environment, just like any other variable. So now the environment stores our temporary values rather than the stack. So the point is that we don't need the Python stack at all. Your interpreter now will not be recursive. It will always stay in a loop without going down into a recursive call. So you can always return from it because you will be always at the topmost level, except maybe for calling some auxiliary functions because for call and returns, you will build a stack. And for temporary values, you will just put them in the environment because we'll give you a compiler that translates from a tree into this. You would put them into the environment of the function in which you are evaluating it. You would have still frames. But frames, remember, frames are not on the Python stack. They always create them as separate objects. So they are not the problem. It is the call stack where the eval calls itself and you keep the temporary variables actually on the Python call stack. So it's just an example of how we actually translate from AST to bytecode. You just walk bottom up the AST and rather than evaluating it as you do in PA1, you spit out code. You emit code which, when evaluated, gives you the value of AST. So you produce not values but code.  So here is a little example. So I'll give you this routine a tree. It walks through it bottom up as your interpreter does. What does it do? Well, it returns two things. It returns when it's called recursively. The code could be just a string with instructions and returns a name of the register in which the return value will reside. So when you run into the tree and the tree is a plus, here is a subtree, here is another subtree. You call this recursively on this tree, then recursively on this tree. What do you get? You get two pieces of code, one another one, sequence of the bytecode instructions and you get the name of the register that stores the return value which when you're executing this has that value of AST. Now we get a new fresh register with a new name that does not conflict with anything and we create a new instruction. How? We construct this instruction here with string substitution, return value, register that comes from the left subtree, right subtree, create a new instruction, then we concatenate the code that comes from here, the code that comes from the right subtree and the new instruction that we created just here and we return also the value that we just got. At the end of the traversal, you get a huge chain of instructions that give you the value of that tree. But it's not an evaluator, it's a compiler because it generates a sequence of these bytecode instructions with just two operands on the right-hand side, no recursion, so your interpreter stays in the main loop, you can always return from it. So that's it. So in tomorrow's recitation, you'll walk again briefly over the bytecode, how does it look like, how does it generate it and the GSI will walk with you over the structure of the interpreter. How does the stack grow? How does each coroutine has its own stack so that you can get a head start on the project?


Here is Tesla again. Here is the whole dynamic of the trade, right? So here is the 457. Here is the 468. Can you stop them? Welcome to Access a Trader, the number one community for those who are committed to taking control of their trading in order to achieve success, profitability, and longevity. Thank you for joining us. Here's Dan Shapiro to help you find your edge, master your process, and own your future. Hey guys, good evening everybody. Welcome to another edition of the Access a Trader dot com nightly wrap up show. Hope everybody is doing well. So I want to start off with a very, very important area that we are kind of faced with today. So if you've been watching this broadcast and you've been hearing me moaning and groaning about why beta hasn't participated in this run, well, now there's a flip side to that, okay? You know, we felt that at any given point, there's going to be a lot of money flow that eventually is going to hit the market and all these beta names are going to wake up. Now they kind of did, right? Tesla, and we'll get to that in a second, had one of the biggest runs I can remember in a very, very long time. We'll get to that in a second. Today's other big news, the biggest school system in the world was New York City is closing down schools, which obviously led to a huge afternoon run in the stay-at-home stocks, especially Zuma. If you take a look at Zuma, for example, this was literally from, you know, this was literally from from what? From two o'clock, right? So two o'clock, they closed down the schools. Its stock literally went from like $393 to $420, huge. But again, if you look and you've been paying attention to kind of the price action for the last week or so, right? And you hear me complaining about, hey, these stocks are not participating. Like what's going on? Well now we're at the point that we are technically faced with, well, you know, kind of a line in the sand. And if you look at the queues and where they closed today, you'll see why. Again, if you're watching this broadcast today for the very first time, again, I believe that technical analysis is not a, it's not a debate, okay? Technically, when stocks trade and they trade organically and start confirming levels, usually that directional bias will take place. And again, when you have a combination of stocks just not rallying, okay, into a full-blown aggressive market rally despite the queues, right? Despite the queues been putting in, you know, higher highs and higher lows now for seven consecutive days. When you look at something like that and you have your first close today below not only the five-day moving average, but the 10-day moving average, this is a huge red flag, okay? And again, it's very, very easy to turn around and say, what's the big deal today? It's just profit-taking, but just keep this in mind. If stocks couldn't go up with the rest of the market, like your Amazon's of the world, your Apple's of the world, your Facebook's of the world, so forth and so on, right? If they didn't go up with the rest of the market, well, what do you think is going to happen if the market starts pulling in? And this is kind of where we are, right? This is where we are right deep in the sand. If you believe in the theory that the five-day moving average is acting like the shortest-term sentiment, and oh, by the way, we close below the five and the 10-day moving average, which I believe is the birth of the trade, there's a lot of sell-bys going into tomorrow's session. Now, again, nobody's turning around saying as soon as you see this broadcast, sell everything, sell everything, sell everything. But what I'm saying is, if we start confirming today's price action and the bottom of this range falls, we're going to have a lot of room to the downside. This is all it is. And again, if you believe the theory of the stocks trade from supply to supply and demand to demand, well, then you have a realistic view of where the market could go from this 290 level all the way down to this 285 level and still be on a really big, massive uptrend. So I think tomorrow's session is going to be very, very important. Again, it's just technical analysis is the most important part. Again, I have an opinion, you have an opinion, but technically, if things get damaged and they start confirming previous days' channels, usually, things are going to follow for the price action-wide. What we saw today was, again, another stalemate for the Nasdaq stocks, you saw a big reversal today in the Dow. And again, for the Dow, it's really not that much of a big deal, because if you look at the diamonds, you can make a case that, again, we are resting, but look where the diamonds closed, right? Look where the Dow closed. You had one, excuse me, more than that. You had 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12. You had 12 days in a row closing above the five-day moving average. This is the first close today below the five-day moving average. So again, guys, if you're going into tomorrow's session and you are bullish, you better hope your stocks are really taking out aggressive levels, because you have the Dow below the five, the Qs below the five. The SPX is a little bit different, right? The SPX closed below the five, but it's still above the 10. So if the SPX start losing, let's just call it 35, 60, right? If the SPX starts losing 35, 60, then again, look at how much room you have all the room all the way down to 35, 0, 2. So it's pretty important tomorrow. Again, if you are a believer of the bull market, well, tomorrow's day, the bulls better step up, but there's going to be a pretty aggressive rug pull. And again, if you're an investor and your time horizon is a year, two years, six months, then again, obviously it doesn't apply to you. If you're an active intraday trader and you trade the upside, you trade the downside, then these levels are something you're going to want to pay attention to. If you look in the video, they came out with earnings. We actually had a really aggressive pivot this morning in the video, but again, stock beat numbers, but again, got really, really sold off after the close. The big story of the day today, in my opinion, and you see why the options market really dictates what happened. So Tesla got upgraded today. Okay. And they got upgraded today from Morgan Stanley. I think it was like a $540 price target. I believe, I believe so. I don't even remember such a long, long day. And it gapped up, but it gapped up so lethargically. It was up like seven, eight points after yesterday's kind of decline, all day decline of the S&P. So we had a couple of levels in mind if the stock would actually get strong and have a one day later reaction. So we knew about the after hours high yesterday of roughly 467.5, 468. We knew about this range here, which is roughly, let's just call it 457. Everybody see that, right? 456.5, 456.05, 456.30s, 456.75. So you kind of get the picture. So it really needed to get about 457. And then you had the next level of interest roughly around the 468 area. And you just started seeing, and again, guys, this is where I really encourage, especially for all you guys who are traded and you trade these stocks, get yourself an option scanner. Like I personally use Flow Algo. It's pretty good. There's a bunch of them. Trade Alerts is really good. Cheddar is pretty decent. Flow Algo, they're all comparable. But get yourself an option scanner. Even if you do not trade options, like I'm not an options trader. But I use the order flow to correlate with my pivot. So if I'm sitting there and I'm looking and I say, wow, 468 is a really, really big area here after this range here. And I start seeing 475 weeklies, 500 weeklies, 510 weeklies, 520 weeklies, 550 weeklies. Some guy went out bet $1.2 million on the 6, I forgot which ones it was. I think it was the 615 or the 625 calls for January. Again, it's like literally holding, it's like literally holding aces. And when the options market correlates with the pivot, you're going to get a really, really great reaction. And again, it can have a res date tomorrow. It could, but those guys that were betting really serious money, especially for the weekly calls, you saw those 500s like rolling off the shelves, like it was panic buying off the 500. So a really, really aggressive day there. I thought the action today was pretty good. Again, a lot of names that probably we wouldn't trade. But now that we are getting a correlated technical view, especially in the NASDAQ 100, hey, you know, it's pretty safe to say, I think tomorrow we're going to get a lot of premium on the downside if these things start to confirm. Again, remember, this is just a thesis. Again, technically everything needs to confirm today's channel. So if we, you know, if we gap up tomorrow, we gap and go and go higher, again, remember, you could be wrong. Again, I'm wrong all the time. You could be wrong as much as possible. Theoretically, just don't be stubborn enough to forecast the trade to go in early that you're wrong financially. Let everything confirm. Believe me, these stocks are not going to run from you. If you believe that the Qs can lose the bottom range, right, the bottom of this five and 10 day range, look how much room you have. You have $6, $7 worth of downside. Do you really need to be perfect or rush into this entry? Probably not. So again, the thesis for tomorrow, I definitely like the market to confirm. If they don't, obviously we could flip around and look to the upside. So it's very, very important. And again, I would love to see a gap up tomorrow only because if the market does gap up and they get these stocks that I'm watching for tomorrow get sold into supply, right? Those are the greatest days because they get stuffed into supply. They go green to red. And once they confirm the previous days lows, which were today, that's going to start a pretty good waterfall effect. So again, my game plan for tomorrow, obviously, is probably 70, 30, 80, 20 sell bias. But again, we trade both sides of the market. It doesn't really matter. So let's talk about the pivots today. Very, very aggressive. Okay. Really, really aggressive pivots today. This first pivot, I actually, well, I don't want to say I screwed it up. So I get short zoom on the second entry and it goes down to 391. The pivot was 394. So it went down to 391, 50s, 60s, bounced around a little bit, went down to 390. I didn't make any covers. I didn't make any covers because I really thought it was going to get down to like 85, 75. Because if you look at the daily chart, you'll see what I mean, right? So I got short here, right? Got short here. So I thought it was going to get down to like 386 and then maybe 375. It never did that. Okay. So I actually wound up instead of making money on the trade. I actually wound up losing 60, 70 cents. Really, it's really not here or there. It's pretty much a break-even trade. But the point is I gave it every opportunity and it would have been nice if we would have just had that one flush into the rise in support. We'll get to zoom in a second. Obviously, a big runner this afternoon. This was a massive move. They knew, right? They absolutely knew what was going to happen with the video after earnings because you should have seen the selling pressure in the video this morning. 536 held three times in the 60 minute. If it builds below, it can flush. 532 is also going to be macro support. Look what they did to the video this morning. Just absolutely destroyed it, right? Check this out. So here was the whole channel, right? This was the whole channel right here. Here's, oh, excuse me. This whole five, everybody see this 536? 536, 536, 536, 536. It takes out 536, takes out 532 and goes all the way down to 527. Huge move on the video. You guys have caught a great job there.  Again, here's another perfect example of the market. Just not embracing many stocks when they're coming out ranges. 189 on square never got close. RL, I wasn't even watching. What did RL do today? I wasn't even watching. We talked about 84.5, 85. It looks like it went to 85 and changed. Nothing there on RL. Net, I don't think Net did anything. I don't believe it confirmed. No, Trader, I liked it at 67. Trader, 66.86. Never got there. Chui, again, once the news started breaking, on these stay-at-home stocks, they all woke up. Again, Zoom put up like a $27 candle. Chui broke out pretty nicely again. They do pet delivery, pet supply delivery. We use Chui all the time, phenomenal company. 65.30 needs to build. And once you started seeing the stay-at-home stocks wake up, this is a stay-at-home play. And here is the play here. Here's the 65.30 daily and stock traded all the way up to 67. I still like it tomorrow if it follows through. Qualcomm, nice move on Qualcomm before everything got pulled. 150 needs to build on Qualcomm. Here was Qualcomm. It took out the 150 and went to 153 and changed. So a really nice move there. And then they obviously pulled it with everything else. Fubu, I scratched on. I bought Fubu at 23 and went up like 20 cents. It just sat there, sat there, sat there. How long are you going to sit there? So I wound up scratching, went up like 50 cents, and I blew it a little bit, and then it got the stock out, killed. TTT never got to this area of confirmation. For all you guys who did take profits on this train, I didn't.  So Nvidia got murdered. Zoom, again destroyed here. This is towards the end of the day. Facebook 273, if it builds below, can flush. Here is Facebook. And again, setting up for tomorrow. So here's the 73. You can see it. Not a big move yet, but if the market confirms it's going to go lower. So 73.10 was low here. 73 was low here. 73.29 was low here. So once it started building below 73, closed under 72. First move is 70 and then 68 for more continuation for tomorrow. Yeah, and this is the one. This is the one. Again, guys, congratulations to all you guys who in this trade, who are still in this trade, who still have calls in this trade. This thing looks amazing. Absolutely amazing. Again, here's the key. This stock is so hated. There's so much short interest in the stock. The problem is all these indexes that are coveting the S&P 500, they have to be long in the stock, I believe by the summer 21st. So there's a lot of selling pressures. Shorts got triggered. Buy-ins got triggered. There was so much going on today. But once those buyers came in, it was just euphoria. At one point, it put in a $27 candle without a down take. It was unbelievable. Tesla 457 needs to build. Here is Tesla again. Here is the whole dynamic of the trade. So here is the 457. Here is the 468. And the stock went to 497. Just an absolute killer move. Again, guys, congratulations for all you guys who caught that. Highland 2630 needs to build. Not a big move. Not a big move on Highland. Traded to what? The 2680. It's nothing a big move before it relaxed. And it went down. I said 2690. It went to 2684. Again, so here is the step by take. 462 is supply. 468, huge area. Yada, yada, yada. And the next thing you know, again, weekly call buyers coming in December 500 is coming in. And basically, there was nothing left to say. Oh, my God, right? There was basically nothing left to say. So crazy move, right? Crazy, crazy move. Again, going into tomorrow, again, I have to be sell buys based on what I'm seeing on the charts. You had a huge reversal also on Boeing. Boeing was a big, big added weight for that move on the Dow Jones industrial average. But now, you know, now we're looking at a different game. So tomorrow, guys, get your, you know, go through charts, see what's sitting on rising five and 10 day supports. And if they start confirming, you know, you're going to have lower prices. Guys, have a great night, everybody. I wish you all the best. And with God's help, I'll see you all tomorrow. Take care.


Thank you very much. It's my great pleasure to introduce Dr. Meng Deng from Ag and Biological Engineering. Dr. Deng joined us here at Purdue in 2014, and I think as a theme, maybe a discussion for all of our associate professors today, very interdisciplinary. So Dr. Deng has a PhD from University of Virginia in chemical engineering, not in agricultural or biological engineering, and also works in multiple scales across engineering as well. So we will certainly hear about his research in his research focus on engineering polymeric biomaterials that facilitate and control cell responses and differentiation, particularly in animal tissues and including humans. And so you'll see some examples of that today. Dr. Deng has a passion for translating his research into functional and practical technologies that have commercial applications. And as part of these efforts, he founded a Dipo Therapeutics to commercialize some of the work from his research. He's been recognized for his entrepreneurial efforts. He was one of two more inventor fellow nominees from Purdue University in 2017 and received the Entrepreneurship Fellow Silver Award also in 2017. In addition to all of his research in entrepreneurial activities, Dr. Deng also teaches a graduate level course that's cross-listed between biomedical engineering and ag and biological engineering in the topic area of tissue engineering. And he also teaches one of the core undergraduate courses in our biological engineering program on enzyme and microbial kinetics. Dr. Deng, I'm looking very forward to your presentation and I hope you will all join me in welcoming him to the podium. Thank you so much, Nate. Thanks to the organizers for putting this together. So it's my great pleasure to be here to share with you my work in terms of developing cell-instructive biomaterials for cellular and the regenerative engineering. Given the limited time I have today, I wanna give a broad stroke what we do and how it actually combines different areas in terms of material science, by engineering, cell biology and translational medicine to move forward. Yeah, so our research focused on three thrust areas, advanced biomaterials, cell engineering and regenerative engineering. So in advanced biomaterials, we focus on rational design of new materials, new polymers, polymer composite by exploring synthetic chemistry and the study of cell-materials interactions. In cell engineering, we're interested in understanding basic cellular processes and engineering effective ways to modulate cell function. In regenerative engineering, we hope to develop biomagnetic samples for regeneration of musculoskeletal tissues, which involves bones, skeletal muscles as well as their tissue interfaces. So as you can see, there are natural synergies among the three thrust areas and our research spans from fundamental science to translational research. You're welcome to look into our research website at the regenerativemetre.com for more details about our research work. So in particularly, we're actually a more interesting understanding how different material physical chemical and cues affect the cells. So we can actually integrate the knowledge into the rational design of cell-instructive biomaterials. So just to give an example, taking our recent work in skeletal muscle regenerative engineering as an example, so we actually take the top-down-based scaffold engineering approach. We examine the tissue properties in the hierarchy structures to review the micro and the nanoscale features. So we can actually create a synthetic matrix mimic the tissue properties. In this case, we have a skeletal muscle that is made of oriented muscle fibers providing this cellular microenvironment. So actually, accordingly we can create a synthetic aligned fiber matrices that mimic that anisotropic organization of the native muscle fibers. Interestingly, we actually will see the muscle cells on this synthetic fiber matrices. The cells actually can sense the topography, align their body according to the direction of the fibers. And interestingly, this is after just seven days of culture. You can see that the robust form the mild tubes on this fiber matrices. So essentially by further actually tailoring that the fiber diameter and the structures we can, we can fine-tune the cellular response in terms of the cell proliferation differentiation for different generation applications. So next I'm going to switch gear to talk about our work in terms of dealing with the problem too much fat. More specifically, too much bad fat, too much energy storing wet fat, which leads to problems such as obesity, diabetes. So essentially in our body we have another type of fat that was discovered, is called actually brown fat or good fat.  It's part of a natural defense mechanism for protecting us in conditions such as cold. So our idea is actually to harness that physiologic differences between these two types of fat to tackle the problem in terms of too much bad fat. So essentially we have developed platform technology that is made of non-achieving nanoparticles that can be injected directly to fat to induce the natural conversion of the fat. So the nanoparticles are about 200 nanometer in diameter so actually they can get into the cells and combining this small molecule, not chipiter and polymer matrix allows to develop a standard release formulation to minimize the number of injections. Here I'm going to show you a video of the journey of engineered nanoparticles. So leverage the well-established application of injective medicines. Nanoparticles show as purple here. When the particles are in conflict with fat cells, they can actually quickly get into the fat cells. Obviously we're optimizing the nanoparticles in the surface properties as well as the size so that they can get into the cells quickly. After the inside cell, they release the drug payload, not chipiter in this case, to inhibit not signaling and promote the expression of brownie markers such as UCP1 and coupling protein one here leads to the fat cell conversion. That's our basic idea behind technology. Over the years this work is actually conducted in collaboration with Xu Hongkuan Animal Science. Over the years we have damaged the efficacy of this technology using both small rodents as well as recently large animals in pigs. So what, we have a cool technology. So this is what we learned at the NSFi Corp's kickoff meeting in Detroit. The mentor would ask, so we were so excited to share our cool technology the mentor would ask. So what, got out of your comfort zone, which is normally office. And so this is what we did. Our team consists of myself, my post-doc, goes there, as well as our business mentor, Wade. So we went out, talked to customers, which includes patients, doctors, primary care physicians, endocrinologists, physicians, as well as different companies, insurance company from two companies. That was quite intense process. So eight weeks we interviewed more than 100 customers. But the process was worthwhile. So what we learned is not only actually the discussions with those customers provide the important insights into our business canvas, but also actually helped us validate the technology market fit. So at the end, our decision was a goal. So I obtained the express license by working with OTC, those wonderful people there. We actually got that the process done very quickly at the end of December, 2016. So obviously, to be honest, I had no idea what that entails back then. But fortunately for me, as part of the Purdue EIA program, we stands for Entrepreneurial Learning Academy. So that process was quite helpful. And we obviously submitted a grant immediately to compete for funding. So luckily we received the NIH SBR grant and along with the matching fund from Elevate Venture, as well as the CEO world from PRF, which are critical to help us survive at the beginning. So we just closed our 2.2 million seed run. We're raising our serious A funding to cover the next steps in terms of our development. And it's an exciting time with Adipo. We have experienced professional team in terms of bringing different areas of activities, including technology development, business management, manufacturing, CMC, regulatory, pre-clinical and clinical development. It really takes a village. And Adipo was actually recently named as the winner of the Elevate Nexus Day-Wake Pitch Competition. Also recently submitted our phase two SBR grant to obtain non-diluted funding to support our work. And Adipo technology was also highlighted by the HPE process, one of the three technology to manage weight, especially by boosting that energy expenditure to bring that energy balance back to the normalcy. So journey continues. It's an exciting time as we continue our efforts to move the clinical translation of technology to benefit the patients. So over the course of my career, I have been so fortunate to have many great teachers in my life who helped shape my life today. So essentially the significant impacts that I received from those wonderful teachers have really made me to contribute to the learning process of others. I learned from my PhD of weather. Life is not important, except in an impact as it's on other lives. So essentially there's an old Chinese saying, give me a fish, you feed him for one day. Teaching him how to fish, you feed him for his whole life. That's essentially my belief in my teaching. I teach both graduate course and the graduate course at Purdue. At the graduate level, I teach polymer bio materials, which is cross-laced with BME. We have great added a textbook for this class and this textbook covers the design, synthesis, characterization, and application of different polymer bio materials. And over the past two years, I've been working with the Purdue online engineering team to convert this course into online hybrid version so that the students who are working in the street can also take this course simultaneously. At the undergraduate level, I teach AB370, which is biological and microbial kinetics and interaction engineering. It's a fun course and also it's great to work on new class each year and interact with them throughout the learning process. All the process there also helped me learn, improve my teaching as well, which resulted in a number of teaching recognitions. Obviously the work I present today results from hard work and the dedication of this wonderful group of individuals. So we have a diverse group of students coming from different backgrounds who always seek aspiring undergraduate students to take part in our research efforts and to enhance their learning as well, while they actually take in the courses. So here is actually an example. It was Carter and Maggie actually, were the first students I recruited at Purdue while I was still setting up the lab in Bingley. So they have worked on electro spinning, as you can see here, as well as a skeleton muscle regeneration project. And Helena was actually the biology honors student who has been with me since her freshman year has worked on own regeneration work. It's now completing her medical school at Ohio State. And this is our lab hosting the four H.E. students for Hands-On by Matius Labs. So over the years, it's really great, gratifying to see them grow and pursue their own big dreams. With that, I'd like to thank all the members of my lab and the medical team. So with COVID, this is a real picture that we have just taken. We got feedback from FDA and was of guidance from FDA on our plan moving forward. And also like to thank my wonderful mentors, collaborators and colleagues for their advice, help and support. And also I'd like to thank my funding source. Lastly, I'd like to thank my family, who else being my cheerleaders. So it's great to have their support and be here where I am today. Thank you so much. I'd like to take any questions you may have. Wonderful, are there any questions from the audience or online? Very interesting. I was wondering, since you do a lot of work on the research side on mammalian cells, how has, I mean, you're sitting in a interdisciplinary facility, Bentley by Science. And then you're also working with colleagues in animal sciences.  And how does Bentley contribute as an interdisciplinary center towards that? Thank you, Marvin. So essentially, as I mentioned, so I was setting up a lab in Bentley. So Bentley is actually a very unique place to encourage interdisciplinary research. So I like the idea in terms of no silo, right? The disciplines between science, the waters are disappearing. I mean, to tackle challenges in life science, medicine these days, you really need to have interdisciplinary team. For me, I think one of the important aspects was actually being in the Bentley, actually being able to collaborate with others who far from different backgrounds, in terms of, and also we have great Bentley Science team to support in terms of a different core facility as well, which help conduct experiments. And another thing, so while we love Bentley, I still missed the time there, but it's also exciting time for us actually to, we recently moved back to ABE building. We're on the fifth floor, which is a great facility. The collaboration synergy is just great to be able to actually collaborate with colleagues in the same department as well. I think a very important aspect in the collaboration is really that synergy among the disciplines, in our case, that we need not only the research, the tools in terms of nanotechnology and material science, but also cell biology, development biology as well as other parts in the clinical medicine to actually develop functional products that may hopefully benefit the patients in one day. I'll stop asking questions and just listen, but well, I need to lodge another complaint because every time Nate or Bernie talk to me, it says, you know, well, Meng is doing great. It's like, you don't have to tell me that. I know I'm doing okay. Says, no, no, no, you, Meng. So, you know, our names are certain similarities, but clearly your standard of excellence is way higher than mine.  One question is glad to see IEDC programs, PRF programs have been of use and congratulations on the commercialization success. Who are your customers? Thank you so much. First of all, it's just been so fortunate to be in the supportive college and also, you know, I still remember that when I first got this SBR grant, I don't know what to do, to be honest, because that takes a significant chunk of my time, you know, so to be able to do that. And really the supportive leadership as well as the department have really made this happen in terms of to allow me to actually embark on this journey. But to answer your questions about the customers, so we're actually currently based on our market feedback talking with leading physicians. So our current patient essentially are those type of diabetes who are overweight as our initial customer base. But obviously we believe the platform technology we have with other potential indications will also keep being in line as well. We have other candidate assets that also under development with IP protections that once we get this first line of product finalized secured that we'll be ready for the launch of the next generation. So are you thinking of directly selling to the end user or your direct customers will be device medical device companies or other therapeutic companies? Good question. So essentially our current plan is actually we're trying to develop assets through the approved concept clinical studies more specifically phase two clinical studies. So after that we'll actually license our technology to the big farmers in terms of as the next steps for phase three and the commercialization. We're already in active discussion with five different forms of companies of interest including Lily, Nova as well as Albee in terms of to start the discussion about collaboration, the partnerships in the future. Excellent. Any final questions online in the chat? No. All right. Thank you very much.


So then time to talk motorsports here on Highland and it's a double weekend, a bumper weekend of action to discuss. Joining me is Killian Duffy from On The Paste Note. Killian, it's good to see you. Good to see you too, Washington. Good to be back at us. Yeah, good to be back. It's been a long time. That's for sure. Well, that's a return on this weekend. Bushwacker on Saturday, Cork on Sunday. Maybe we'll touch on the Bushwacker briefly. It's based out of Oma and there's been a lot of anticipation and excitement about this one. So there hasn't there's a great entry list for it as well. Killian. Yeah, it's a great entry list for it. It was over 100 entries, I think, in about an hour for it. The Bushwacker, I've always done notes for it and it hasn't been ran in two years, but certainly the two-year break has helped the forest. They're an absolutely fantastic shape, condition-wise for the crews. Leading away is Kevin McCourt. He was the previous winner of the event. It'd be very familiar stages, although they've mixed it up. There's a good bit of tarmac in the event this year on the third stage, some long sections of tarmac. So that'll be making it interesting, particularly on gravel tires. But again, a lot of the people are familiar with the gravel parts of the stages. Pick a winner, be tricky enough. I'd say Khan McCourt has to be favored. Patrick O'Brien then is in his evil. Now, unless he appears in an R5, I know Gary Jennings is out as well. Also Vivian Hamill was out last week in Galloway Hills. Jason Mitchell knew to rally, and he won't be far away. Martina Samsonas as well from Lithuania is out doing the event. He's down in a lancer. I can't see any of the group-end sort of traditional cars matching or beating the R5 cars, even though it is a very fast event. They won't be far away. But I would say it'll be hard to look past Khan McCourt, Vivian Hamill, James Wilson even. He's done a couple of events this year. So yeah, it'll be an interesting event. Donnie Gullman obviously involved Paddy Robinson sitting with Derek McGearty. Joseph McGonigal has Mark McGehan on board in the R5 Fiesta. We can't forget about the county Trollman, Frank Kelly and his daughter Lauren Kelly. They're sitting in seated 33 for this one. But a lot of Tarong people are expecting big stuff from Mr Kelly at the weekend, Kelly. Yeah, again, he won't have it all his own way. David Crossen is showing massive speed across the water in the few events he's done. Paul Barrett, okay, he's in a historic spec car. Frank Kelly, Adrian Hedrington is in a historic car. Shane McGeart, I mean, pick a winner there. It's not easy at all. But definitely, David Crossen has been sitting at a great pace this year. So Frank is going to have it all to do to beat him. Gary Jennings is doing the Bushwacker on Saturday. He was in the entry list for Cork himself in Rory Kennedy, but that's not happening now on Sunday. But Cork 20 is back. Yes, it's a single day. They were just at nine stages, obviously, under the current COVID umbrella that we have killing and a lot of restrictions involved. But from our point of view up here, as the crews go to almost the furthest point of the country, Donna Kelly and Declan Boyle, same sort of machinery, and will they be fighting it out at the head of the field while they kill him? Hard to say, to be honest with you. It'll be like, how is the break affected people? I mean, Donna hasn't been out, I don't think since COVID. I'm sure he is a decent test on. Declan Boyle hasn't been out since Donegal 19. Again, he's in a new car. Like I would say top five or six, definitely, for both them picking a winner again, I would say Murray Evans could be the dark horse for it. He just had a win in a three-shires tournament event in the UK there a couple of weeks ago. Like he's the most match fit along with Callum Devine. Callum Devine, as well, is going to go well. He's fourth on the road. But again, he's been match fit. He's been doing a lot in Europe. His confidence is going to be up. And yeah, it'll be a good race. But again, you know, you have the moffits. You have such a fantastic entry there. But I would say Murray and Evans could be just get the jump at the start. And it might be just to him or Callum Devine. And I would say it'll be hard to stay with them. What kind of stages are these crews going to expect on Sunday and Cork as a traditional Cork 20 event stages? Yeah, well, like I suppose traditional ones, people think of is around McCroom area. Whereas this year, it's around Firmoy, Rath Cormack. And they're very fast stages and very flown bar section of the second one in the middle. That's a bit tricky and tight narrow. Generally, the rest is nice, fast, sort of smooth, flown roads. And so it'll be interesting the times that the modifies put in as well.  Yeah, we were expecting Brian Brogan and Demi McGeregan to be out in a modified escort and fighting it out at the head of the national, but quite a number of crews have new machinery. Brogan is among one of them. He's going to go on a two liter turbo Skoda Fabia, while Aiden Ray, who we know, of course, was heavily involved in the Group N cars all down through the years in the Mitsubishi. Now he's got himself a Ford Fiesta R5. He has, yeah. And actually, Aiden was out in Argyll there at Tarmac event about six or seven weeks ago in Scotland. And he had a good run there. So he's going to be confident as well. Starting again, the left hand drive, it'll take some learning, I would say, still probably with his confidence. Brian Brogan's an interesting one. All right. And the Fabia, it'll be interesting to see that car, how it handles. I mean, the Fabia, I presume it's a Super 2000 model, good handling car, particularly on medium speed corners. So it'll be interesting to see how it goes with this turbo engine in it. Yeah, that's right hand drive from as well. There's less learning. I think it's hard to get used to the left hand drive at a certain point in your career. Yeah. So who do you think is going to be there about to come to the national at the end of the day on Sunday? Gary Kernan is there. He's going to be quick. James Stafford, he doesn't seem to ever take time to get going after a long break. He just seems to be on the pace straight away. Damien Toner was out and locked all. It's hard to say. I would say, to be honest with you, probably, I would say Gary Kernan now will be, it'll be hard to live with. I mean, Chris Armstrong's there as well, but Chris hasn't been out since his big accident in Killarney a couple of years ago. So it'll be, I would say it'll be between Kernan, Stafford and Toner. Okay. And you can, of course, follow both events over the weekend with yourself. Kelly, you've got a busy one ahead of you. Yeah. If people go onto the Facebook page on the pace note, we're covering live feeds from the Bushwacker and also then Cork 20. So we haven't had a stage rally in since May of 2020. So really, I'll come forward to get back to traditional stage ends and hopefully people can tune in and follow the coverage. Yeah. Just finally then, you're on the road to Donegal today as I'm talking to you. Yes, up to do the harvest notes today. So just on the way up here, it's two stages with a shakedown on the Saturday around Donegal Town. Looking forward to seeing these stages. They're never easy around Donegal Town. So I'm expecting a bit of a day's work ahead of me. Yeah. Okay. Well, let's enjoy your time and Donegal will be speaking to you in the coming weeks again, Kelly. And thanks for joining us. Thanks, Oshin.