Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 235.

racminer

member

Activity: 242

Merit: 17

Quote from: racminer on December 12, 2018, 09:09:22 AM

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 Roll Eyes

) and exchange ruled out scanned ranges.
the lucky one will get the prize

anyone interested?

the range PPPP PPPP PPPP can be scanned with a single 2080 using bitcrack in about one day Wink

https://bitcointalksearch.org/topic/m.48444413

PietCoin97

jr. member

Activity: 91

Merit: 3

Quote from: itod on December 13, 2018, 03:07:35 PM

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.

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

racminer

member

Activity: 242

Merit: 17

Quote from: itod on December 13, 2018, 03:07:35 PM

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.

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

Huh

Amazing ignorance.

Andzhig

jr. member

Activity: 183

Merit: 3

Quote

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

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

Quote

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.

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

itod

legendary

Activity: 1974

Merit: 1076

^ Will code for Bitcoins

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.

PietCoin97

jr. member

Activity: 91

Merit: 3

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

Andzhig

jr. member

Activity: 183

Merit: 3

Quote

do you still have doubts ?

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

Quote

from bitcoin import *
import random
import subprocess
import time
from decimal import *
#from PyRandLib import *
#rand = FastRand63()
#random.seed(rand())

l1= [("10001111"),("10010000"),("10010001")]

