Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 318. (Read 240068 times)

Whats the range for the 60th address? Need to upgrade my blind monk script

It’d be a dream to crack this but I have neither the technology nor technical know how to be able to achieve it.

Whoever does it is a lucky guy.

For those who are curious, here's an update on the cracking pool.

This has been on the back burner due to a general lack of interest. I've repurposed the majority of my computing power to more useful applications. The public website is nearly complete now, I'm expecting it to be live today. If I see that interest has increased and people start to join the pool I'll reallocate some of my systems and time for this purpose.

I know it's been said already but to those of you who are posting these giant walls of numbers and analysis you're wasting your time. The only way these wallets will be cracked is by brute force. If you manage to find a flaw in the process used to generate random addresses you'd be much better off focusing on a larger payout. That being said, if you do manage to come up with a solid theory but lack the capacity to test a certain keyspace, post it here. I'll run it for you and even let you sweep the wallet yourself if you prove to be correct. The conjecture is ugly to try to read here and generally irrelevant nonsense.

There are some shortcuts in curve generation, that's why point are generated in large batches.
But due to the next steps, that make hashes, other operations are calculated individually.

Maybe authors of Bitcrack, vanitygen have mislooked something else, but this optimization
should be not in stupid walls of numbers, but somewhere in the code of bruteforcer.

Because it can be an digital analogue of a "black hole", if we can take the first 100-200 digits of the multi billionth trillion num... and fly in power of 2 at the "speed of light"))

2^115792089237316195423570985008687907853269984665640564039457584007913129639936 (the first 100-200 numbers of a huge number)
2^115792089237316195423570985008687907853269984665640564039457584007913129639937 (the first 100-200 numbers of a huge number)
2^115792089237316195423570985008687907853269984665640564039457584007913129639938 (the first 100-200 numbers of a huge number)
2^115792089237316195423570985008687907853269984665640564039457584007913129639939 (the first 100-200 numbers of a huge number)
...

and at the same time we can accelerate even more skipping any number of steps the farther to infinity, the greater the chance of getting the desired number.

why are you trying so hard to find a pattern where there are none?
this is not even "exactly a puzzle", i think you are misled by the choice of words by the starter. all these numbers you are trying to find a pattern for are chosen using a cryptographically secure pseudorandom number generator which has no pattern, if it did then it would have never been "secure" and should be considered broken.
the whole purpose of this is to show the strength of bitcoin private keys which are 256 bits. so far so much computing power has been wasted and they haven't even covered more than 4.9e-58 percent of it (that is 4.9 * 10^-58)

Would probably join the pool if cpu's are okay - no nifty vid cards but a pile of old comps just sitting around, pi's etc..  but avoided it because i don't feel like downloading one more program to like telegram. partly just ugh, at the thought, partly too many other things going on.

Bitcrack creator would add the function of reading the number from the file (selectable length is 18..77,77,78) so that you can take such files https://www.mersenne.org/primes/ and check them as addresses, there is the last 2^282,589,933 ~24mb (I merged the lines there and drove half of them along 78 addresses, I did not find anything, parallel to 18 long pass, and then, from the back side will go 123...321...). And if add the ability to generate large power of 2 generally it will be great. Otherwise we have to ask for Arulbero with its 64 gigabytes of memory to generate us .txt files from 2^17592186044416 (on google drive drop) in PARI/GP.

a little information about 2^ (we specifically do not need prime)
https://www.youtube.com/watch?v=pKwsPBeSiOc
https://www.youtube.com/watch?v=vetsor9NTF8
https://www.youtube.com/watch?v=lEvXcTYqtKU
http://earthmatrix.com/binary/system.htm

https://interestingengineering.com/japanese-kids-learn-multiply-using-line-counting-trick
it is interesting if you count in binary representation but we probably can't get anything from there for our purposes.

I don’t know what to come up with to calculate the giant numbers, if so many people with 10 higher education did not come up with anything)) Try to identify the sequence (which someone has probably already tried). For example, take numbers from 000-999 (all numbers consist of 1234567890, further combinations 00-99, 000-999, .. 000000-999999 .. and so on). We take 000-999, we ring our power of 2 (so that the starting and ending numbers connect to bagel), take 360 degree circle (where there will be both degrees 360 and our numbers 000-999), next, write out all triple matches with their degrees. Ie if we look from above, there will be a (expanding) circle, if there is a growing cone on the side. And depending on what combinations of numbers will fall out as the degree of 2,4,8,16,32,64,128 grows, we try to see the pattern.

