Bitcoin puzzle transaction ~32 BTC prize to who solves it

[Andzhig]

Or such an option.

Take 1000 samples of 50 from the set 00-99 ()

>>> 1

>>> 2

>>> 3

>>> 4

>>> 5
480 huuuuuuuuuurraaaaaaaaaa... ['00', '01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99'] 100     ['46', '77', '96', '34', '68', '95', '45', '60', '30', '96', '90', '63', '29', '23', '56', '65', '28', '84', '69', '43', '84', '08', '84', '36', '64', '83', '70', '91', '20', '28', '73', '73', '58', '68', '72', '92', '61', '85', '70', '52', '24', '58', '55', '54', '54', '93', '12', '64', '44', '31'] 50     ['30'] ['56'] ['83'] ['77'] ['31'] ['20'] ['64'] ['20'] ['28'] ['55']

5 samples come across

['46, '77', '96', '34', '68', '95', '45', '60', '30', '96', '90', '63', '29', '23', '56', '65', '28', '84', '69', '43', '84', '08', '84', '36', '64', '83', '70', '91', '20', '28', '73', '73', '58', '68', '72', '92', '61', '85', '70', '52', '24', '58', '55', '54', '54', '93', '12', '64', '44', '31'] 50

['30'] ['56'] ['83'] ['77'] ['31'] ['20'] ['64'] ['20'] ['28'] ['55']

and that only 5000 mixed sets in which dropped out with the required number.

now we take each of these 5000 sets and select 1000 from each of them, 30 samples.

finds the first time (but you may need 20-30, etc.)

174 huuuuuuuuuurraaaaaaaaaa... ['46', '77', '96', '34', '68', '95', '45', '60', '30', '96', '90', '63', '29', '23', '56', '65', '28', '84', '69', '43', '84', '08', '84', '36', '64', '83', '70', '91', '20', '28', '73', '73', '58', '68', '72', '92', '61', '85', '70', '52', '24', '58', '55', '54', '54', '93', '12', '64', '44', '31'] 50     ['46', '73', '31', '84', '83', '95', '63', '72', '95', '68', '68', '58', '30', '77', '56', '83', '20', '45', '95', '84', '64', '28', '65', '70', '85', '55', '08', '85', '68', '83'] 30     ['30'] ['56'] ['83'] ['77'] ['31'] ['20'] ['64'] ['20'] ['28'] ['55']

666 huuuuuuuuuurraaaaaaaaaa... ['46', '77', '96', '34', '68', '95', '45', '60', '30', '96', '90', '63', '29', '23', '56', '65', '28', '84', '69', '43', '84', '08', '84', '36', '64', '83', '70', '91', '20', '28', '73', '73', '58', '68', '72', '92', '61', '85', '70', '52', '24', '58', '55', '54', '54', '93', '12', '64', '44', '31'] 50     ['92', '56', '73', '12', '34', '73', '96', '90', '95', '58', '20', '93', '83', '60', '63', '84', '58', '68', '31', '28', '77', '23', '72', '54', '55', '30', '64', '70', '93', '23'] 30     ['30'] ['56'] ['83'] ['77'] ['31'] ['20'] ['64'] ['20'] ['28'] ['55']

now can search further in the same way for 17 parts, but it takes a long time or choose from 30

and then, in the end, for the first choice from 100 to 50 we take 1000 and then for each 1000 1000 already 1000000 and 17 parts from 30 20-30 20000000 (using a stirring of 17 on a PC it takes 1 stirring per day approximately)

or search in another way

how to choose from 30 parts.
can create as many sets as you like from fixed positions and run reading lines

we have a string blablabla

123456789

pos 2 4 6 8
     2 4 6 8 > 2468
pos 1 3 4 7
     1 3 4 7 > 1347

n this case,need to run only 1000x1000 1,000,000 lines (in several copies of the program, for each program you need its own set of random 1,000,000)

and position traps when fishing from 30 parts what you can think of

pos 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17...
pos 2 4 6 8 10 12 14 16...
pos 1 3 7 9...
pos 25 12 20 3...

***
Or try to iterate over the private keys (not compressed in short). Someone could still hack this.
https://twitter.com/UnderTheBreach/status/1303316723186139136?ref_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E1303316723186139136%7Ctwgr%5E%7Ctwcon%5Es1_&ref_url=https%3A%2F%2F2bitcoins.ru%2Fvzlomat-koshelek-s-69370-bitkoinami%2F forwarded https://www.blockchain.com/btc/address/bc1qa5wkgaew2dkv56kfvj49j0av5nml45x9ek9hz6

And they wrote that out of 15+ a password from a set of letters and numbers cannot be cracked faster than 100 years.

Or the author of the puzzle, if bitcoin starts to cost 500 thousand dollars (0,6 > ~ 300000$), will bring everything back to himself. Either he owns thousands of bitcoins and doesn't care or we need to hurry.  

We have 17 to 15 characters (123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz) long.

the private owner himself lenght is 51...

5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip + 17 or

5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip7 + 16
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip8 + 16
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9 + 16

etc...

from bit import Key
from bit.format import bytes_to_wif
import random
import time

i=1
while i <= 100000000:
    
    try:
        while True:
            
            a = "5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip"
            c1 = random.choice("789")
            c2 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c3 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c4 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c5 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c6 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c7 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c8 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c9 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c10 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c11 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c12 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c13 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c14 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c15 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c16 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            c17 = random.choice("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
            
            b = (a+c1+c2+c3+c4+c5+c6+c7+c8+c9+c10+c11+c12+c13+c14+c15+c16+c17)
            
            print(b)
            key1 = Key(b)
            wif1 = bytes_to_wif(key1.to_bytes(), compressed=True)
            key2 = Key(wif1)
            addr1 = key2.address
            
            print(addr1)
            
            list =["16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN","13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so","1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9",
                   "1MVDYgVaSN6iKKEsbzRUAYFrYJadLYZvvZ","19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG","17aPYR1m6pVAacXg1PTDDU7XafvK1dxvhi"]

            if addr1 in list:
                print(key2,wif1)
                s5 = str(b)
                f=open(u"C:/a.txt","a")
                f.write(s5 + '\n')
                f.close()
                break
            
    except:
      
        pass


    i=i+1

[/size]

5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9TCtAvUfKhoFxYTc9
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip7bv5RMSuoznp2uhqe
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip8BrrMP9oEfbvD94YX
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9a1SzEwmAvpT26x4C
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9KdgPtUyZKWvJC4ZF
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip8fH4ZZ69fWw6BdtDv
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip78tWUnQ6qF8yXcaY2
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip7rJRmZ6friVeM1qc6
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9UAa2ekurdKcPF4My
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip8dYitTcwJfxXCGfeZ
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9bKNcfneeyf6CUUgw
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9YbKx2dJB5efJtfNy
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9Ygtosb3g6gF4Y5DM
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9ovmK8kCJkCfDEi9Y
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9bAdqx6zqtTmwKH6x
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip817D7YjqpzHBJhqWx
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip9n7yTUMxnivSB5Vd7
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip8KtL7pfLmPRUxZPFL
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip8MRboemYp2iaY5mph

[/size]

did not delve into the details of how he generates it this private but the main part goes through step by step (for each of 123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz the same in order) as an option, see how much it will roll on the counter between the puzzles, maybe there is something to attach to, or it will copy dec.

It is not yet clear where he might be

1Me6EfpwZK5kQziBwBfvLiHjaPGxCKLoJi      | 4611686018427387903                     
1NpYjtLira16LfGbGwZJ5JbDPh3ai9bjf4        | 9223372036854775807  8993229949524469768
16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN   | 18446744073709551615                 
18ZMbwUFLMHoZBbfpCjUJQTCMCbktshgpe | 36893488147419103231                   

from bit import Key
from bit.format import bytes_to_wif

#print (int("0000000000000000000000000000000000000000000000007CCE5EFDACCF6808",16))

i = 9223372036854775807          # 9223372036854775807     #44218742292676575 1461501637330902918203684832716283019655932542464
while i <= 18446744073709551615  : # 18446744073709551615 115792089237316195423570985008687907852837564279074904382605163141518161494336
    key1 = Key.from_int(i)

    wif = bytes_to_wif(key1.to_bytes(), compressed=False)
    wif2 = bytes_to_wif(key1.to_bytes(), compressed=True)
    key2 = Key(wif)
    key1 == key2
        #print(hex(i))
        #print(key1.address)
        #print(key2.address)
    print(i,wif,wif2) #(i,wif,wif2,key1.address,key2.address)

    i=i+1

[/size]

[1714924080]

1714924080

[1714924080]

1714924080

[1714924080]

1714924080

[dextronomous]

how you make the bottom part of your code search the 64th puzzle and save it if found
wow andzhig respect. you really great in these things man.
thanks

[as9ardia]

how you make the bottom part of your code search the 64th puzzle and save it if found
wow andzhig respect. you really great in these things man.
thanks

You can use open() function + parameter to open/read/write/append your result into a file
parameters:
'a' (Append) will append to the end of the file
'w' (Write) will overwrite any existing content
'r' (Read) will read from file

This code I use to scan #64 using python 3.xxx:

Code:

import binascii, blocksmith

a = 2**63
b = 2**64-1
prehex = '000000000000000000000000000000000000000000000000' #48 digit 0
wallettofind = '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN'
fwrite = open('YourFileName.txt', 'w')

print('Scan is Running')
for i in range(a,b):
    privhex = hex(i)[2:]
    dumppriv = prehex+str(privhex)
    walletscan = blocksmith.BitcoinWallet.generate_compressed_address(dumppriv)
    if walletscan == wallettofind:
        fwrite.write('Key: '+ str(privhex) + ' ( '+str(walletscan)+' ) \n')
        break
else:
    #fwrite.write('Not Found!!!') if you set b value less than 2**64-1 then you can use this i.e b= 2**63+1000000000 and will only scan for 1000000000 keys between 9223372036854775808 (2**63) to 9223372037854775808
fwrite.close()
print('Scan Finish!')

*if the YourFileName.txt file does not exist it will create automatically

if you want to test the code with a small range. let say puzzle #25
then you can change a,b, prehex and wallettofind value like this:

Code:

a = 2**24
b = 2**25-1
prehex = '000000000000000000000000000000000000000000000000000000000' #57 digit 0
wallettofind = '15JhYXn6Mx3oF4Y7PcTAv2wVVAuCFFQNiP' #Puzzle no 25

[fxsniper]

you can follow this topic on new thread update at here

https://bitcointalk.org/index.php?topic=5218972.0

this thread is older and long

[as9ardia]

you can follow this topic on new thread update at here

https://bitcointalk.org/index.php?topic=5218972.0

this thread is older and long

but you can found puzzle creator comment on this thread. (just one comment). and it would be better to read all about this puzzle on all related info/thread

btw, I read almost all of the thread, including the locked one and you've mentioned above

[dextronomous]

This code I use to scan #64 using python 3.xxx:

Code:

import binascii, blocksmith

a = 2**63
b = 2**64-1
prehex = '0000000000000000000000000000000000000000000000007CCE5EFDACCF6808'
wallettofind = '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN'
fwrite = open('YourFileName.txt', 'a')

print('Scan is Running')
for i in range(a,b):
    privhex = hex(i)[2:]
    dumppriv = prehex+str(privhex)
    walletscan = blocksmith.BitcoinWallet.generate_compressed_address(dumppriv)
    if walletscan == wallettofind:
        fwrite.write('Key: '+ str(privhex) + ' ( '+str(walletscan)+' ) \n')
        break
else:
    #fwrite.write('Not Found!!!') if you set b value less than 2**64-1 then you can use this i.e b= 2**63+1000000000 and will only scan for 1000000000 keys between 9223372036854775808 (2**63) to 9223372037854775808
fwrite.close()
print('Scan Finish!')

Do i just add this one if only wanting the 64th to be searched,
0000000000000000000000000000000000000000000000007CCE5EFDACCF6808 so adding this
added the a append, anything needed to be printed onscreen while searching?
like speed or time left or
#print(hex(i))
#print(key1.address)
#print(key2.address)
  print(i,wif,wif2) #(i,wif,wif2,key1.address,key2.address)
any of these, i know i already asked to much.

[fxsniper]

but you can found puzzle creator comment on this thread. (just one comment). and it would be better to read all about this puzzle on all related info/thread

btw, I read almost all of the thread, including the locked one and you've mentioned above

Ok, I still read info from this thread

[1083ivangod]

This is just a bot game.

[Andzhig]

Or consider an option divide and conquer https://en.wikipedia.org/wiki/Divide-and-conquer_algorithm (from the brute-force family)

take our desired number and decompose it into terms

30568377312064202855

3 0,   5 6,    8 3,   7 7,   3 1,   2 0,    6 4,   2 0,   2 8,   5 5
 3      11      11     14      4      2       10      2      10    10
    14               25              6               12             20
              39                              18                      20  
                               57  <==left side                    20  <==right side
                                                     77

how to organize it correctly? we have 20 numbers long at some point we have 5 parts (here, for example, with even https://res.cloudinary.com/practicaldev/image/fetch/s--JMbxW5kY--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://skerritt.blog/content/images/2019/03/image-35.png). we leave some part (we have 20) and just push it along the script.

import random
def foo(number):
    first = random.randint(0, number)
    second = number - first
    return first, second

while True:

    a = foo(77)

    A=[]
    ost = []

    B=[]


    C1=[]
    C2=[]

    b=a
    A.append(b)

    #print(a,b,A)

    for elem in A:
        for XXX in elem:
            if XXX == 57:                         <==left side
                f = foo(elem[0])
                B.append(f)
                ost.append(elem[1])
                #print(elem,f,ost)

    for AAA in ost:
        if AAA == 20:                              <==right side
  

            D1=[]
            D2=[]
            D3=[]
            D4=[]
            ost2 = []

            for elems in B:
                f1 = foo(elems[0])
                f2 = foo(elems[1])
                C1.append(f1)
                C2.append(f2)
                #ost.append(elem[1])
                #print(elems,f1,f2,C1,C2,ost)


            for elems in C1:
                f1 = foo(elems[0])
                f2 = foo(elems[1])
                D1.append(f1)
                D2.append(f2)
                #ost.append(elem[1])
                #print(D1,D2)

            for elems in C2:
                f1 = foo(elems[0])
                f2 = foo(elems[1])
                D3.append(f1)
                D4.append(f2)
                #ost.append(elem[1])
                #print(D3,D4)

            for elems in ost:
                f1 = foo(elems)
                #f2 = foo(elems[1])
                ost2.append(f1)
                #D4.append(f2)
                #ost.append(elem[1])
                #print(D3,D4)


            #print(D1,D2,D3,D4,ost2)    
            add = D1+D2+D3+D4+ost2
            #print(add)

            End = []

            for elems in add:
                for x in elems:
                #print(elems)
                    f = foo(x)
                    End.append(f)

            End1=[]

            for elems in End:
                for x in elems:
                #print(elems)
                    
                    End1.append(str(x))



            #print(End)
            #print(End1)
            ex = (''.join(End1))
            exx = int(ex)
            exxx = str(exx)
            exxxx = len(exxx)
            if exxxx == 20:
                if exx == 30568377312064202855:
                    print(ex,"length>",len(ex),"   right side>",ost)
                    break
                else:
                    
                    print(exx,exxxx,"   right side>",ost)

33031002842015744120 20    right side> [20]
10493216611310103980 20    right side> [20]
11641140504016533410 20    right side> [20]
30122010327100627463 20    right side> [20]
10002034845003022511 20    right side> [20]
10001615017710012503 20    right side> [20]
11323155020102408390 20    right side> [20]
12000101405020523132 20    right side> [20]
61982180100000315500 20    right side> [20]
22810420011220500164 20    right side> [20]
12760113116251113467 20    right side> [20]
30673057540316161694 20    right side> [20]
10513518702621631511 20    right side> [20]
24141601500100508318 20    right side> [20]
10014352140000001154 20    right side> [20]
30124201718010021413 20    right side> [20]
12531011510613031061 20    right side> [20]
51458219016130231610 20    right side> [20]
53268549001523312981 20    right side> [20]
10011329111100031232 20    right side> [20]
14012110000054926347 20    right side> [20]
20010001146919501118 20    right side> [20]
41513911021200003737 20    right side> [20]
66222231600000021134 20    right side> [20]
18640001450617233863 20    right side> [20]
21041812041510931232 20    right side> [20]
15422601112320080210 20    right side> [20]
12275141002052169371 20    right side> [20]
71040404700376523213 20    right side> [20]
11281000052352001442 20    right side> [20]
86241148022712081110 20    right side> [20]
19131254415022171667 20    right side> [20]
20030134611000015140 20    right side> [20]
20500352114191515212 20    right side> [20]
84119219102000100884 20    right side> [20]
20245012000100421017 20    right side> [20]
40326302060701147517 20    right side> [20]
29620223100071049380 20    right side> [20]
20211333210051241928 20    right side> [20]
36371432318510281649 20    right side> [20]
15177040193800029542 20    right side> [20]
10221161186100032114 20    right side> [20]
76808034218201702369 20    right side> [20]
12000045240011121215 20    right side> [20]
10003023349060811081 20    right side> [20]

***
in this crap, the output ends up going through a set from 0-0 to 9-9 (but not always).

[['0', '0'], ['0', '1'], ['0', '2'], ['0', '3'], ['0', '4'], ['0', '5'], ['0', '6'], ['0', '7'], ['0', '8'], ['0', '9'], ['1', '1'], ['1', '2'], ['1', '3'], ['1', '4'], ['1', '5'], ['1', '6'], ['1', '7'], ['1', '8'], ['1', '9'], ['2', '2'], ['2', '3'], ['2', '4'], ['2', '5'], ['2', '6'], ['2', '7'], ['2', '8'], ['2', '9'], ['3', '3'], ['3', '4'], ['3', '5'], ['3', '6'], ['3', '7'], ['3', '8'], ['3', '9'], ['4', '4'], ['4', '5'], ['4', '6'], ['4', '7'], ['4', '8'], ['4', '9'], ['5', '5'], ['5', '6'], ['5', '7'], ['5', '8'], ['5', '9'], ['6', '6'], ['6', '7'], ['6', '8'], ['6', '9'], ['7', '7'], ['7', '8'], ['7', '9'], ['8', '8'], ['8', '9'], ['9', '9'], ['9', '8'], ['9', '7'], ['9', '6'], ['9', '5'], ['9', '4'], ['9', '3'], ['9', '2'], ['9', '1'], ['9', '0'], ['8', '7'], ['8', '6'], ['8', '5'], ['8', '4'], ['8', '3'], ['8', '2'], ['8', '1'], ['8', '0'], ['7', '6'], ['7', '5'], ['7', '4'], ['7', '3'], ['7', '2'], ['7', '1'], ['7', '0'], ['6', '5'], ['6', '4'], ['6', '3'], ['6', '2'], ['6', '1'], ['6', '0'], ['5', '4'], ['5', '3'], ['5', '2'], ['5', '1'], ['5', '0'], ['4', '3'], ['4', '2'], ['4', '1'], ['4', '0'], ['3', '2'], ['3', '1'], ['3', '0'], ['2', '1'], ['2', '0'], ['1', '0']] 100

and there are 100 (but not always).

77
***
first num breaking > [(67, 10)]
***
first num> (67, 10) first num left> (55, 12) right ost >  [10]
***
first num left> (55, 12) left> (6, 49) right> (9, 3) ost> [10]
***
left> [(3, 3)] [(45, 4)] right> [(7, 2)] [(0, 3)] ost> [(7, 3)]                           <== loop from this step
***
[(3, 0), (1, 2), (24, 21), (0, 4), (5, 2), (1, 1), (0, 0), (1, 2), (4, 3), (3, 0)]
***
['3', '0', '1', '2', '24', '21', '0', '4', '5', '2', '1', '1', '0', '0', '1', '2', '4', '3', '3', '0']
***
3012242104521100124330 lenght 22
[(0, 3), (0, 3), (18, 27), (4, 0), (1, 6), (0, 2), (0, 0), (0, 3), (6, 1), (0, 3)]
***
['0', '3', '0', '3', '18', '27', '4', '0', '1', '6', '0', '2', '0', '0', '0', '3', '6', '1', '0', '3']
***
0303182740160200036103 lenght 22
[(1, 2), (0, 3), (41, 4), (4, 0), (0, 7), (2, 0), (0, 0), (2, 1), (7, 0), (3, 0)]
***
['1', '2', '0', '3', '41', '4', '4', '0', '0', '7', '2', '0', '0', '0', '2', '1', '7', '0', '3', '0']
***
120341440072000217030 lenght 21


here we can, of course, loop over these 100

and 1 more moment whether there is any sense in it is not clear. if our number 30568377312064202855 turned to 77

then each puzzle has its own number he dances there from 40 to 140 mostly

from 10000000000000000000 to 18446744073709551615

10000000000000000000 1
10000000000000000001 2
10000000000000000002 3
10000000000000000003 4
10000000000000000004 5
10000000000000000005 6
10000000000000000006 7
10000000000000000007 8
10000000000000000008 9
10000000000000000009 10
10000000000000000010 2
10000000000000000011 3
10000000000000000012 4
10000000000000000013 5
10000000000000000014 6
10000000000000000015 7
10000000000000000016 8
10000000000000000017 9
10000000000000000018 10
10000000000000000019 11
10000000000000000020 3
10000000000000000021 4
10000000000000000022 5
10000000000000000023 6
10000000000000000024 7
10000000000000000025 8
10000000000000000026 9
10000000000000000027 10
10000000000000000028 11
10000000000000000029 12
10000000000000000030 4
10000000000000000031 5
10000000000000000032 6
10000000000000000033 7
10000000000000000034 8
10000000000000000035 9

or with a big step

10000000001234567890 46
10000000002469135780 46
10000000003703703670 37
10000000004938271560 46
10000000006172839450 46
10000000007407407340 37
10000000008641975230 46
10000000009876543120 46
10000000011111111010 10
10000000012345678900 46
10000000013580246790 46
10000000014814814680 46
10000000016049382570 46
10000000017283950460 46
10000000018518518350 46
10000000019753086240 46
10000000020987654130 46
10000000022222222020 19
10000000023456789910 55
10000000024691357800 46
10000000025925925690 55
10000000027160493580 46
10000000028395061470 46
10000000029629629360 55
10000000030864197250 46
10000000032098765140 46
10000000033333333030 28
10000000034567900920 46
10000000035802468810 46
10000000037037036700 37
10000000038271604590 46
10000000039506172480 46
10000000040740740370 37
10000000041975308260 46
10000000043209876150 46

etc.

10000000000000000000 1
11123123213123123123 38
12246246426246246246 75
13369369639369369369 112
14492492852492492492 95
15615616065615615615 78
16738739278738738738 115
17861862491861861861 98

is there any point in making several brute-force programs fixed from 40 to 140?...

import random


i =       10000000000000000000
while i<= 18446744073709551615:

    h1 = str(i)

    g1 = ([h1[i:i + 2] for i in range(0, len(h1), 2)])
    #print(g1)

    A=[]
    for elem in g1:
        g2 = ([elem[i:i + 1] for i in range(0, len(elem), 1)])
        A.append(g2)

    #print(A)    
    #print(A[0])

    B = []

    for elems in A:
        result = [int(item) for item in elems]
        v = sum(result)
        B.append(v)
        #print(v)

    #print(B)

    C = []
    g3 = ([B[i:i + 2] for i in range(0, len(B), 2)])
    #print(g3,len(g3))

    for elems in g3:
        result = [int(item) for item in elems]
        v = sum(result)
        C.append(v)
        #print(v)

    #print(C)

    c1 = int(C[0])+ int(C[1])
    c2 = int(C[2])+ int(C[3])
    c3 = int(C[4])

    #print(c1,c2,c3)


    f1= c1+c2
    f2= c3
    #print(f1,f2)

    b1 = f1+f2
    print(i,b1)
    
    i=i+1234567890

[/size]

import random
from bit import Key
import time

list = ["16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN","13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so","1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9",
        "1MVDYgVaSN6iKKEsbzRUAYFrYJadLYZvvZ","19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG","1DJh2eHFYQfACPmrvpyWc8MSTYKh7w9eRF",
        "1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU","1JTK7s9YVYywfm5XUH7RNhHJH1LshCaRFR","12VVRNPi4SJqUTsp6FmqDqY5sGosDtysn4",
        "1FWGcVDK3JGzCC3WtkYetULPszMaK2Jksv","1DJh2eHFYQfACPmrvpyWc8MSTYKh7w9eRF","1Bxk4CQdqL9p22JEtDfdXMsng1XacifUtE",
        "15qF6X51huDjqTmF9BJgxXdt1xcj46Jmhb","1ARk8HWJMn8js8tQmGUJeQHjSE7KRkn2t8","15qsCm78whspNQFydGJQk5rexzxTQopnHZ",
        "13zYrYhhJxp6Ui1VV7pqa5WDhNWM45ARAC","14MdEb4eFcT3MVG5sPFG4jGLuHJSnt1Dk2","1CMq3SvFcVEcpLMuuH8PUcNiqsK1oicG2D",
        "1K3x5L6G57Y494fDqBfrojD28UJv4s5JcK","1PxH3K1Shdjb7gSEoTX7UPDZ6SH4qGPrvq","16AbnZjZZipwHMkYKBSfswGWKDmXHjEpSf",
        "19QciEHbGVNY4hrhfKXmcBBCrJSBZ6TaVt","1EzVHtmbN4fs4MiNk3ppEnKKhsmXYJ4s74","1AE8NzzgKE7Yhz7BWtAcAAxiFMbPo82NB5",
        "17Q7tuG2JwFFU9rXVj3uZqRtioH3mx2Jad","1K6xGMUbs6ZTXBnhw1pippqwK6wjBWtNpL","15ANYzzCp5BFHcCnVFzXqyibpzgPLWaD8b",
        "18ywPwj39nGjqBrQJSzZVq2izR12MDpDr8","1CaBVPrwUxbQYYswu32w7Mj4HR4maNoJSX","1JWnE6p6UN7ZJBN7TtcbNDoRcjFtuDWoNL",
        "1CKCVdbDJasYmhswB6HKZHEAnNaDpK7W4n","1PXv28YxmYMaB8zxrKeZBW8dt2HK7RkRPX","1AcAmB6jmtU6AiEcXkmiNE9TNVPsj9DULf",
        "1EQJvpsmhazYCcKX5Au6AZmZKRnzarMVZu","18KsfuHuzQaBTNLASyj15hy4LuqPUo1FNB","15EJFC5ZTs9nhsdvSUeBXjLAuYq3SWaxTc",
        "1HB1iKUqeffnVsvQsbpC6dNi1XKbyNuqao","1GvgAXVCbA8FBjXfWiAms4ytFeJcKsoyhL","12JzYkkN76xkwvcPT6AWKZtGX6w2LAgsJg",
        "1824ZJQ7nKJ9QFTRBqn7z7dHV5EGpzUpH3","18A7NA9FTsnJxWgkoFfPAFbQzuQxpRtCos","1NeGn21dUDDeqFQ63xb2SpgUuXuBLA4WT4",
        "1NLbHuJebVwUZ1XqDjsAyfTRUPwDQbemfv","1MnJ6hdhvK37VLmqcdEwqC3iFxyWH2PHUV","1KNRfGWw7Q9Rmwsc6NT5zsdvEb9M2Wkj5Z",
        "1PJZPzvGX19a7twf5HyD2VvNiPdHLzm9F6","1GuBBhf61rnvRe4K8zu8vdQB3kHzwFqSy7","17s2b9ksz5y7abUm92cHwG8jEPCzK3dLnT",
        "1GDSuiThEV64c166LUFC9uDcVdGjqkxKyh","1Me3ASYt5JCTAK2XaC32RMeH34PdprrfDx","1CdufMQL892A69KXgv6UNBD17ywWqYpKut",
        "1BkkGsX9ZM6iwL3zbqs7HWBV7SvosR6m8N","1PXAyUB8ZoH3WD8n5zoAthYjN15yN5CVq5","1AWCLZAjKbV1P7AHvaPNCKiB7ZWVDMxFiz",
        "1G6EFyBRU86sThN3SSt3GrHu1sA7w7nzi4","1MZ2L1gFrCtkkn6DnTT2e4PFUTHw9gNwaj","1Hz3uv3nNZzBVMXLGadCucgjiCs5W9vaGz",
        "1Fo65aKq8s8iquMt6weF1rku1moWVEd5Ua","16zRPnT8znwq42q7XeMkZUhb1bKqgRogyy","1KrU4dHE5WrW8rhWDsTRjR21r8t3dsrS3R",
        "17uDfp5r4n441xkgLFmhNoSW1KWp6xVLD","13A3JrvXmvg5w9XGvyyR4JEJqiLz8ZySY3","16RGFo6hjq9ym6Pj7N5H7L1NR1rVPJyw2v",
        "1UDHPdovvR985NrWSkdWQDEQ1xuRiTALq","15nf31J46iLuK1ZkTnqHo7WgN5cARFK3RA","1Ab4vzG6wEQBDNQM1B2bvUz4fqXXdFk2WT",
        "1Fz63c775VV9fNyj25d9Xfw3YHE6sKCxbt","1QKBaU6WAeycb3DbKbLBkX7vJiaS8r42Xo","1CD91Vm97mLQvXhrnoMChhJx4TP9MaQkJo",
        "15MnK2jXPqTMURX4xC3h4mAZxyCcaWWEDD","13N66gCzWWHEZBxhVxG18P8wyjEWF9Yoi1","1NevxKDYuDcCh1ZMMi6ftmWwGrZKC6j7Ux",
        "19GpszRNUej5yYqxXoLnbZWKew3KdVLkXg","1M7ipcdYHey2Y5RZM34MBbpugghmjaV89P","18aNhurEAJsw6BAgtANpexk5ob1aGTwSeL",
        "1FwZXt6EpRT7Fkndzv6K4b4DFoT4trbMrV","1CXvTzR6qv8wJ7eprzUKeWxyGcHwDYP1i2","1MUJSJYtGPVGkBCTqGspnxyHahpt5Te8jy",
        "13Q84TNNvgcL3HJiqQPvyBb9m4hxjS3jkV","1LuUHyrQr8PKSvbcY1v1PiuGuqFjWpDumN","18192XpzzdDi2K11QVHR7td2HcPS6Qs5vg",
        "1NgVmsCCJaKLzGyKLFJfVequnFW9ZvnMLN","1AoeP37TmHdFh8uN72fu9AqgtLrUwcv2wJ","1FTpAbQa4h8trvhQXjXnmNhqdiGBd1oraE",
        "14JHoRAdmJg3XR4RjMDh6Wed6ft6hzbQe9","19z6waranEf8CcP8FqNgdwUe1QRxvUNKBG","14u4nA5sugaswb6SZgn5av2vuChdMnD9E5",
        "174SNxfqpdMGYy5YQcfLbSTK3MRNZEePoy", "1NBC8uXJy1GiJ6drkiZa1WuKn51ps7EPTv"]

def foo(number):
    first = random.randint(0, number)
    second = number - first
    return first, second

vib = random.randint(40, 130) # <== Start

#count = 0

while True:

    a = foo(vib) # <== Start

    A=[]
    ost = []

    B=[]

    C1=[]
    C2=[]

    b=a
    A.append(b)

    #print(a,b,A)

    for elem in A:
        f = foo(elem[0])
        B.append(f)
        ost.append(elem[1])
        #print(elem,f,ost)

    D1=[]
    D2=[]
    D3=[]
    D4=[]
    ost2 = []

    for elems in B:
        f1 = foo(elems[0])
        f2 = foo(elems[1])
        C1.append(f1)
        C2.append(f2)
        #ost.append(elem[1])
        #print(elems,f1,f2,C1,C2,ost)

    for elems in C1:
        f1 = foo(elems[0])
        f2 = foo(elems[1])
        D1.append(f1)
        D2.append(f2)
        #ost.append(elem[1])
        #print(D1,D2)

    for elems in C2:
        f1 = foo(elems[0])
        f2 = foo(elems[1])
        D3.append(f1)
        D4.append(f2)
        #ost.append(elem[1])
        #print(D3,D4)

    for elems in ost:
        f1 = foo(elems)
        #f2 = foo(elems[1])
        ost2.append(f1)
        #D4.append(f2)
        #ost.append(elem[1])
        #print(D3,D4)

    #print(D1,D2,D3,D4,ost2)    
    add = D1+D2+D3+D4+ost2
    #print(add)
    count = 0
    i=1
    while i <=100000:                          #<== LOOP

        count += 1
        End = []

        for elems in add:
            for x in elems:
            #print(elems)
                f = foo(x)
                End.append(f)

        End1=[]

        for elems in End:
            for x in elems:
            #print(elems)
                
                End1.append(str(x))

        #print(End)
        #print(End1)
                
        #time.sleep(0.02)
        
        ex = (''.join(End1))
        exx = int(ex)
        exxx = str(exx)
        exxxx = len(exxx)
        if exxxx >= 20:

            #time.sleep(0.02)
            
            #count += 1
            
            ran = exx
            key1 = Key.from_int(ran)
        
            addr1 = key1.address
        
            if addr1 in list:

                print (ran,"found!!!")

                s5 = str(ran)
                f=open(u"C:/a.txt","a")
                f.write(s5 + '\n')
                f.close()

                break

            else:
                
                #pass
                print(count,ran,exxxx,addr1) #(count,ran,exxxx,addr1)

        i=i+1
    print("loop end...")
    count = 0
    pass

[/size]

[Matic]

I don't believe there could be that big price

[Markzuberg64]

Can you please check your PM Sir.

How do y'all know how many bits a public key is?

It is not possible to know the private key bit length from the public key

MrFreeDragon, I have question for you if you can explain to me please !! how brainless can find that those address are 100bits ?
let think that he take the 110 address and try to add negative hex numbres to reduce the bit ,right !! but even that how he can be sure that the numbre that he add make address from 110bit to 100bit !!? that is really weird
the only thing that we know is 2^n = 2^(n-1) + 2^(n-2) .....+ 2^(n-n+1) + 2 !!
but if we have "n" =in range 110 and 111 that make impossible to know of even predict the bit of wallet.
if you have any idea please.

thanks

dear bro
do you like test and proof that my 110bit pubk to 100 bit pubk, mean 10 bit down PM for take test
thankx

[WanderingPhilospher]

Can you please check your PM Sir.

How do y'all know how many bits a public key is?

It is not possible to know the private key bit length from the public key

MrFreeDragon, I have question for you if you can explain to me please !! how brainless can find that those address are 100bits ?
let think that he take the 110 address and try to add negative hex numbres to reduce the bit ,right !! but even that how he can be sure that the numbre that he add make address from 110bit to 100bit !!? that is really weird
the only thing that we know is 2^n = 2^(n-1) + 2^(n-2) .....+ 2^(n-n+1) + 2 !!
but if we have "n" =in range 110 and 111 that make impossible to know of even predict the bit of wallet.
if you have any idea please.

thanks

dear bro
do you like test and proof that my 110bit pubk to 100 bit pubk, mean 10 bit down PM for take test
thankx

He is shifting the pubkeys down; if a pubkey is known, you can point mul or point div by point add. He may use more research in shifting pubkeys down but uses same formula.

[WanderingPhilospher]

This code I use to scan #64 using python 3.xxx:

Code:

import binascii, blocksmith

a = 2**63
b = 2**64-1
prehex = '0000000000000000000000000000000000000000000000007CCE5EFDACCF6808'
wallettofind = '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN'
fwrite = open('YourFileName.txt', 'a')

print('Scan is Running')
for i in range(a,b):
    privhex = hex(i)[2:]
    dumppriv = prehex+str(privhex)
    walletscan = blocksmith.BitcoinWallet.generate_compressed_address(dumppriv)
    if walletscan == wallettofind:
        fwrite.write('Key: '+ str(privhex) + ' ( '+str(walletscan)+' ) \n')
        break
else:
    #fwrite.write('Not Found!!!') if you set b value less than 2**64-1 then you can use this i.e b= 2**63+1000000000 and will only scan for 1000000000 keys between 9223372036854775808 (2**63) to 9223372037854775808
fwrite.close()
print('Scan Finish!')

Do i just add this one if only wanting the 64th to be searched,
0000000000000000000000000000000000000000000000007CCE5EFDACCF6808 so adding this
added the a append, anything needed to be printed onscreen while searching?
like speed or time left or
#print(hex(i))
#print(key1.address)
#print(key2.address)
  print(i,wif,wif2) #(i,wif,wif2,key1.address,key2.address)
any of these, i know i already asked to much.

Keep the prehex as it was...the prehex should be all zeros; the prehex ensures the priv key is 64 characters long (dumppriv = prehex+str(privhex)) before generating pub key. So if you are searching the 64 bit range then the prehex should have 48 zeros...16 chars for 64 bit hex + 48 zeros to pad the string and make it 64 characters

[dextronomous]

wow wandering, thanks for your reply,
needed that information, so great stuff,
then its only showing scan is running,
maybe something to be added like.

Target Addr or Pattern: 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN
Min Range: 63
Max Range: 65
Magnitude: 100
================
58449828it [20:48:19, 770.99it/s]

or left to search keyspace it is doing this random in this keyspace all not checked for checksum or
is it checked, so could i not ask it to do stdout or ? > to .txt thanks in advance friend.

[WanderingPhilospher]

wow wandering, thanks for your reply,
needed that information, so great stuff,
then its only showing scan is running,
maybe something to be added like.

Target Addr or Pattern: 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN
Min Range: 63
Max Range: 65
Magnitude: 100
================
58449828it [20:48:19, 770.99it/s]

or left to search keyspace it is doing this random in this keyspace all not checked for checksum or
is it checked, so could i not ask it to do stdout or ? > to .txt thanks in advance friend.

I created something similar awhile back using python 2.7 but looking at the code, it looks like it checks keys sequentially [for i in range(a,b)], from the start of 63 up to 64 bits. Hex range of 8000000000000000:FFFFFFFFFFFFFFFF

[indoarts]

Wonderful thread for people who cant buy fancy GPU like me

[nomadsena]

completey unrelated to this topic and basically a noob question. but i read somewhere here on this thread that "directory.io has 904625697166532776746648320380374280100293470930272690489102837043110636675 pages thats almost all the private keys". if generating all the private keys combinations takes more then the age of universe with current technology, how come they generated them all.

[WanderingPhilospher]

completey unrelated to this topic and basically a noob question. but i read somewhere here on this thread that "directory.io has 904625697166532776746648320380374280100293470930272690489102837043110636675 pages thats almost all the private keys". if generating all the private keys combinations takes more then the age of universe with current technology, how come they generated them all.

Each page is only generated if visited...basically each page contains say 100 keys/addresses, so the website script knows if you visit page 900 to calculate the keys for 9000 through 9100.

[nioctib.co]

completey unrelated to this topic and basically a noob question. but i read somewhere here on this thread that "directory.io has 904625697166532776746648320380374280100293470930272690489102837043110636675 pages thats almost all the private keys". if generating all the private keys combinations takes more then the age of universe with current technology, how come they generated them all.

Each page is only generated if visited...basically each page contains say 100 keys/addresses, so the website script knows if you visit page 900 to calculate the keys for 9000 through 9100.

I have another noob question for you about the website privatekeys.pw. Why they can provide a Search Private Key queries but not Search Address? If their website able to Search Private Key, why can't they do Search Address for their pages?

[nomadsena]

completey unrelated to this topic and basically a noob question. but i read somewhere here on this thread that "directory.io has 904625697166532776746648320380374280100293470930272690489102837043110636675 pages thats almost all the private keys". if generating all the private keys combinations takes more then the age of universe with current technology, how come they generated them all.

Each page is only generated if visited...basically each page contains say 100 keys/addresses, so the website script knows if you visit page 900 to calculate the keys for 9000 through 9100.

thanks for the reply but why do they have this at the bottom of their page:"It took a lot of computing power to generate this database. Donations welcome: 1LBCPotwPzBvBcTtd7ADGzCWPXXsZE19j6". i thought all the address were already generated.