l2= [("10000000"),("10000001"),("10000010"),("10000011"),("10000100"),("10000101"),("10000110"),("10000111"),
   ("10001000"),("10001001"),("10001010"),("10001011"),("10001100"),("10001101"),("10001110"),("10001111"),
   ("10010000"),("10010001"),("10010010"),("10010011"),("10010100"),("10010101"),("10010110"),("10010111"),
   ("10011000"),("10011001"),("10011010"),("10011011"),("10011100"),("10011101"),("10011110"),("10011111"),
   ("10100000"),("10100001"),("10100010"),("10100011"),("10100100"),("10100101"),("10100110"),("10100111"),
   ("10101000"),("10101001"),("10101010"),("10101011"),("10101100"),("10101101"),("10101110"),("10101111"),
   ("10110000"),("10110001"),("10110010"),("10110011"),("10110100"),("10110101"),("10110110"),("10110111"),
   ("10111000"),("10111001"),("10111010"),("10111011"),("10111100"),("10111101"),("10111110"),("10111111"),
   ("11000000"),("11000001"),("11000010"),("11000011"),("11000100"),("11000101"),("11000110"),("11000111"),
   ("11001000"),("11001001"),("11001010"),("11001011"),("11001100"),("11001101"),("11001110"),("11001111"),
   ("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
   ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),
   ("11100000"),("11100001"),("11100010"),("11100011"),("11100100"),("11100101"),("11100110"),("11100111"),
   ("11101000"),("11101001"),("11101010"),("11101011"),("11101100"),("11101101"),("11101110"),("11101111"),
   ("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
   ("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"),
   ("00000000"),("00000001"),("00000010"),("00000011"),("00000100"),("00000101"),("00000110"),("00000111"),
   ("00001000"),("00001001"),("00001010"),("00001011"),("00001100"),("00001101"),("00001110"),("00001111"),
   ("00010000"),("00010001"),("00010010"),("00010011"),("00010100"),("00010101"),("00010110"),("00010111"),
   ("00011000"),("00011001"),("00011010"),("00011011"),("00011100"),("00011101"),("00011110"),("00011111"),
   ("00100000"),("00100001"),("00100010"),("00100011"),("00100100"),("00100101"),("00100110"),("00100111"),
   ("00101000"),("00101001"),("00101010"),("00101011"),("00101100"),("00101101"),("00101110"),("00101111"),
   ("00110000"),("00110001"),("00110010"),("00110011"),("00110100"),("00110101"),("00110110"),("00110111"),
   ("00111000"),("00111001"),("00111010"),("00111011"),("00111100"),("00111101"),("00111110"),("00111111"),
   ("01000000"),("01000001"),("01000010"),("01000011"),("01000100"),("01000101"),("01000110"),("01000111"),
   ("01001000"),("01001001"),("01001010"),("01001011"),("01001100"),("01001101"),("01001110"),("01001111"),
   ("01010000"),("01010001"),("01010010"),("01010011"),("01010100"),("01010101"),("01010110"),("01010111"),
   ("01011000"),("01011001"),("01011010"),("01011011"),("01011100"),("01011101"),("01011110"),("01011111"),
   ("01100000"),("01100001"),("01100010"),("01100011"),("01100100"),("01100101"),("01100110"),("01100111"),
   ("01101000"),("01101001"),("01101010"),("01101011"),("01101100"),("01101101"),("01101110"),("01101111"),
   ("01110000"),("01110001"),("01110010"),("01110011"),("01110100"),("01110101"),("01110110"),("01110111"),
   ("01111000"),("01111001"),("01111010"),("01111011"),("01111100"),("01111101"),("01111110"),("01111111")]

def ran1():
   nnn1 = str(random.choice(l1))
   return nnn1

def ran2():
   nnn2 = str(random.choice(l2))
   return nnn2

while 1 == 1:
   i = 1
   while i <= 100000:
   a = str("7.")
   bina = (ran1()+ran2()+ran2())
   nuli = bina.count("0")
   if nuli != 100:
   comb1 = int(bina,2)
   if comb1 >= 9400000:
   if comb1 <= 9680000:
   deccomb1 = str(comb1)
   comb2 = Decimal(a+deccomb1)
   deccomb2 = int(576460752303423488 - ((((((((((comb2 * 128) * 128) * 128) * 128) * 128) * 128) * 128) * 128) - 571957152676052992) * 128))
   if deccomb2 >= 390000000000000000:
   if deccomb2 <= 554000000000000000:
   ran = deccomb2
   myhex = "%064x" % ran
   myhex = myhex[:64]
   priv = myhex
   pub = privtopub(priv)
   pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
   addr = pubtoaddr(pubkey1)

   oy = """cd "C:\crackbit" """
   ey = "\nstart /min cuBitCrack.exe -d 0 -i addr.txt -o find.txt -c -b 32 -t 256 -p 512 -s " # bitcrack settings
   f=open("C:/testpy.cmd","w")
   f.write (oy)
   f.write (ey)
   f.write (priv)
   f.close()

   subprocess.Popen([r"C:/testpy.cmd"])

   print(bina,nuli,comb1,deccomb1,comb2,deccomb2,bin(deccomb2)[2:])

   time.sleep(0.1)



   time.sleep(1200.0) # break between restarts, scan time, in sec, 1200 sec > 20 min.
   subprocess.call("taskkill /IM cuBitCrack.exe")
   i = i+1

   pass

[/size]

racminer

member

Activity: 242

Merit: 17

Quote from: Andzhig on December 12, 2018, 12:33:02 PM

Quote from: racminer on December 12, 2018, 09:09:22 AM

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 Roll Eyes

) and exchange ruled out scanned ranges.
the lucky one will get the prize

anyone interested?

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"

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 ?

Andzhig

jr. member

Activity: 183

Merit: 3

Quote from: racminer on December 12, 2018, 09:09:22 AM

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 Roll Eyes

) and exchange ruled out scanned ranges.
the lucky one will get the prize

anyone interested?

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"

racminer

member

Activity: 242

Merit: 17

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 Roll Eyes

) and exchange ruled out scanned ranges.
the lucky one will get the prize

anyone interested?

racminer

member

Activity: 242

Merit: 17

Quote from: PietCoin97 on December 10, 2018, 06:09:23 PM

Quote from: arulbero on November 11, 2018, 04:38:51 PM

Quote from: noaj24 on November 11, 2018, 04:29:24 PM

If the public key is revealed it is still safe from bruteforce if the attacker don't know the range of bits to search for?

Of course.
Many blocks mined by Satoshi have txs with "pay to public key" script (P2PK) instead of "pay to public key hash" script (P2PKH, pay to address).

The public keys are known, but the btc are still there:

block #100

