or something and so that's the best estimate of how long it took regardless of what the nan says regardless of what it looks like they did you could say well it's gonna take on average two to thirty one attempts let's just and so if any valid solution they give me I'm gonna sort of credit that with two to thirty one work so actually in the case of mine the one is the thread number and there were eight threads so this Taj Forge one NUMBER_TOKEN million so I had eight threads going in parallel and that happened to be thread one and so they all they all went about the same speed so it's really like hundred fifty four million times eight which is about NUMBER_TOKEN billion and so that's actually kind of lucky right like it should it you would you would estimate on average it would take two billion and I got in like NUMBER_TOKEN billion so like pretty good luck but within you know within NUMBER_TOKENx of what you'd expect and and since you can look at like the probability distributions of like that might be kind of interesting with the homework like okay everyone's attempt some people it takes to billions some people get lucky and it takes NUMBER_TOKEN billion some people get unlucky and it takes NUMBER_TOKEN billion and you're gonna have this sort of curve to see it but this is that's a kind of weird application of this signature forging algorithm alright it's it's sort of not what it's made for it we can have a simpler proof of work that has a specific target that's reused forever and it's sort of more universal and that it's not like oh here's this private key you know here's this key pair and here are these four signatures where are these things coming from that's weird we have to like match these weird strings of bits and stuff that's kind of annoying so it's better to do something similar but much simpler we'll just try to collide with a fixed string so there's some defined string of ones and zeroes and we just say okay well let's try to have a collision with this and the simplest is collide with zero or you could also collide with like ffff but in the case of Bitcoin in the case of many of these systems we say well let's just try to have a low number so let's interpret the hash output as an actual number in most cases do I have any cashes out here no you know it's a it's a NUMBER_TOKEN byte string and we think of it as just like here's a blob of bytes but you could cast that into like an integer right you could say oh let's let's interpret these NUMBER_TOKEN bytes as a you end NUMBER_TOKEN write a NUMBER_TOKEN bit unsigned integer and let's look for really low once and and you can do that I think with some CPUs they'll actually like let you do giant integers that way but even if not you have like some kind of big int library in your computer which just interprets it that way and says okay let's try to find collisions with zero basically let's try to find low numbers okay so this this idea there's a paper before hashcash but I don't think cache cache was the first software this idea is actually really old in NUMBER_TOKEN Adam back who still works on this kind of stuff now with Bitcoin the idea was to stop email spam which I don't know if you know in the
NO_SEGMENT_TOKEN