Has anyone been accepted on the Puzzle Hunter Pool telegram??

Is it a problem to give the source of CrackBit to the archive with shit?

----
...except for the subject - I try to make BitCrack cooperate with this Hashtopolis, as it was suggested earlier, and now it does not speak, but I can not do it because it requires modifications. Is there anyone who would be able to do it for a fee here? If so, I invite you to join PW in order to reach agreement. In addition, there will be a bonus if I manage to find the right key for every next wallet in these puzzles as the first.
Currently I have configured the API server and the problem lies on the "client" side where after downloading the API, the downloaded BitCrack and ... the end because it is given commands from HashCat that will not work. Substitution of commands is not enough (I suspect that this is because I am totally an amateur from Hashcat).

Anyway maybe that makes sense to reduce the volume of addresses being searched. We can preselect all double matches from 2^2 to 2^16384, from 000001 to 999999, to boldly use the space up 2^16384. The first we know 288230 to 576460. For Part 3, the same variability of coincidences as for the two is distributed. If the first does not coincide with the second in a certain space, then it does not coincide with the third as well as the second with the third. Therefore can take 288230 + blabla + blabla, blabla which are not in those addresses that we drop.

 
288230 + blabl1(-drop) + blabl1(-drop)
288230 + blabl1(-drop) + blabl2(-drop)
288230 + blabl1(-drop) + blabl3(-drop)
...
288230 + blabl2(-drop) + blabl1(-drop)
288230 + blabl2(-drop) + blabl2(-drop)
288230 + blabl2(-drop) + blabl3(-drop)
...
288231 + blabl1(-drop) + blabl1(-drop)
288231 + blabl1(-drop) + blabl2(-drop)
288231 + blabl1(-drop) + blabl3(-drop)
...
288232 + blabl1(-drop) + blabl1(-drop)
288232 + blabl1(-drop) + blabl2(-drop)
288232 + blabl1(-drop) + blabl3(-drop)
...

In this way, can search for Satoshi addresses, 78:6=13.

114316678280891804995523418509491057753329410818141542253734500471810132820688 1CHKGF3SsDLK3djn6E8jUkjuwcgPKMyc34 17cojTmUrAofenxVSB5BhSvZM61iMPCrzd
114316260673220778268790230044278609268507534811910719820562753639543748782835 1AEqg7kTHmLho5PcF9tPVZhhnQ6tmfUTha 1LpADvJHv1odfkWxXxzccqZ8viBNkFhnHy
114316452646018272683475381526695091171425943777328474335018802849693380444001 18upKC5M91ypuRKzeJWkgGqZf1d1TpsE2F 1LoCCvHWDNHSYYmNNczS7sLYQCvJmPWdtm
114316625178452460115813013373580331434373522159645941409868415734332300148981 1PGXnFaQYgrt3qGaJZYGtwDj8FGHzrQkQL 1NZDn5NPAmtgDPLAegZRkMUfLSsRbdnAtS
114316904686872180867719739744819328776352362511332360202616099091238249076764 1KCvqGifTqgfhgr36JXjY9j9xfrttqJJSe 13FMzY25nL9z19DzbnSAJZ9s3C2Nsv3YiY
100235088372727205216482572769683692690495080675055786504559914586112624555718 1Kx65vMycF29aho4732Q3QzVe6SPsxKhDk 18K2zfmfKaitvS1rXRn3w3sq3wSHHa6SMr
100235527728515171422893936559947349135600554688646401128675966128331072713446 1N4Tc4pWXegZrZKcNHRy6FQaqMnyqK1yXM 145NB2fvU9MYVMTJ567PcXuNikR95vDJmX
100235723673589086620306468291281640667774197889575061424929696336978686441984 14GjH3Txb7e7Z1FKnJDkvdjmCJKvzv2EE7 1LEU3HxJG9WzS5BTfQeBSK8V3yVjjfKVUC
100235635271122069407191662505452274854151459486808625334955067680197890775655 12Vm8sExTCTS32L8YxghS8EBV4rcuBZxkp 1KE1ezfgMt1qGLDkq8vqkUNB3dLDPZqmTS
100235202398033455327631709491786847917683923094331177537179646806329369617010 1FG7VwA2meYBaLSGbwBseCyMUYNJgZ452E 18TmNBvQtDXm5QjCR6r7pY5HSQd29bzJbC
100235093529756268710420280488109144495848453137385895680900086092684317815814 1DN8sByU9PVz52SDPZakFfYVLPmrUkX6ro 1NPbvqfZzxJKc86kP2bPW4z6iM5Wv5y7aP

