Bitcoin puzzle transaction ~32 BTC prize to who solves it

[_Counselor]

It is difficult to know which division is a fraction or not, because the curve sees them as integers.

Of course it's difficult, that's one reason to love bitcoin and be assured of it's security, I don't deny that. My goal is to find out what is the remainder of a fraction for different values and if there is a way to find that out, like 4501/230 =
 19.56956522, and I want to know how to detect .56956522 and extract it's representation on the curve, we have 4500/230 =  19.56521739, I want to know how we could find curve representations of :
.56956522  and
.56521739 difference between them is : .434783
Now if we could find .434783 on the curve we can potentially determine the range to solve 4501.

Everything is much simpler than it seems if you forget about decimal fractions and work with it as with simple fractions.

4501/230 = 19 ¹³¹/₂₃₀ Fraction part = 131/230 or 131*modinv(230) on curve

4500/230 = 19 ¹³⁰/₂₃₀ = 19 ¹³/₂₃

⁴⁵⁰¹/₂₃₀ - ⁴⁵⁰⁰/₂₃₀ = ¹/₂₃₀ => difference on curve = 1*modinv(230)

If you really need to find decimal fraction, just convert it to simple fraction:
0.5 = 5/10 = 1/2 = 1 * modinv(2) (or 5*modinv(10) - doesn't matter).
0.434783 = 434783/1000000 = 434783*modinv(1000000)

[mcdouglasx]

It is difficult to know which division is a fraction or not, because the curve sees them as integers.

Of course it's difficult, that's one reason to love bitcoin and be assured of it's security, I don't deny that. My goal is to find out what is the remainder of a fraction for different values and if there is a way to find that out, like 4501/230 =
 19.56956522, and I want to know how to detect .56956522 and extract it's representation on the curve, we have 4500/230 =  19.56521739, I want to know how we could find curve representations of :
.56956522  and
.56521739 difference between them is : .434783
Now if we could find .434783 on the curve we can potentially determine the range to solve 4501.

The representation in the curve in decimals is obtained by dividing N:

N = 115792089237316195423570985008687907852837564279074904382605163141518161494337

1/2= 0.5

N/2= 0.5

1/4= 0.25

N/4= -0.25

then its sequence is

(N/2)+1= 1.5
(N/2)+2= 2.5
(N/2)+1000= 1000.5

Any division of N that is less than N/2 will show its result as negative in ECC.

N/4= -0.25

you transfer it to positive like this:

N-(N/4)

additional info.

if you want to find any pubkey reflection

NM1= 115792089237316195423570985008687907852837564279074904382605163141518161494336
NM1_pub= 0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 (or -1)

pk= 5

pub-key= 022f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4

N-pk    (if you use numbers)

N-pk= 115792089237316195423570985008687907852837564279074904382605163141518161494332
N-pk pub=032f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4

or

(NM1_pub - pub-key) + 1   #(ECC)

[digaran]

I already know these things, I should provide real examples,
What I have been working on is this :
 34771879058060 /897125896 = 38759.1966892236
Of course the integer above is supposedly unknown, but dividing it would make it small, now if I know with which value should I divide n to reach that bolded part, then we could just brute force "38759" keys as the representation of bolded part on curve to be our start range, then brute forcing 38759 keys should 100% give us our target, also note that our k in this example is unknown, so you can't calculate anything based on your knowledge about the key.

[Woz2000]

@albert0bsd

Trying to understand...

Why would endomorphism not work with BSGS if I am searching the entire space?

[alek76]

Use  @alek76 github link....It is exactly the same thing  forked from Jean-Luc PONS. (I removed Printing and command line options from my binaries..)


git clone https://github.com/alek76-2/VanitySearch.git


TO make it work add in Random.cpp

#include <cstring>  (should be changed there in source)

You have in README.md how to compile exe in Windows.

p.s.
this is still in the testing phase

It's not the same! You should look carefully at the GPUEngine.cu code. Which functions were prohibited for use, and which were fixed and allowed, and why this was done.
The Y coordinate is calculated, so only the __device__ void ComputeKeys() function is used, and this is due to the prohibition of reuse of _GetHash160Comp() - to increase speed. It is better to calculate the Y coordinate once than to calculate hash160 twice (in which there are 2 functions sha256 + 1 time Ripemd160).
So what will be faster???
You need to look at someone else’s code carefully before drawing such conclusions. Is this the same thing or not?


Binary build using CUDA 10.2 Available for downloads https://github.com/alek76-2/VanitySearch/tree/main/bin

NO testing phase  

Well, if you ask why I removed the endomorphism? It is only effective for 256-bit keys, because... k1 and k2 are half the length of 256 bits (this is how they get the speedup). In this case, it is useless for solving the 32 BTC Puzzle.
With endomorphism you will search in space for 128 bits for heating an apartment with a video card  

[nomachine]

Use  @alek76 github link....It is exactly the same thing  forked from Jean-Luc PONS. (I removed Printing and command line options from my binaries..)


git clone https://github.com/alek76-2/VanitySearch.git


TO make it work add in Random.cpp

#include <cstring>  (should be changed there in source)

You have in README.md how to compile exe in Windows.

p.s.
this is still in the testing phase

It's not the same! You should look carefully at the GPUEngine.cu code. Which functions were prohibited for use, and which were fixed and allowed, and why this was done.
The Y coordinate is calculated, so only the __device__ void ComputeKeys() function is used, and this is due to the prohibition of reuse of _GetHash160Comp() - to increase speed. It is better to calculate the Y coordinate once than to calculate hash160 twice (in which there are 2 functions sha256 + 1 time Ripemd160).
So what will be faster???
You need to look at someone else’s code carefully before drawing such conclusions. Is this the same thing or not?


Binary build using CUDA 10.2 Available for downloads https://github.com/alek76-2/VanitySearch/tree/main/bin

NO testing phase  

Well, if you ask why I removed the endomorphism? It is only effective for 256-bit keys, because... k1 and k2 are half the length of 256 bits (this is how they get the speedup). In this case, it is useless for solving the 32 BTC Puzzle.
With endomorphism you will search in space for 128 bits for heating an apartment with a video card  

Sorry, but I really didn't look.I don't have a GPU here (ADLINK Ampere Altra 128-core ) so I don't even care about that part (removed all CUDA code in my version). I'm only interested in the CPU how to speed up in a specific environment targeting platform specific compiler ...I have to admit that Open SSL is very good.  

[alek76]

I have to admit that Open SSL is very good.  

To have a good probability of finding, you need a good randomness of the search. Sounds logical  . I have not studied probability theory. Previously, the program included the Mersenne Twister algorithm. The Mersenne Twister is a general-purpose pseudorandom number generator (PRNG) developed in 1997 by Makoto Matsumoto.
This algorithm is predictable, and external events are seconds of time and a hashed SEED from the command line.
OpenSSL is certainly better.

[zahid888]

puzzle: 30 frontHex: 3d94cd64 Binary: 111101100101001100110101100100        Zeros: 14        Ones: 16

puzzle: 34 frontHex: 34a65911 Binary: 110100101001100101100100010001        Zeros: 17        Ones: 13

puzzle: 38 frontHex: 22382fac Binary: 100010001110000010111110101100        Zeros: 16        Ones: 14

puzzle: 42 frontHex: 2a221c58 Binary: 101010001000100001110001011000        Zeros: 19        Ones: 11

puzzle: 46 frontHex: 2ec18388 Binary: 101110110000011000001110001000        Zeros: 18        Ones: 12

puzzle: 50 frontHex: 22bd43c2 Binary: 100010101111010100001111000010        Zeros: 16        Ones: 14

puzzle: 54 frontHex: 236fb6d5 Binary: 100011011011111011011011010101        Zeros: 11        Ones: 19

puzzle: 58 frontHex: 2c675b85 Binary: 101100011001110101101110000101        Zeros: 14        Ones: 16

puzzle: 62 frontHex: 363d541e Binary: 110110001111010101010000011110        Zeros: 14        Ones: 16

frontHex: 3aea4435     Zeros: 15 Ones: 15     Bin: 111010111010100100010000110101     Addr: 13zb1hQbWVLbiRYaoLhWuCDY7WcAw4dXF9
frontHex: 354d62e5     Zeros: 14 Ones: 16     Bin: 110101010011010110001011100101     Addr: 13zb1hQbWVnN3ag9GNS2vCraT8PQJDjVdr
frontHex: 345ccb1b     Zeros: 14 Ones: 16     Bin: 110100010111001100101100011011     Addr: 13zb1hQbWVi8cYnLyEus3LFucU535Bm52s
frontHex: 33dfe480     Zeros: 14 Ones: 16     Bin: 110011110111111110010010000000     Addr: 13zb1hQbWVBmBqFsBnFR49ZxK8A6RXeaMg
frontHex: 35e3dacf     Zeros: 10 Ones: 20     Bin: 110101111000111101101011001111     Addr: 13zb1hQbWVByHkiAWQr5wmdiSyeAzNBwEb     

 Bin: 11 1 0 1 0 1 1 1 0 1 0 1 0 0 1 0 0 0 1 0 0 0 0 1 1 0 1 0 1 
 Bin: 11 0 1 0 1 0 1 0 0 1 1 0 1 0 1 1 0 0 0 1 0 1 1 1 0 0 1 0 1 
 Bin: 11 0 1 0 0 0 1 0 1 1 1 0 0 1 1 0 0 1 0 1 1 0 0 0 1 1 0 1 1 
 Bin: 11 0 0 1 1 1 1 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 0 0 0 0 0 
 Bin: 11 0 1 0 1 1 1 1 0 0 0 1 1 1 1 0 1 1 0 1 0 1 1 0 0 1 1 1 1 
 Bin: 11 X X X X X 1 X X X X X X X 1 X X X X X X X X X X X X X X

URange : 37cac165000000000:37cac165fffffffff
FntHex : 37cac165x
Binary : 110111110010101100000101100101 num_zeros : 14, num_ones : 16
Cnditn : 11xxxxx1xxxxxxx1xxxxxxxxxxxxxx

VanBitCrackenS v1.0
Keyspace start=37CAC165000000000
Keyspace   end=37CAC165FFFFFFFFF
Search: 15 prefixes (Lookup size 15) [Compressed]
Started at Tue Sep 26 18:06:24 2023
CPU threads used: 0
GPU: GPU #0 NVIDIA GeForce RTX 3060 Ti (38x128 cores) Grid(304x512)
1108.527 MK/s (GPU 1108.527 MK/s) (2^36.14) [00:01:07 Elapsed Time][0]
[EXIT] Reached end of keyspace.

Finish at Tue Sep 26 18:07:32 2023

Lastt Found Address : 13zb1hQbQVEsGkStRa5QNndvakyhr9ji6M  36DB505C509D330C1
Puzzl Sarch Address : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so.._________________
Prfix Match Address : ^^^^^^^^ ^
Charr Match Totalss : 9
Total Found Address : 458
Total scned rangess : 58410

URange : 3967c187000000000:3967c187fffffffff
FntHex : 3967c187x
Binary : 111001011001111100000110000111 num_zeros : 14, num_ones : 16
Cnditn : 11xxxxx1xxxxxxx1xxxxxxxxxxxxxx

VanBitCrackenS v1.0
Keyspace start=3967C187000000000
Keyspace   end=3967C187FFFFFFFFF
Search: 15 prefixes (Lookup size 15) [Compressed]
Started at Tue Sep 26 18:07:38 2023
CPU threads used: 0
GPU: GPU #0 NVIDIA GeForce RTX 3060 Ti (38x128 cores) Grid(304x512)
1118.864 MK/s (GPU 1118.864 MK/s) (2^36.25) [00:01:13 Elapsed Time][1]
[EXIT] Reached end of keyspace.

Finish at Tue Sep 26 18:08:52 2023

Lastt Found Address : 13zb1hQbBpwfx2dfsz96hZc3eyBAskknZD  3967C187FFBA0F1D1
Puzzl Sarch Address : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so.._________________
Prfix Match Address : ^^^^^^^^
Charr Match Totalss : 8
Total Found Address : 459
Total scned rangess : 58411

URange : 32f0e8ce000000000:32f0e8cefffffffff
FntHex : 32f0e8cex
Binary : 110010111100001110100011001110 num_zeros : 14, num_ones : 16
Cnditn : 11xxxxx1xxxxxxx1xxxxxxxxxxxxxx

VanBitCrackenS v1.0
Keyspace start=32F0E8CE000000000
Keyspace   end=32F0E8CEFFFFFFFFF
Search: 15 prefixes (Lookup size 15) [Compressed]
Started at Tue Sep 26 18:08:57 2023
CPU threads used: 0
GPU: GPU #0 NVIDIA GeForce RTX 3060 Ti (38x128 cores) Grid(304x512)
1119.154 MK/s (GPU 1119.154 MK/s) (2^36.25) [00:01:13 Elapsed Time][0]
[EXIT] Reached end of keyspace.

Finish at Tue Sep 26 18:10:12 2023

Lastt Found Address : 13zb1hQbBpwfx2dfsz96hZc3eyBAskknZD  3967C187FFBA0F1D1
Puzzl Sarch Address : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so.._________________
Prfix Match Address : ^^^^^^^^
Charr Match Totalss : 8
Total Found Address : 459
Total scned rangess : 58412

When applying these conditions, I reduce the ranges too much. Should I have to create a pool with such stupidity?

Something interesting I found.. 

1FeexV6bAHo9rxCoRCbMbdGsVA13ca3Cc6  2B91CA5E6DE963B9F
1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF

[albert0bsd]

your first analisys seems interesting but i think that those repeated bits in some specific puzzles are just a coincide.

Lastt Found Address : 13zb1hQbQVEsGkStRa5QNndvakyhr9ji6M  36DB505C509D330C1
Puzzl Sarch Address : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so.._________________
Prfix Match Address : ^^^^^^^^ ^
Charr Match Totalss : 9
Total Found Address : 458
Total scned rangess : 58410

Charr Match Totalss : 9 ??

Only the first 7 match, with out counting the first 1, i mean it is impossible  that the first character is not 1 for legacy address P2PKH

Lastt Found Address : 13zb1hQbBpwfx2dfsz96hZc3eyBAskknZD  3967C187FFBA0F1D1
Puzzl Sarch Address : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so.._________________
Prfix Match Address : ^^^^^^^^
Charr Match Totalss : 8
Total Found Address : 459
Total scned rangess : 58411

Again only 7 match

Lastt Found Address : 13zb1hQbBpwfx2dfsz96hZc3eyBAskknZD  3967C187FFBA0F1D1
Puzzl Sarch Address : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so.._________________
Prfix Match Address : ^^^^^^^^
Charr Match Totalss : 8
Total Found Address : 459
Total scned rangess : 58412

Only 7, the thing is that all the characters need to match

1FeexV6bAHo9rxCoRCbMbdGsVA13ca3Cc6  2B91CA5E6DE963B9F
1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF

Those M aren't even in the same position, those extra characters doesn't metter, it need to match all 160 bits..

Should I have to create a pool with such stupidity?

No

[zahid888]

Should I have to create a pool with such stupidity?

No

Thank you for your suggestions. You are highly experienced, if you have ever used a method in your experience (without revealing the public key) that even slightly brings us closer to our goal, please do share it.

Edit-----------

Or any method to reach closer to pubkey

039f7bed2fb18144484a1db48d50c01e9ed80dd7a4166d7c1d2b7ca73c19d97c74  20d45a6a76753cb0a8fedc855ed3cee4705a1a3e
____________________________________________________________________20d45a6a762 535700ce9e0b216e31994335db8a5
                                                                    ^^^^^^^^^^ ^^  ^           ^   ^  ^


020b03dcc67a5279a4508319a498f529853de9c635343e6e7384e55244f73fbd12  20d45a6a764133470ef8e736e371fa347572bc35
____________________________________________________________________20d45a6a762 535700ce9e0b216e31994335db8a5
                                                                    ^^^^^^^^^^  ^   ^   ^          ^    ^  ^


0276fa074b58763dfba10124f49ee0a0e09856741a288bf9a45e6fdabc7479cd84  20d45a6a767f3f18ec9bced9cce1709114540295
____________________________________________________________________20d45a6a762 535700ce9e0b216e31994335db8a5
                                                                    ^^^^^^^^^^  ^    ^        ^   ^   ^    ^


033fe62b18c8bae2df06223b4e10cb75237a3a33650c496db4ed6d5968e7a0c8b1  20d45a6a7625d3b68c702a8b993379f0100758c9
____________________________________________________________________20d45a6a762 535700ce9e0b216e31994335db8a5
                                                                    ^^^^^^^^^^^^     ^         ^ ^       ^


033fe62b18c8bae2df06223b4e10cb75237a3a33650c496db4ed6d5968e7a0c8b1  20d45a6a7625d3b68c702a8b993379f0100758c9
____________________________________________________________________20d45a6a762 535700ce9e0b216e31994335db8a5
                                                                    ^^^^^^^^^^^^     ^         ^ ^       ^

[digaran]

I can't understand your method, why are you looking for base58 addresses, can you at least explain this non existing mathematical relation? Base58 addresses distribution  can not be determined by permutation equation.
You know what you should do? You have to explain a mathematical logic behind your method which should be reproducible and   verifiable by everyone else.
Nobody knows, maybe hash 0 famous address with all 0 characters is somewhere in 66 or 67 bit range, right?  When there is no possible way  to accurately determine that, why do you keep doing it over and over and expect a different result?

[albert0bsd]

@albert0bsd

Trying to understand...

Why would endomorphism not work with BSGS if I am searching the entire space?

Do you want the sort answer or a long answer?

I would try to explain it as simply as possible.

What is endomorphism?
According to wikipedia:

In mathematics, an endomorphism is a morphism from a mathematical object to itself.

In this case i see endomorphism as a math function that maps a public key to another public key

Examples of it ? Point negation function

Lets to said that you have a public key with some (X,Y) values, if you negate that Publickey you will get something like (X,Y2), The X value is the same value from the same point, if you negate this value again you will get the original (X,Y) values, do you the endomorphism here?

Code:

(X,Y) ->(X,Y2) -> (X,Y)

A math function that maps a value to another representation of itself.

In the case of of the Values of lambda and beta we have that:

Code:

Q * lambda = (x * beta mod p , y)

Q is a publickey and (x, y) are their independent values.
Q * lambda is a Scalar multiplication (It is some kind of expensive operation)
In the other hand x * beta is just a regular multiplication.

Code:

(x,y) -> (x * beta mod p , y) -> (x * beta^2 mod p , y) -> (x,y)

Now is it possible to apply this to BSGS? I've thinking a lot this and for BSGS the endomorphism is useless because, if you are working in a Baby table from 1 to N, the baby table for endomorphism  will be from
1*lambda , 2 * lambda , 3 * lambda , ... N * lambda.

and then you may need to add the x*beta to all your Giants steps (This will reduce the speed a little), But in any case, lets to said that you are going to hit the key with the regular BSGS process, that means that you are going to hit the key with the BSGS-endomorphism. So see it? it is useless if you are going to find the key with regular BSGS, why overcomplicate a process that actually is complicated?

[zahid888]

I can't understand your method, why are you looking for base58 addresses, can you at least explain this non existing mathematical relation? Base58 addresses distribution  can not be determined by permutation equation.
You know what you should do? You have to explain a mathematical logic behind your method which should be reproducible and   verifiable by everyone else.
Nobody knows, maybe hash 0 famous address with all 0 characters is somewhere in 66 or 67 bit range, right?  When there is no possible way  to accurately determine that, why do you keep doing it over and over and expect a different result?

Look closely, I am working with artistic binary, not with base58, Ripemd160, decimal, or hexadecimal. and just print output in any format, If you have any output result even in any format, please show us. 100% of people are trying randomly even in 130 also, and I am also trying randomly, but with some logic. You are a master of mathematics, so you can solve 130 directly even with your mobile. All the best!

[Woz2000]

@albert0bsd

Trying to understand...

Why would endomorphism not work with BSGS if I am searching the entire space?

Do you want the sort answer or a long answer?

I would try to explain it as simply as possible.

What is endomorphism?
According to wikipedia:

In mathematics, an endomorphism is a morphism from a mathematical object to itself.

In this case i see endomorphism as a math function that maps a public key to another public key

Examples of it ? Point negation function

...deleted...

Thanks for the explanation. I was only thinking of it in terms of it generating the extra addresses/points. I didn't think about the BSGS process. This makes sense.

[alek76]

////

Do you know how any linear function differs from the sha256 and Ripemd160 functions? All your calculations make no sense, because... The output value of sha256 hash and Ripemd160 hash changes completely even if 1 byte of the input data changes. Points on a curve can be counted - these are linear calculations (addition and modulo division). And everything else that is obtained after hashing with the sha256 and Ripemd160 functions becomes non-linear data. Please clarify this!!!!!!!! The entire topic was filled with these useless calculations. This can be regarded as spam, because... you have many similar messages.

[alek76]

Look closely, I am working with artistic binary, not with base58, Ripemd160, decimal, or hexadecimal. and just print output in any format, If you have any output result even in any format, please show us. 100% of people are trying randomly even in 130 also, and I am also trying randomly, but with some logic. You are a master of mathematics, so you can solve 130 directly even with your mobile. All the best!

Then you should go to an art school to teach 

[albert0bsd]

The entire topic was filled with these useless calculations. This can be regarded as spam, because... you have many similar messages.

I already said that before but people  keep writing a lot non-senses, keep quoting entire long mesages just to write one single line.

https://bitcointalk.org/index.php?topic=1306983.msg62842432#msg62842432

Anyway...

[Woz2000]

I have several people on ignore.

So now have to figure what to do with those long quotes of the ignored. lol

The entire topic was filled with these useless calculations. This can be regarded as spam, because... you have many similar messages.

I already said that before but people  keep writing a lot non-senses, keep quoting entire long mesages just to write one single line.

https://bitcointalk.org/index.php?topic=1306983.msg62842432#msg62842432

Anyway...

[digaran]

You are a master of mathematics, so you can solve 130 directly even with your mobile.

Jokes aside.

Look closely

I want a working equation, this master of mathematics has no clues what you are talking about. You should forget about previously solved puzzles, it's not like the author designed the whole elliptic curve, hash functions and then applied your logic to create this puzzle with some sort of pattern to test our IQ level and gift us some candy.


Why are you looking in 66 bit space? You know there are 2^96 ( 79228162514264337593543950336 ) exactly identical bitcoin addresses just like #66 address?

If you are curious about finding collisions, start by searching in 256 bit, maybe you get lucky and find a private key/ address collision where different keys can open the same address.
Your artistic binary method ( whatever that even means ) is beyond my level of understanding.

Did you even know solving 130 give or take is as difficult as solving 66? So instead of going after 66, start working on public keys, I haven't seen anyone post something interesting about their discoveries while working on points.

I have posted a few proof of concept python scripts, it's the result of community's collective effort ( right, 🙃, just a few), since you are spending your time anyways, at least work with them and share your findings.

[zahid888]

////

As I mentioned before, I also use random numbers, just like others do. However, what you are doing in your 'random.cpp' involves seeding, twisting, doubling, and including 'rand.h,' which has already been created by someone else.

It uses many old and common methods for generating random numbers, which have been tried by many over the years. Unfortunately, there haven't been any positive results, and the only method that seems to work is brute force. Yet, you continue to use these methods instead of exploring something new. Just as some people are asking why I keep doing the same job repeatedly, I can also ask why you keep using the same old random methods repeatedly.

If someone attempts to innovate, you suggest they go to art school, taunting them in the process. I'm not here to teach anyone; I'm simply sharing my experiences with these so-called 'random' methods and my own random formula.
for your information.
When I was working on puzzle 64, I've come close to solving it using what you call 'cheap art' as random numbers. Right now, my 'cheap art' has brought me closer to possible keys for puzzle 66. And how am I able to differentiate between the two random methods? Because I have saved the analysis of the initial 8 hex (4 bytes) generated through both functions in my local database, and I have managed to obtain matches through my random method several times (3 or 4 bytes), whereas with the old random method, I have hardly obtained a match of (2 bytes). If puzzle 62 hasn't been solved yet, I've managed to solve it twice with my 'cheap art' through 14 zeros and 16 ones. My script skipped it 2 times because the range was already in the database, and I saved the skipped range also to study how randomness works. I'm not blindly running code like the so-called 'copy-paste' programmers.

Once I've achieved the 14:16 pattern and saved and merged my database, then I'll invert it and try more combinations. I also have ten more unique methods that I haven't shared yet. These methods are far better than the older random techniques that couldn't produce even three matching bytes of the private key hex in months, or even years.

As I mentioned earlier, I'm not here to teach anyone, just to share my experience whether it's the worst or good. These are common factors that cross everyone's minds to compare their results with something that exists, whether it's Ripemd160 or Base58. That's why I always share information related to these topics. That doesn't mean my calculation is totally dependent on these things. You may call it spam or anything else you like. The only difference is that I am using a different method to generate random numbers, which I prefer over the old methods, so please stop repeatedly giving me advice on this topic. I am well aware of non-linear or linear functions; please don't attempt to act overly intelligent. And I don't need advice from 'copy-paste' and renaming enthusiasts.

I have several people on ignore.

this is a good idea if my posts are irritating someone.

this master of mathematics has no clues what you are talking about.

This is the reason why I write long posts, so that they can penetrate people's minds without explaining much. But it's the sheer bad luck of some people that even after that, they can't understand properly. And people scold me, asking why I write such long posts... lol  . Here, I'm just reducing the possibilities from nearly 100% to 27%, you can try it yourself.

Code:

import math

def binomial_coefficient(n, k):
    return math.factorial(n) // (math.factorial(k) * math.factorial(n - k))

start = int('20000000', 16)
end = int('40000000', 16)

zeros = int(input("Enter the number of zeros (0-30): "))

if 0 <= zeros <= 30:
    total_possibilities = end - start + 1
    possibilities_with_zeros = binomial_coefficient(30, zeros)
    percentage_with_zeros = (possibilities_with_zeros / total_possibilities) * 100
    percentage_diff = 100 - percentage_with_zeros
    print(f"Total possibilities within the specified 30-bit range: {total_possibilities} (100%)")
    print(f"When applying {zeros} zeros within the range: {possibilities_with_zeros} ({percentage_with_zeros:.2f}%)")
    print(f"Difference between total possibilities and applying condition: {total_possibilities - possibilities_with_zeros} ({percentage_diff:.2f}%)")
else:
    print("Invalid input. Please enter a number between 0 and 30.")

Seriously, how much am I talking, that's why I try to explain it in the language of coding. My fingers are tired . Smarter people can kindly put me in their ignore list or create a new thread (I think there are already 2 more threads). You can go there, I won't be coming there. I'll just continue my nonsense here. Thank you very much, everyone👍