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

ROFL

What is confusing me is that's your own wallet !
it seems that you have lost 13.22 BTC forever ... too bad.

(Well, maybe not 13.22 since your profile here was created on may 2013)
 

Because they can, and it says "Do not send". What is confusing you here?

You realize these 13.22016611 BTC are lost forever?

the range PPPP PPPP PPPP can be scanned with a single 2080 using bitcrack  in about one day   https://bitcointalksearch.org/topic/m.48444413

hahaha yes i know what random means but i like the thoughts of Andzhig

hi

Why on earth people have  sent  BTC  here:   https://www.blockchain.com/btc/address/1BitcoinEaterAddressDontSendf59kuE  from 2011-06-21 up to 2018-11-02

13.22016611 BTC

 

Amazing ignorance.  

do not know, it is necessary to find first)).

This we know. But at the time of the puzzle, in early 2015, there were still no powerful graphics cards and programs for finding Bitcoin addresses on them. The speed of 1 2080 is impressive https://bitcointalksearch.org/topic/m.48444413

Do you newbies know what "random" means?

Although the private keys you are talking about are generated with pseudorandom algorithm, it's obvious creator of this puzzle knew what he was doing, and this means he used enough entropy that these laughable experiments with walls of numbers where you try to find some pattern makes as much sense as trying to get in earths orbit by jumping up as hard as you can.

Amazing ignorance.

When you find the puzzel 59 with your success Formular it will be easy for you to find the other ones?

clearly, understood, thx.

***

Another option to try your luck.

288230376151711744-576460752303423488 our range.

success formula.

144115188075855872  - ((((((((((1,9850114 * 128) * 128) * 128) * 128) * 128) * 128) * 128) * 128) - 142989288169013248) * 128) = ~138245434111601493 - 138245758910846492 = 324799244999 < scan residue
288230376151711744  - ((((((((((3,9783185 * 128) * 128) * 128) * 128) * 128) * 128) * 128) * 128) - 285978576338026496) * 128) = ~199976540817066822 - 199976667976342049 = 127159275227 < scan residue  
576460752303423488  - ((((((((((7,9456789 * 128) * 128) * 128) * 128) * 128) * 128) * 128) * 128) - 571957152676052992) * 128) =


                            63

101   3,9783185                          2
111   1,9850114                          4

                            56                             sec                            49                                sec                                 42                           sec                            
100 127,38634167733380354869954231845    1    101 127,27325883491753266696377977496    2     101 127,34166804622168456262443214655   1
110  63,583036446150909604124734642028   3    101  63,660348182749885381781496107578   1     101  63,668431836413219571113586425781  1
100  31,861576626618332619411688710898   0    110  31,787429311634468831471167504787   3     111  31,771796089393319562077522277832  4
110  15,90613502904471082688431238239    2    101  15,908679856821891007712110877037    2     100  15,926393464003922417759895324707  0
111   7,941484368221046585833988729064   4    100   7,9644791460323176579549908638        0     100   7,966582541557727381587028503418  0
111   3,97142883352349745                        4    111   3,9726356460934955094899123650976   4     101   3,9699310258729383349418640136719 2
100   1,9915187218734213270288080366299  0    110   1,9868375314665325248597582685761   3     100   1,990362136945805104915052652359  1
                                                                                      
                            35                                                               28                                                                      21
100 127,41463838936761021614074707031    0    110 127,1519957482814788818359375           3     110 127,1361083984375
110  63,588673464953899383544921875        3    110  63,58295440673828125                        3     110  63,58837890625
110  31,7922732196748256683349609375       3    110  31,7968273162841796875                    3     101  31,82952880859375
101  15,90996809303760528564453125          2    111  15,876374721527099609375                 5     110  15,9052734375
111   7,938812442123889923095703125         4    110   7,9462490081787109375                     3     101   7,954345703125
111   3,979142837226390838623046875         4    101   3,97543811798095703125                          110   3,97543811798095703125
101   1,9883378362865187227725982666016   2    101   1,9887961782515048980712890625             110   1,987188816070556640625

binary representations of the first 7 digits, after the comma. 1,9...3,9...7,9...15,9... (15.blabla - 127.blabla We are not taking yet.) And we look at coincidences.

                    63

