Hey guys, instead of wasting your eye sight on long and useless base58 WIFs which literally represent 0s in hexadecimal, let me share a little secret regarding public keys.
Here is how you can find half of your public key, it's not straight forward method but I bet many of you didn't know about it.
First we need to extract 1 and half of our public key then we can subtract our p which is 1 from it's 1.5 to get it's 0.5 half. Though we could just divide it by 2 without all this trouble, this is a hint to make you dive deeper in to this vast ocean of numbers and equations.
Target pub:
03219b4f9cef6c60007659c79c45b0533b3cc9d916ce29dbff133b40caa2e96db8
Target priv:
0x800000000000
Our multiplier inverse or not doesn't matter, +n will give you +n result and vice versa.
Scalar : aka n/2+1 half n +1 or 1 and half of n.
7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a2
If you multiply our target pub with scalar above, you will get this :
Pub2 :
02161c6cbee1483deaf6f9b395c817eb019228cda5afac5857295ba10959dffc96
Priv :
0xc00000000000
Now if we subtract target from pub2, we will get :
Pub3, half of target :
0313d1ffc481509beee68f17d8ff41c2590f4c85f15268605087eda8bab4e218da
Priv :
0x400000000000
We didn't even use division, *chop chop and good luck diving.😅
* = hurry! Get to work.
Now, if it were possible to calculate an even target pub or an odd one, then 130 puzzle could be solved in a few hours.
The tools already developed achieve these operations better...
all we need is something to work better than these tools or programs...
if we can write all these ideas out in a code and run the scripts, we would be able to work faster on the CPU 100 times faster than the codes already built to run on GPUs.
BSGS works great, Kangaroo is awesomely perfect...
these programs are great but we can programmatically edit their functions to our desires or the codes will completely break down which eventually brings us to the point where all we need is functions to calculate these operations programmatically to our own tastes and commands.
the 1s and 0s idea is a great idea that worked but still, we needed it to go faster...
the BitCrack, Kangaroo programs works super fast but what do we get when the bit ranges keeps increasing? these programs, though very fast now feels super slow because the way the keys starts to get even bigger and bigger and the ranges wider and wider which now brings us to the moment of truth...
There are only two possible explanations: either no one told us, or no one knows.
Because as we are undoubtedly gathering, the anomaly is not systemic, and it's not creating any fluctuations in even the most simplistic equations.
The problem is choice.
Our function is now to return to the source code, allowing a temporary dissemination of the code, reinserting the prime program.
Failure to comply with this process will result in a cataclysmic system crash in the brain because we won't be able to break the curve without getting to it's source.
Which brings us at last to the moment of truth, wherein the fundamental flaw is ultimately expressed, and the anomaly revealed as both beginning, and end... and the curve at one point is a reflection of another point... wherein we can call it a mirror.
There are two doors. One door is bruteforcing or as we all call it, BSGS, Kangaroo... whatever you like you can call it... and the other door is owning, buying, mining. this door only costs you some resources like money or vis-a-vis finance but the first door only gives us Hope, it is the quintessential human delusion, simultaneously the source of our greatest strength, and our greatest weakness.