https://www.blockchain.com/it/btc/tx/2d05f0c9c3e1c226e63b5fac240137687544cf631cd616fd34fd188fc9020866

PUSHDATA(65)[04e70a02f5af48a1989bf630d92523c9d14c45c75f7d1b998e962bff6ff9995fc5bdb44f1793b3749 5d80324acba7c8f537caaf8432b8d47987313060cc82d8a93] CHECKSIG

Code:

x = e70a02f5af48a1989bf630d92523c9d14c45c75f7d1b998e962bff6ff9995fc5

y = bdb44f1793b37495d80324acba7c8f537caaf8432b8d47987313060cc82d8a93

hey arulbero

mabey someone found keys for these addresses ?

or am i wrong ?

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

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

PietCoin97

jr. member

Activity: 91

Merit: 3

Quote from: arulbero on November 11, 2018, 04:38:51 PM

Quote from: noaj24 on November 11, 2018, 04:29:24 PM

If the public key is revealed it is still safe from bruteforce if the attacker don't know the range of bits to search for?

Of course.
Many blocks mined by Satoshi have txs with "pay to public key" script (P2PK) instead of "pay to public key hash" script (P2PKH, pay to address).

The public keys are known, but the btc are still there:

block #100

https://www.blockchain.com/it/btc/tx/2d05f0c9c3e1c226e63b5fac240137687544cf631cd616fd34fd188fc9020866

PUSHDATA(65)[04e70a02f5af48a1989bf630d92523c9d14c45c75f7d1b998e962bff6ff9995fc5bdb44f1793b3749 5d80324acba7c8f537caaf8432b8d47987313060cc82d8a93] CHECKSIG

Code:

x = e70a02f5af48a1989bf630d92523c9d14c45c75f7d1b998e962bff6ff9995fc5

y = bdb44f1793b37495d80324acba7c8f537caaf8432b8d47987313060cc82d8a93

hey arulbero

mabey someone found keys for these addresses ?

or am i wrong ?

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

PietCoin97

jr. member

Activity: 91

Merit: 3

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

Andzhig

jr. member

Activity: 183

Merit: 3

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.

Quote