10010101 01000111 10010001 (3,9783185 > 9783185 > 100101010100011110010001)
10010110 01001101 00000010 (1,9850114 > 9850114 > 100101100100110100000010)

                    56

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


Let's say we have a repeat 10001111 we get an approximate range 510000000000000000-550000000000000000. At 10010011 290000000000000000-340000000000000000.

with clarification, on all possible ranges.

10001111 553000000000000000-580000000000000000 if after 9 comes 3 > 7,93... too high
10001111 519000000000000000-554000000000000000 if after 9 comes 4 > 7,94...
10010000 460000000000000001-520000000000000000 if after 9 comes 4 > 7,94...
10010000 458000000000000000-462000000000000000 if after 9 comes 5 > 7,95...
10010001 390000000000000000-460000000000000000 if after 9 comes 5 > 7,95...
10010010 369000000000000000-400000000000000000 if after 9 comes 5 > 7,95... did not appear yet
10010010 337000000000000000-369000000000000000 if after 9 comes 6 > 7,96... did not appear yet
10010011 270000000000000000-338000000000000000 if after 9 comes 6 > 7,96... too low

if after 9 comes 7,9 012...789 fall out of range, 012 > 576460752303423488,789 < 288230376151711744. As we see 10010010 have not participated anywhere yet (unless on initial puzzles).

Most likely range from 10010001 390000000000000000 to 10001111 554000000000000000. 390000000000000000-554000000000000000.

***

python 3 script

[/size]

Of course I am aware of LBC but what I suggest is not the same spirit.  About the 1023 cases, it is oubious  no need to get "tormented by vague doubts", it's just simple arithmetic.
( 07FF FFFF FFFF FFFF - 0400 0000 0000 0000 ) = 288230376151711743 keys
   FFFF FFFF FFFF = 281474976710655

288230376151711743/(281474976710655+1) = 1023

do you still have doubts ?

 

