 So, hi, I'm Nathan, hope everyone's enjoying the room session this evening. I'd like to talk about a recent work called SecureMPC, laziness leads to God, and this is joint work with other folks at UCLA. And despite the title, I have no intention of making any sort of philosophical statement. The point of this talk is to basically introduce a new model of MPC called lazy MPC and motivate it. So in SecureMolody Party Computation, you've probably seen this many times before. A bunch of parties, they have inputs, they want to compute some function on their inputs, and so they execute some protocol and at the end of the protocol, each party should only learn the function evaluation on the inputs and not any of the other party's private inputs. And in traditional MPC, what happens if a party aborts? Well, in this case, the party is treated as a corrupted party. And we consider this problematic for several reasons. In particular, this is unrealistic in many settings. So in particular, if we treated an aborted party as a corrupted party, we're treating them as this like adversarial party that's colluding with other parties, et cetera, when what actually happened, maybe the power line got taken out and they simply lost connectivity and that's why they're not responding. And so in situations like this, I guess as our president would eloquently put it, there is quote, no collusion. So the purpose of this work was to try to motivate, or sorry, was to introduce this lazy MPC model. So there are various reasons why honest parties may abort. So the previous slide, I detailed connectivity as a potential issue. Other reasons, maybe a certain message requires a lot of computational resources to compute and a certain party is unable to compute it if they have a weak computational device. Or maybe they simply stop caring about the output of the protocol and decide to stop responding. And in these instances, it would be nice if the parties that do care about the protocol and remain are able to compute something meaningful. And so how do we model lazy MPC? Essentially, in traditional MPC, there are honest parties and corrupted parties. And in lazy MPC, there's a third type of party which we're calling a lazy party, which is basically a party that behaves honestly but may decide to abort at some point in the protocol. And in this work, we focus on the standard broadcast model, and we have any party that aborts, we assume it never returns. And another interesting line of work would be to consider a model where boarding parties may return in the future. So basically, there are two phases to a protocol, an input-commitment phase, essentially in this phase. It's independent of the function, parties commit to the inputs, and then the parties execute a computation phase. And if enough parties, essentially the guarantee we want is if enough parties remain at the end of the protocol, all parties should be able to recover the output, which is defined as a function evaluated on the inputs that we're committed to. And we obtain some results, and particularly get some three-round semi-malicious secure lazy MPC in the plain model, and we can obtain malicious secure in the CRS model. And then if we view our lazy MPC protocols in the standard traditional MPC model, we're able to obtain round optimal maliciously secure MPC in the plain model with guaranteed output delivery. So if anyone has any more questions about the model or would like to discuss alternatives to the model, feel free to talk to me afterwards. Thanks.