0 111 101 sec N
10110001 10011101 01101110 0001010010000110001001101000100001 33-25 10 2 3 11640174 B19D6E 2.0 50
11110101 10010010 11100100 100000111100101011101011000011100 28-29 11 2 2 16093924 F592E4 4.9 118
10011101 00011000 10110110 00111010110001001111111111011111 22-34 12 1 3 10295478 9D18B6 1.2 30
11010101 01111100 00111111 0011011011001111110000100010100 24-31 8 3 2 13990975 D57C3F 3.7 86
10001101 10111110 11011011 010101101011010001111101000100 23-31 8 1 5 9289435 8DBEDB 0.6 14
11000000 00111100 01000111 00100011111100011001001101100 29-24 14 2 0 12598343 C03C47 2.6 65
11101111 10101110 00010110 0100110010111001111000111100 22-30 9 3 3 15707670 EFAE16 4.6 112
11101010 00001110 00010100 001101000000000100111010000 33-18 14 2 2 15339028 EA0E14 4.5 107
10001010 11110101 00001111 00001011101001001101010100 26-24 11 2 2 9106703 8AF50F 0.4 11
10111010 00001011 10110101 1000000010101111101001101 24-25 11 2 5 12192693 BA0BB5 2.3 59
10101101 11100110 11010111 110011100011101110011011 17-31 8 2 4 11396823 ADE6D7 1.9 46
11011001 10101100 00100001 01101010011110010111010 23-24 13 0 2 14265377 D9AC21 3.6 90
10111011 00000110 00001110 0010001101010101000100 27-19 13 2 2 12256782 BB060E 2.4 60
10010001 01111110 01010000 101000011110000000101 26 -19 13 2 2 9535056 917E50 0.7 18
11100000 00101011 00110101 10100011010110001111 22-22 13 1 2 14691125 E02B35 4.0 97
11010111 10100111 01100100 1111100010110010001 19-24 10 2 3 14133092 D7A764 3.6 88
10101000 10001000 01110001 011000110110001111 23-19 15 1 1 11044977 A88871 1.5 41
10101001 11000011 01001101 01100110001011011 20-21 12 1 3 11125581 A9C34D 1.7 42
11101001 10101110 01001001 0011001111010110 18-22 11 2 2 15314505 E9AE49 4.3 106
10010110 10111111 00000110 000001111101001 19-20 11 2 2 9879302 96BF06 0.9 23
10001000 11100000 10111110 10110011010000 21-17 13 2 1 8970430 88E0BE 0.3 9
10111010 10111011 10101011 0101010010011 14 -22 8 3 6 12237739 BABBAB 2.3 59
10011101 11101000 00100000 101001111100 19- 17 14 2 2 10348576 9DE820 1.2 30
10010101 11011010 01000010 00101110000 20-15 13 1 3 9820738 95DA42 0.9 22
11010010 10011001 01100100 0100011101 18-16 13 0 3 13801828 D29964 3.3 83
11010100 10110110 01010100 011011000 17-16 12 0 4 13940308 D4B654 3.3 85
10111000 01100010 10100110 00101110 17-15 13 1 2 12083878 B862A6 2.2 57
11111010 10011111 11001110 1000111 10-21 7 4 1 16424910 FA9FCE 4.9 (7) 123
11110110 01010011 00110101 100100 14-16 10 1 3 16143157 F65335 4.8 119
10111111 00010010 10101000 11110 13-16 12 2 3 12522152 BF12A8 2.6 64
11011001 00010110 11001110 1000 14-14 11 1 3 14227150 D916CE 3.7 90
11010101 10000111 00001110 101 13-14 12 2 2 13993742 D5870E 3.5 86
11010000 00001100 10011011 10 15-11 14 0 2 13634715 D00C9B 3.2 81
11111101 00101111 01110010 1 8-17 8 4 3 16592754 FD2F72 5.2 126
11011100 00101010 00000100 15-9 15 1 2 14428676 DC2A04 3.8 93

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
3 5 3 3 3 2 4 4 2 3 3 0 1 2 0 0 4 1 1 3 4 0 2 3 1 2 0 4 4 2 0 3 1 4 2

=>===<>><==<<<==><<=><<=<<<>><<=<><
35333244233012004113402312044203142

[/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.

PietCoin97

jr. member

Activity: 91

Merit: 3

Quote

There is no formula, there is a random and our collective unconscious. Therefore, someone will write something, someone will think of something. Grin You never know, I will write now and you will light up (light bulb lights up).

Take the last number found. 1011000110011101011011100001010010000110001001101000100001 take the first 3 bytes from it 10110001 10011101 01101110 here we have 10 zeros. Check how many combinations will be from the first byte 10110001, 8008 combinations which we need in place 583 (depending on the given data of course, table for counting in python, I'll leave it down) bin 101100011001110101101110 dec 11640174 multiply this number 34 times by 2 will get ~199976666598998016 practically what you need 199976667976342049. 199976667976342049-199976666598998016=1377344033 error on 1377344033 using a scanner "bitcrack" it's practically nothing. You need to guess just 3 bytes then "bitcrack" will do everything himself.

The most important question is how to guess these 3 bytes (and multiply by 2 35 times for 59 puzzle).

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

zielar

full member

Activity: 277

Merit: 106

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]

zielar

full member

Activity: 277

Merit: 106

Andzhig

jr. member

Activity: 183

Merit: 3

Quote from: bill32767 on December 06, 2018, 04:44:53 AM

i tought when i run this python script for every search space there opens a new cmd file with Bitcrack and this search 180sec in random space.

In the first case, there would be more explanation of what the table means, In the second case (if I understand you correctly), bitcrack does not know how (currently not implemented in the program) to sort randomly in a given range, so the only option is to reduce the search time for the start of the next random part and step by step from smaller value to bigger..

***

Since we have 4 repetitions

11110101 1001001011100100 100000111100101011101011000011100 28-29 11 2 2 16093924 F592E4
11101001 1010111001001001 0011001111010110 18-22 11 2 2 15314505 E9AE49
10010110 1011111100000110 000001111101001 19-20 11 2 2 9879302 96BF06
10001010 1111010100001111 00001011101001001101010100 26-24 11 2 2 9106703 8AF50F

the script takes the same initial bytes 11110101 11101001 10010110 10001010 and through the filter produces 10 options for subsequent puzzles. running time 600 sec = 10 min.
Or take ("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"), and drive a week))