Another scan variant is to take a fixed position degrees

blabla=115000
blabl1 = 15
blabl2 = 2
blabl3 = 1
blabl8 = 5
...
123456789...position (blabl2 = 2)
65536
4294967296
18446744073709551616
340282366920938463463374607431768211456
115792089237316195423570985008687907853269984665640564039457584007913129639936
13407807929942597099574024998205846127479365820592393377723561443721764030073546976801 874298166903427690031858186486050853753882811946569946433649006084096
...
random walks 2^2 - 2^16384, positions remain.
scan (blabla+blabl1+blabl2+blabl3+...blab12)
scan (blabla+blabl1+blabl2+blabl3+...blab12)
scan (blabla+blabl1+blabl2+blabl3+...blab12)



Well, the variant that was already mentioned is just a bust with a cognitive shift, but we cannot find out what the numbers will be in large degrees 2^18446744073709551616. But given the fact that they are all repeating in infinity)), maybe something will jump out.

(Imagine that this is a 77-78 digit number.)
115792089237316195423570985008687907853269984665640564039457584007913129639936
115792089237316195423570985008687907853269984665640564039457584007913129639936
115792089237316195423570985008687907853269984665640564039457584007913129639936
115792089237316195423570985008687907853269984665640564039457584007913129639936
115792089237316195423570985008687907853269984665640564039457584007913129639936

***

Well, going back to wandering in a puzzle  in continuation https://bitcointalksearch.org/topic/m.48644494

If 59 turns out to be among 390000000000000000-554000000000000000 Quite interesting where will be 60.

10001010 01000011 11100110    10001010 10100111 01001110    10001101 01011011 00111110   
10001111 10101000 10111011    10010011 00101010 11110111    10010011 01111101 00100001   
10010100 00111010 01110000    10010100 01101001 10010100    10010011 11111111 11101110   
10010111 01001011 00110011    10010110 10010100 01010111    10010111 00011110 00000101   

10001010 11011001 10100000    10000101 10111001 01100011    10001010 00100010 00111110
10001111 01000000 01011100    10010000 01100010 11011010    10010001 10011111 00100001
10010101 01100111 11000100    10010100 11010111 00001101    10010100 11010111 00001101
10010110 11001110 11110010    10010110 11100000 11011001    10010110 10100010 00010000

60 15,... 1152921504606846976 - ((((((((((15,9456789 * 128) * 128) * 128) * 128) * 128) * 128) * 128) * 128) - 1143914305352105984) * 128) =

10001110 570000000000000000 - 640000000000000000    9 low  15,93
10001101 640000000000000000 - 710000000000000000    9 low  15,92 15,93
10001100 700000000000000000 - 770000000000000000    9       15,91 15,92
10001010 810000000000000000 - 882000000000000000    9       15,90 15,91
10001001 880000000000000000 - 943000000000000000    8,9    15,89 15,90
10001000 940000000000000000 - 1010000000000000000   8      15,89
10000111 1000000000000000000- 1070000000000000000  8       15,88 15,89
10000110 1060000000000000000- 1130000000000000000  8 hi   15,87 15,88
10000101 1120000000000000000- 1160000000000000000  8 hi   15,87

576460752303423488-1152921504606846976

Will there be a match 10001010 or include other bytes 10001100 10001001 10001000 10000111 10000110. Here the approximate space is obtained 700000000000000000-1070000000000000000, maybe up to 1130000000000000000 will go.

Lol. I remind you once again that the private key does not result from any algorithm. It's located at 2 ^ 59 and only this rule applies here.
--
Umadbro I joined your channel for a telegram but there's nothing there ... and what? I wanted to connect or ask for the configuration of the hashtopolis in exchange for some benefits for you for facilitating my control over searching for a key :-)

If left to right go, they should have already found (if the speed did not fall).

***

A little thought ...

On the example of the number of 12 characters 100251560595. We divide it into 2 parts of 6 characters. 100251 560595. Looking for a big number 2^... when both parts are in it. this 2^19445 [5, 3889.0] length 5854 characters. Means all previous 2 ^... it can be used to find all degrees with the first 6 digits 100251, from 2^2 to 2^19445, their