It is unlikely, here, to find a sufficient number of people willing, so that from this idea it would turn out to be something worthwhile. Moreover, no need to reinvent the wheel, LBC already exists. And I am tormented by vague doubts that there is such a number (I think it's a "little" more.). "from 400 to 7FF we have 1023 possibles cases"

Hi

I have a suggestion to everyone here interested in solving case #59
We know for sure that the private key looks like:

04XX PPPP PPPP PPPP  or
05XX PPPP PPPP PPPP  or
06XX PPPP PPPP PPPP  or
07XX PPPP PPPP PPPP

the range PPPP PPPP PPPP can be scanned with a single RX480 using bitcrack  in about ten days

from 400 to 7FF we have 1023 possibles cases

we could split the workload and create a peer to peer method (via private messages here + trust + honesty  ) and exchange ruled out scanned ranges.
the lucky one will get the prize 
anyone interested?

Hi

look at the date 2011-06-11 12:57:32
those where normally mined blocks that where normally spent back then.  

unlike this one  https://www.blockchain.com/it/btc/tx/2d05f0c9c3e1c226e63b5fac240137687544cf631cd616fd34fd188fc9020866  mined on 2009-01-11 08:00:25 when BTC was not worth a penny !

the first mined block on 2009-01-09 02:54:25  is still unspent  https://www.blockchain.com/fr/btc/address/12c6DSiU4Rq3P4ZxziKxzrL5LmMBrzjrJX 

hey arulbero

mabey someone found keys for these addresses ?

or am i wrong ?

https://www.blockchain.com/btc/address/1E9jNPoV7R14mzgcoZcGn6fjHGq7FdfbFv

shit ok yeah i see i do really wrong thanks for show me the right.

you have to know i am only interested in this i really know not much about that whole thing

i learn this all by myself

Chew for stupid what are you doing. But the first byte cannot start at 0. And each step up is multiplied by +2. Every step below -2. Ie 55 * 2> 31, 54 * 2> 30 ...

55bit = 01101010 10111110 00011111 = 15 (1) 32
54bit = 00100011 01101111 10110110 = 14 (1) 32 > 31
53bit = 00011000 00000111 10001000 = 7  (1) 32 > 30



***
a little thought

       1("10000000"),   2("10000001"),  3("10000010"),   4("10000011"),  5("10000100"),   6("10000101"),   7("10000110"),  8("10000111"),
       9("10001000"), 10("10001001"), 11("10001010"), 12("10001011"), 13("10001100"), 14("10001101"), 15("10001110"), 16("10001111"),
      17("10010000"), 18("10010001"), 19("10010010"), 20("10010011"), 21("10010100"), 22("10010101"), 23("10010110"), 24("10010111"),
      25("10011000"), 26("10011001"), 27("10011010"), 28("10011011"), 29("10011100"), 30("10011101"), 31("10011110"), 32("10011111"),
      33("10100000"), 34("10100001"), 35("10100010"), 36("10100011"), 37("10100100"), 38("10100101"), 39("10100110"), 40("10100111"),
      41("10101000"), 42("10101001"), 43("10101010"), 44("10101011"), 45("10101100"), 46("10101101"), 47("10101110"), 48("10101111"),
      49("10110000"), 50("10110001"), 51("10110010"), 52("10110011"), 53("10110100"), 54("10110101"), 55("10110110"), 56("10110111"),
      57("10111000"), 58("10111001"), 59("10111010"), 60("10111011"), 61("10111100"), 62("10111101"), 63("10111110"), 64("10111111"),
      65("11000000"), 66("11000001"), 67("11000010"), 68("11000011"), 69("11000100"), 70("11000101"), 71("11000110"), 72("11000111"),
      73("11001000"), 74("11001001"), 75("11001010"), 76("11001011"), 77("11001100"), 78("11001101"), 79("11001110"), 80("11001111"),
      81("11010000"), 82("11010001"), 83("11010010"), 84("11010011"), 85("11010100"), 86("11010101"), 87("11010110"), 88("11010111"),
      89("11011000"), 90("11011001"), 91("11011010"), 92("11011011"), 93("11011100"), 94("11011101"), 95("11011110"), 96("11011111"),
    97("11100000"), 98("11100001"), 99("11100010"),100("11100011"),101("11100100"),102("11100101"),103("11100110"),104("11100111"),
 105("11101000"),106("11101001"),107("11101010"),108("11101011"),109("11101100"),110("11101101"),111("11101110"),112("11101111"),
 113("11110000"),114("11110001"),115("11110010"),116("11110011"),117("11110100"),118("11110101"),119("11110110"),120("11110111"),
 121("11111000"),122("11111001"),123("11111010"),124("11111011"),125("11111100"),126("11111101"),127("11111110"),128("11111111")

first byte numbers of found puzzles (starting at eighth where is the whole byte). 51 whole byte + 7 non-integer initial(1001100,110001,10101,1000,111,11,1).

97 106 1 17 40 36 37 82 74 60 67 47 83 94 56 43, 93 126 81 86 90 64 119 123 57 85 83 22 30 59 9 23 106 42 41 88 97 18 60 90 46 59 11 107 112 65 14 86 30 118 50

On these 51 bytes 5 repetitions with the maximum step between them 13, 83-83. How can this be used, by removing the last 10 bytes from the table for example.

   1("10000000"),  2("10000001") ,   3("10000010" ),  4("10000011"),  5("10000100") ,  6("10000101")     , 7("10000110") ,  8("10000111"),
   9("10001000"), 10("10001001") ,  11                 , 12("10001011"), 13("10001100"),  14                    , 15("10001110"), 16("10001111"),
  17("10010000"), 18("10010001"),  19("10010010"), 20("10010011"), 21("10010100"),  22("10010101")   , 23("10010110"), 24("10010111"),
  25("10011000"), 26("10011001"),  27("10011010"), 28("10011011"), 29("10011100"),  30                    , 31("10011110"), 32("10011111"),
  33("10100000"), 34("10100001"),  35("10100010"), 36("10100011"), 37("10100100"),  38("10100101")   , 39("10100110"), 40("10100111"),
  41("10101000"), 42("10101001"),  43("10101010"), 44("10101011"), 45("10101100"),  46("10101101")   , 47("10101110"), 48("10101111"),
  49("10110000"), 50                 ,  51("10110010"), 52("10110011"), 53("10110100"),  54("10110101")   , 55("10110110"), 56("10110111"),
  57("10111000"), 58("10111001"),  59                 , 60("10111011"), 61("10111100"),  62("10111101")   , 63("10111110"), 64("10111111"),
  65                 , 66("11000001"),  67("11000010"), 68("11000011"), 69("11000100"),  70("11000101")   , 71("11000110"), 72("11000111"),
  73("11001000"), 74("11001001"), 75("11001010") , 76("11001011"), 77("11001100"),  78("11001101")   , 79("11001110"), 80("11001111"),
  81("11010000"), 82("11010001"), 83("11010010") , 84("11010011"), 85("11010100"),  86                    , 87("11010110"), 88("11010111"),
  89("11011000"), 90("11011001"), 91("11011010") , 92("11011011"), 93("11011100"),  94("11011101")  , 95("11011110"), 96("11011111"),
  97("11100000"), 98("11100001"), 99("11100010") ,100("11100011"),101("11100100"), 102("11100101"),103("11100110"),104("11100111"),
 105("11101000"),106("11101001"),107                 ,108("11101011"),109("11101100"),110("11101101"),111("11101110"),112                 ,
 113("11110000"),114("11110001"),115("11110010"),116("11110011"),117("11110100"),118                 ,119("11110110"),120("11110111"),
 121("11111000"),122("11111001"),123("11111010"),124("11111011"),125("11111100"),126("11111101"),127("11111110"),128("11111111")

In the puzzle 160 steps (don’t know what a madman will look for 150-160 puzzles even if hypothetically a large collider seeks for collisions no higher "The effective search space until a collision is found is 134.58 bits (See here why).") and 128 possible initial bytes, - 7 initial non-full, 153-128=25 at least 25 repetitions are possible (Minimum 20, 5 already). If random when creating the puzzle worked to create the greatest difference maybe he will go through all the initial bytes therefore, they are already used can be discarded.

***

Or for specifically that table with numbers time finding 3 bytes of initial. We take the whole initial numbers. It is understandable the closer to the beginning of bytes, the faster the time for finding a combination of three.

[/size]

Here we see that after the two so far followed 2(4),2(3),2(0). 2(1),2(2) did not have. It means 101 disappears. 100 questionable. More likely 110 111.

so i calculate like you say but this dont work for the others.

look here:


288 230 376 151 711 744 = 58bit found #58priv key puzzel is 199 976 667 976 342 049‬ mitte  errechneter wert 199 976 666 598 998 016 mit hoch 34 == 1 377 344 033
144 115 188 075 855 872 = 57bit found #57priv key puzzel is 138 245 758 910 846 492 ende   errechneter wert 138 245 754 488 619 008 mit hoch 33 == 4 422 227 484
 72 057 594 037 927 936 = 56bit found #56priv key puzzel is  44 218 742 292 676 575‬ mitte    errechneter wert  44 218 741 306 687 488 mit hoch 32 ==   985 989 087
 36 028 797 018 963 968 = 55bit found #55priv key puzzel is  30 045 390 491 869 460 ende    errechneter wert  30 045 387 884 593 152 mit hoch 32
 18 014 398 509 481 984 = 54bit found #54priv key puzzel is   9 974 455 244 496 707 anfang  errechneter wert   9 974 451 659 603 968 mit hoch 32
   9 007 199 254 740 992 = 53bit found #53priv key puzzel is   6 763 683 971 478 124 mitte     errechneter wert   6 763 680 138 002 432 mit hoch 32
  4 503 599 627 370 496 = 52bit found #52priv key puzzel is   4 216 495 639 600 700 ende      errechneter wert   4 216 495 559 147 520 mit hoch 28
  2 251 799 813 685 248 = 51bit found #51priv key puzzel is   2 058 769 515 153 876 ende      errechneter wert   2 058 769 487 888 384 mit hoch 28

59bit =
58bit = 10110001 10011101 01101110 = 14 (1) 34
57bit = 11110101 10010010 11100100 = 13 (1) 33
56bit = 10011101 00011000 10110110 = 12 (1) 32
55bit = 01101010 10111110 00011111 = 15 (1) 32
54bit = 00100011 01101111 10110110 = 14 (1) 32
53bit = 00011000 00000111 10001000 = 7  (1) 32
52bit = 11101111 10101110 00010110 = 15 (1) 28
51bit = 01110101 00000111 00001010 = 10 (1) 28

ok ... finally after installing Python 3.7.1 and patches from "\" to "/" everything is OK. Has anyone of you can knowledge about the best settings for 1080TI? For me, these 10 processes reach 22Mkey / s on my setting [-b 28 -t 256 -p 512]