The truth is there is a miss in space 147573952589676412928 - 295147905179352825856.
295147905179352825856−45147905179352825856=250000000000000000000
110110001101011100100110 10110111000101110111101010000000000000000000 14210854
14210854* 2 44 times 249999987418033291264
250000000000000000000-249999987418033291264=~12581966708736 fourteen digit number, how many 1 2080ti squeezes 1000mk\s ~ 3 hours apparently.
may have, further, take the first not 3 but 4 bytes...

Variant with filter 11 zeros, 2 111, 2 101.

Quote

import random
from bitcoin import *
import subprocess
import time
#from PyRandLib import *
#rand = FastRand63()
#random.seed(rand())

#l1= [("11010000")]

l1= [("11110101"),("10001010"),("11101001"),("10010110")]

l2= [("10000000"),("10000001"),("10000010"),("10000011"),("10000100"),("10000101"),("10000110"),("10000111"),
   ("10001000"),("10001001"),("10001010"),("10001011"),("10001100"),("10001101"),("10001110"),("10001111"),
   ("10010000"),("10010001"),("10010010"),("10010011"),("10010100"),("10010101"),("10010110"),("10010111"),
   ("10011000"),("10011001"),("10011010"),("10011011"),("10011100"),("10011101"),("10011110"),("10011111"),
   ("10100000"),("10100001"),("10100010"),("10100011"),("10100100"),("10100101"),("10100110"),("10100111"),
   ("10101000"),("10101001"),("10101010"),("10101011"),("10101100"),("10101101"),("10101110"),("10101111"),
   ("10110000"),("10110001"),("10110010"),("10110011"),("10110100"),("10110101"),("10110110"),("10110111"),
   ("10111000"),("10111001"),("10111010"),("10111011"),("10111100"),("10111101"),("10111110"),("10111111"),
   ("11000000"),("11000001"),("11000010"),("11000011"),("11000100"),("11000101"),("11000110"),("11000111"),
   ("11001000"),("11001001"),("11001010"),("11001011"),("11001100"),("11001101"),("11001110"),("11001111"),
   ("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
   ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),
   ("11100000"),("11100001"),("11100010"),("11100011"),("11100100"),("11100101"),("11100110"),("11100111"),
   ("11101000"),("11101001"),("11101010"),("11101011"),("11101100"),("11101101"),("11101110"),("11101111"),
   ("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
   ("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"),
   ("00000000"),("00000001"),("00000010"),("00000011"),("00000100"),("00000101"),("00000110"),("00000111"),
   ("00001000"),("00001001"),("00001010"),("00001011"),("00001100"),("00001101"),("00001110"),("00001111"),
   ("00010000"),("00010001"),("00010010"),("00010011"),("00010100"),("00010101"),("00010110"),("00010111"),
   ("00011000"),("00011001"),("00011010"),("00011011"),("00011100"),("00011101"),("00011110"),("00011111"),
   ("00100000"),("00100001"),("00100010"),("00100011"),("00100100"),("00100101"),("00100110"),("00100111"),
   ("00101000"),("00101001"),("00101010"),("00101011"),("00101100"),("00101101"),("00101110"),("00101111"),
   ("00110000"),("00110001"),("00110010"),("00110011"),("00110100"),("00110101"),("00110110"),("00110111"),
   ("00111000"),("00111001"),("00111010"),("00111011"),("00111100"),("00111101"),("00111110"),("00111111"),
   ("01000000"),("01000001"),("01000010"),("01000011"),("01000100"),("01000101"),("01000110"),("01000111"),
   ("01001000"),("01001001"),("01001010"),("01001011"),("01001100"),("01001101"),("01001110"),("01001111"),
   ("01010000"),("01010001"),("01010010"),("01010011"),("01010100"),("01010101"),("01010110"),("01010111"),
   ("01011000"),("01011001"),("01011010"),("01011011"),("01011100"),("01011101"),("01011110"),("01011111"),
   ("01100000"),("01100001"),("01100010"),("01100011"),("01100100"),("01100101"),("01100110"),("01100111"),
   ("01101000"),("01101001"),("01101010"),("01101011"),("01101100"),("01101101"),("01101110"),("01101111"),
   ("01110000"),("01110001"),("01110010"),("01110011"),("01110100"),("01110101"),("01110110"),("01110111"),
   ("01111000"),("01111001"),("01111010"),("01111011"),("01111100"),("01111101"),("01111110"),("01111111")]

def take1():
   yy = str(random.choice(l1))
   return yy

def take2():
   uu = str(random.choice(l2))
   return uu

def rana():
   s = [take2(),take2()]
   d = ''.join(random.sample(s,len(s)))
   bina = (take1()+d)
   return bina

def mult():
   a1 = 2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2 # * 35 288230376151711744 - 576460752303423488
   a2 = 2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2 # * 36 576460752303423488 - 1152921504606846976
   a3 = 2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2 # * 37 1152921504606846976 - 2305843009213693952
   a4 = 2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2 # * 38 2305843009213693952 - 4611686018427387904
   a5 = 2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2 # * 39 4611686018427387904 - 9223372036854775808
   a6 = 2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2 # * 40 9223372036854775808 - 18446744073709551616
   a7 = 2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2 # * 41 18446744073709551616 - 36893488147419103232
   a8 = 2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2 # * 42 36893488147419103232 - 73786976294838206464
   a9 = 2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2 # * 43 73786976294838206464 - 147573952589676412928
   a10= 2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2 # * 44 147573952589676412928 - 295147905179352825856
   multypl = random.choice([a1,a2,a3,a4,a5,a6,a7,a8,a9,a10])
   return multypl

def funk():
   i = 2
   while i != 1:
   aaa = rana()
   filtr0 = aaa.count("0")
   if filtr0 == 11: # zeros filt
   filtr1 = aaa.count("111")
   if filtr1 == 2: # 111 filt
   filtr2 = aaa.count("101")
   if filtr2 == 2: # 101 filt
   b = int(aaa,2)* mult()
   ran = b
   myhex = "%064x" % ran
   myhex = myhex[:64]
   priv = myhex
   pub = privtopub(priv)
   pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
   addr = pubtoaddr(pubkey1)

   oy = """cd "C:\crackbit" """
   ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 56 -s " # bitcrack settings
   f=open("C:/testpy.cmd","w")
   f.write (oy)
   f.write (ey)
   f.write (priv)
   f.close()

   subprocess.Popen([r"C:/testpy.cmd"])

   print(aaa,b,addr,priv,bin(b))

   time.sleep(0.1)

   break
   return None

while True:
   for a in range(10): # number of copies
   funk()


   time.sleep(600.0) # break between restarts, scan time, in sec
   subprocess.call("taskkill /IM cuBitCrack.exe")

[/size]

PietCoin97

jr. member

Activity: 91

Merit: 3

hahaha yeah ok Grin

but i like your strategy can you code something what i wrote at last ?

Andzhig

jr. member

Activity: 183

Merit: 3

Quote

you have to understand i am not a coder i learn the basics from python but this was a while ago.

Me too about 10 years ago assembler even under ms-dos taught)) From examples from the Internet glued. Can be without .cmd run, there damn head break, figure out how.)) If you still have experience in this matter, then if necessary, you will understand how it is more convenient for you to make a program. There are lots of options. Take the dec range convert to bin, filter (if necessary) back to dec and on... Take any combinations, organization of zeros, ones.. bits, bytes. Or create a list of options to a file and binomial randomly choose from it. Or, alternatively, take out the leaves from the pouch while in deep trance. Grin

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