100251 286 [2, 11, 13.0] < 2^ fac search | num length > 87
100251 3276 [2, 2, 3, 3, 7, 13.0] < 2^ fac search | num length > 987
100251 4966 [2, 13, 191.0] < 2^ fac search | num length > 1495
100251 5391 [3, 3, 599.0] < 2^ fac search | num length > 1623
100251 5691 [3, 7, 271.0] < 2^ fac search | num length > 1714
100251 5875 [5, 5, 5, 47.0] < 2^ fac search | num length > 1769
100251 6504 [2, 2, 2, 3, 271.0] < 2^ fac search | num length > 1958
100251 7389 [3, 3, 821.0] < 2^ fac search | num length > 2225
100251 7426 [2, 47, 79.0] < 2^ fac search | num length > 2236
100251 8168 [2, 2, 2, 1021.0] < 2^ fac search | num length > 2459
100251 9202 [2, 43, 107.0] < 2^ fac search | num length > 2771
100251 9307 [41, 227.0] < 2^ fac search | num length > 2802
100251 9422 [2, 7, 673.0] < 2^ fac search | num length > 2837
100251 9788 [2, 2, 2447.0] < 2^ fac search | num length > 2947
100251 9892 [2, 2, 2473.0] < 2^ fac search | num length > 2978
100251 9965 [5, 1993.0] < 2^ fac search | num length > 3000
100251 10025 [5, 5, 401.0] < 2^ fac search | num length > 3018
100251 10469 [19, 19, 29.0] < 2^ fac search | num length > 3152
100251 10852 [2, 2, 2713.0] < 2^ fac search | num length > 3267
100251 11071 [11071] < 2^ fac search | num length > 3333
100251 11591 [67, 173.0] < 2^ fac search | num length > 3490
100251 11803 [11, 29, 37.0] < 2^ fac search | num length > 3554
100251 11906 [2, 5953.0] < 2^ fac search | num length > 3585
100251 11925 [3, 3, 5, 5, 53.0] < 2^ fac search | num length > 3590
100251 11981 [11981] < 2^ fac search | num length > 3607
100251 12056 [2, 2, 2, 11, 137.0] < 2^ fac search | num length > 3630
100251 12365 [5, 2473.0] < 2^ fac search | num length > 3723
100251 12384 [2, 2, 2, 2, 2, 3, 3, 43.0] < 2^ fac search | num length > 3728
100251 13007 [13007] < 2^ fac search | num length > 3916
100251 13017 [3, 4339.0] < 2^ fac search | num length > 3919
100251 13174 [2, 7, 941.0] < 2^ fac search | num length > 3966
100251 13202 [2, 7, 23, 41.0] < 2^ fac search | num length > 3975
100251 13232 [2, 2, 2, 2, 827.0] < 2^ fac search | num length > 3984
100251 13320 [2, 2, 2, 3, 3, 5, 37.0] < 2^ fac search | num length > 4010
100251 13334 [2, 59, 113.0] < 2^ fac search | num length > 4014
100251 13354 [2, 11, 607.0] < 2^ fac search | num length > 4020
100251 13410 [2, 3, 3, 5, 149.0] < 2^ fac search | num length > 4037
100251 13507 [13, 1039.0] < 2^ fac search | num length > 4067
100251 13648 [2, 2, 2, 2, 853.0] < 2^ fac search | num length > 4109
100251 13772 [2, 2, 11, 313.0] < 2^ fac search | num length > 4146
100251 13845 [3, 5, 13, 71.0] < 2^ fac search | num length > 4168
100251 14005 [5, 2801.0] < 2^ fac search | num length > 4216
100251 14354 [2, 7177.0] < 2^ fac search | num length > 4321
100251 14573 [13, 19, 59.0] < 2^ fac search | num length > 4387
100251 14617 [47, 311.0] < 2^ fac search | num length > 4401
100251 14996 [2, 2, 23, 163.0] < 2^ fac search | num length > 4515
100251 15196 [2, 2, 29, 131.0] < 2^ fac search | num length > 4575
100251 15686 [2, 11, 23, 31.0] < 2^ fac search | num length > 4722
100251 15689 [29, 541.0] < 2^ fac search | num length > 4723
100251 15985 [5, 23, 139.0] < 2^ fac search | num length > 4812
100251 16530 [2, 3, 5, 19, 29.0] < 2^ fac search | num length > 4977
100251 16647 [3, 31, 179.0] < 2^ fac search | num length > 5012
100251 17112 [2, 2, 2, 3, 23, 31.0] < 2^ fac search | num length > 5152
100251 17324 [2, 2, 61, 71.0] < 2^ fac search | num length > 5216
100251 17495 [5, 3499.0] < 2^ fac search | num length > 5267
100251 17525 [5, 5, 701.0] < 2^ fac search | num length > 5276
100251 17687 [23, 769.0] < 2^ fac search | num length > 5325
100251 18309 [3, 17, 359.0] < 2^ fac search | num length > 5512
100251 18320 [2, 2, 2, 2, 5, 229.0] < 2^ fac search | num length > 5515
100251 18739 [7, 2677.0] < 2^ fac search | num length > 5642
100251 18774 [2, 3, 3, 7, 149.0] < 2^ fac search | num length > 5652
100251 18971 [61, 311.0] < 2^ fac search | num length > 5711
100251 19312 [2, 2, 2, 2, 17, 71.0] < 2^ fac search | num length > 5814
100251 19445 [5, 3889.0] < 2^ fac search | num length > 5854

