 I'll be talking about lockable obfuscation. So as we know, in the past few years, we have seen that indistinguishability obfuscation has been really powerful, with it being labeled as the holy gilder of modern cryptography. When obfuscation was introduced, it was not known that whether obfuscation could be constructed for general programs. And Barakinov showed that virtual black box obfuscation is impossible. But with the introduction of indistinguishability obfuscation, since in the past few years, we have seen tremendous attention by the cryptographic community in the area of indistinguishability obfuscation. Starting with the work of Sahay and Waters, we have seen how indistinguishability obfuscation could be used to solve various open problems in cryptography. Now, as it turns out, the power of indistinguishability obfuscation has been exposed. But we don't have any constructions of IO from standard assumptions. Now, if all the constructions of IO, they are mostly built upon what's called multi-linear maps. And as it turns out, multi-linear maps have a tax and we have seen a steady stream of trip analysis on multi-linear maps. In this work, what we try to do is that we try to see. We want to anchor ourselves to a standard assumption, which is learning with errors in this case and try to see what can be explored in the area of obfuscation and different applications that we can achieve from this standard assumptions. To that end, we introduce a new primitive, which we call lockable obfuscation, which is not general purpose obfuscation, but a very short indistinguishability obfuscation that I primitive for certain class. And formally, the results that we show are, so let me first tell you what lockable obfuscation is. Now, in mostly obfuscation, what we have is that we have two algorithms, obfuscate and eval. The obfuscate algorithm is going to take only a program as an input. And it's going to give you an obfuscated program, which you can evaluate and learn the output of the program on it. However, in lockable obfuscation, it takes us input a program, a message that we hide inside this obfuscated program, as well as a special string, which we call the lockstring alpha. And now the evaluation algorithm, it just takes us input the obfuscated program, an input x, and it outputs either the message that was hidden inside the obfuscated program or a special reject symbol. Now, the correctness condition that we require from a lockable obfuscation scheme is that, if you try to evaluate the obfuscated program on an input x such that output of the program that was obfuscated on the input matches the lockstring alpha, then you get the message. Otherwise, the evaluation algorithm, it just outputs the special abort string. Now, it turns out that it might not be very useful. So let's see what kind of security guarantees it requires for this. So the security requirement that we want from a lockable obfuscation scheme is that the obfuscated program, it should not reveal any information about the program that was obfuscated in, or the message if the lockstring alpha is chosen uniformly at random. Now, it turns out that this might not be very useful. However, in a work that will appear at Fox, we show that we can construct lockable obfuscation scheme for all policy circuits from the standard LWU assumption. And it turns out that it leads to a wide variety of applications which we didn't knew how to construct. The only new constructions of all these primitives or all these applications from indistinguishability obfuscations. So we were able to show that how we can move some applications of IO to standard assumptions by using this primitive of lockable obfuscation. The applications are trying to convert an attribute-based encryption scheme to a one-sided predicate encryption scheme, getting some uninstitutional results in the circular separations, as well as some random-autical uninstitutional results, and getting anonymous broadcast encryption from broadcast encryption. The remaining just 50 seconds, I'll quickly tell you about how to use lockable obfuscation. So I'll just quickly, in one slide, try to describe the main application, which is to get one-sided predicate encryption from attribute-based encryption. In attribute-based encryption, we want decryption to work on ciphertext, such that if you have the secret key that can, so when you encrypt a message, then it also takes some attributes. And if you have the secret key, which is associated to a policy, you can decrypt it if the policy satisfies those attributes. Now, in predicate encryption, we also want to hide the attributes inside the ciphertext. The idea is that the setup and the entry generation algorithm will work as before. Only in encryption algorithm, we first choose a random lock. We encrypt it using the same underlying attribute-based encryption scheme. Now, we encode this. We hide this ciphertext that encrypts a random lock inside a program. And we obfuscate it using the lockable obfuscation. And the message that is inside this obfuscated code is the message that we want to encrypt. And to decrypt, we just simply use the secret key. And so please look into the paper if you want to look at how this really works. And just to show how this is really powerful, yeah, I'll just finish it very quickly. So this is one example where we see that we can really move all the number of IO applications to lockable obfuscation. Because this is an application of IO. And we simply use a similar program. And it turns out that we can get this application using lockable obfuscation. Thank you.