and we can exclude all, 6 digit numbers from these numbers, there definitely will not be the second part of our number 560595.

what is the problem with this method, we do not know the first part of our number (and where there will be a match with both of them from 2^2 to 2^... , approximately 2 to 6 matches start with 2 ^ 5000) and we will have 3 parts of 6 digits (18:6=3). 

Is there a link to these statistics in real time?

I joined!

Relax, it could be just a blabla to sow the seeds for doubt, underdevelopment and unrest in our beautiful community. HODL ON 

352 GHs on Bitcrack than means at least  3520*50 watt = 176 kWatt wasted electric power for a week that is 176*24*7 = 29568 kWh just for fun   

 

some analytics...

5598802  (2, 11, 254491)

degree factorization numbers, where among the numbers, there is our number 5598802

2^47395 1011100100100011 5, 9479
2^47853 1011101011101101 3, 3, 13, 409
2^48555 1011110110101011 3, 3, 5, 13, 83
2^48704 1011111001000000 2, 2, 2, 2, 2, 2, 761
2^49993 1100001101001001 49993
2^50806 1100011001110110 2, 7, 19, 191
2^50903 1100011011010111 109, 467
2^52592 1100110101110000 2, 2, 2, 2, 19, 173
2^53094 1100111101100110 2, 3, 8849
2^54821 1101011000100101 13, 4217
2^55112 1101011101001000 2, 2, 2, 83, 83
2^55655 1101100101100111 5, 11131
2^56022 1101101011010110 2, 3, 9337
2^56117 1101101100110101 17, 3301
2^57421 1110000001001101 7, 13, 631
2^57925 1110001001000101 5, 5, 7, 331

14428676 (2, 2, 19, 189851)

2^38669 1001011100001101 38669
2^42741 1010011011110101 3, 3, 3, 1583
2^43942 1010101110100110 2, 127, 173
2^52395 1100110010101011 3, 5, 7, 499
2^52461 1100110011101101 3, 3, 3, 29, 67
2^55196 1101011110011100 2, 2, 13799
2^58769 1110010110010001 17, 3457
2^63838 1111100101011110 2, 59, 541

what we see, that our number will be 100% in factorized numbers equal to themselves (and that there are just a lot of them among other factors))). there is also a small gain in the search 5598802 vs 15050 (2^49993,num length > 15050), 14428676 vs 11641 (2^38669,num length > 11641). although we can divide this length by the length of our number 14428676 > 8 11641:8= 1455,125 options (from left to right), total 14428676 vs 1456 winnings.

Themselves these numbers (equal to themselves) is also not a bit, from our 38669 to 49993 is 1060 steps.
2^[38669]
2^[38671]
2^[38677]
2^[38693]
2^[38699]
2^[38707]
2^[38711]
...
2^[49927]
2^[49937]
2^[49939]
2^[49943]
2^[49957]
2^[49991]
2^[49993]

In general, all this is necessary to digest, and try to catch something. Large numbers will have to be divided into pieces (the blessing the number we need floats from the beginning of a large number by the end) otherwise the pc will think for a long time. Or search, search algorithm. In theory, there should be numbers (in infinity) which will begin on the number of signs we need 18.19 .. pz59, pz60 .. what is their length, trillions of millions of characters...

script (peeped in google) factorization (integer "degrees") with the search for the desired number

[/size]

i think a big man is disappointed and sell all his coin hahaa

That's right. The hashtopolis agent downloads bitcrack along with whatever address list is assigned and runs a benchmark. Using that result it determines what size chunk to send. Each chunk takes about 10 minutes with the current settings.

Any found keys will get swept automatically. It'll then search and try to sweep any fork currency. The payout will then be split up among the participants similarly to a pps mining pool. If we manage to recover any funds I'll be taking 10 percent to donate to the developers of hashtopolis and bitcrack.

Probably a huge waste of time but it was fun to set up.