Bitcoin puzzle transaction ~32 BTC prize to who solves it

[fecell]

He just generated a series of normal full-length private keys with good PRNG, and then manually masked (XOR-ed) them to required length one by one.

i know. i wanna know a env where this process was doing.

[1714827672]

1714827672

[1714827672]

1714827672

[1714827672]

1714827672

[itod]

He just generated a series of normal full-length private keys with good PRNG, and then manually masked (XOR-ed) them to required length one by one.

i know. i wanna know a env where this process was doing.

He almost certainly used some env with good entropy, he obviously knew what he was doing. Zero chance that these random numbers have a weakness on PRNG side.

[fxsniper]

is OP still here?
can you explain your env used to create tx? win, mac, nix, python, btc core, other wallet? what a flags was used to compile openssl-1.0.1c?

If you read the OP you would see that OP was not the one who created the transactions.

BTW, the one who created the transactions explained it in another thread. He just generated a series of normal full-length private keys with good PRNG, and then manually masked (XOR-ed) them to required length one by one.

sound like create puzzle list by binary level

may be like the other puzzle
https://bitcointalk.org/index.php?topic=766000.0

https://github.com/ynohtna92/1FLAMEN6/blob/master/puzzle_decoder.py

something like that?

[fxsniper]

for some python code use random

I found some code can use with GPU

use numba

try code from this
https://stackoverflow.com/questions/61982672/cuda-gpu-processing-typeerror-compile-kernel-got-an-unexpected-keyword-argum

just found code work on GPU, I will try testing move some random code to run on numba it can be work faster or not?

[WanderingPhilospher]

@fxsniper

Here is the code I told you I would upload.  It's not the exact one I was looking for but it is based on the same principle.  Easy to change the range you want to search through. I modified my code to search for the RIPEMD of the address I was looking for. Shaves a few milliseconds off versus processing all the way to the address. I created this probably 6 months ago and I am sure it is not the most efficient coding.  Hopefully it gives you some ideas on how to tweak and make exactly what you are wanting.

Code:

#Amateur, very amateur coding by the Wandering Philosopher
#Tested with Python 2.7
import binascii, hashlib, base58, sys, ecdsa, codecs, os, random
import time
import timeit
#Enter the RIPEMD160 of the address you want to search for; make sure it is in LOWERCASE
ripetofind = '3ee4133d991f52fdf6a25c9834e0745ac74248a4'

def compressed_RIPEMD(privkey):
    start_time = timeit.default_timer()
    pvk_to_bytes = codecs.decode (privkey, 'hex')
    
    #Generates the public key
    key = ecdsa.SigningKey.from_string (pvk_to_bytes, curve=ecdsa.SECP256k1).verifying_key
    key_bytes = key.to_string()
    key_hex = codecs.encode(key_bytes, 'hex')

    if(ord(bytearray.fromhex(key_hex[-2:])) % 2 == 0):
        #If the last byte of Y is Even, add '02'
        public_key_compressed = '02' + key_hex[0:64]

        #Making SHA-256 of compressed pubkey and then RIPEMD-160
        public_key_in_bytes = codecs.decode(public_key_compressed, 'hex')
        sha256_public_key_compressed = hashlib.sha256(public_key_in_bytes)
        sha256_public_key_compressed_digest = sha256_public_key_compressed.digest()

        ripemd160 = hashlib.new('ripemd160')
        ripemd160.update(sha256_public_key_compressed_digest)
        ripemd160_digest = ripemd160.digest()
        ripemd160_hex = codecs.encode(ripemd160_digest, 'hex')
        
    else:
        #If the last byte of Y is Odd, add '03'
        public_key_compressed = '03' + key_hex[0:64]

        #Making SHA-256 of compressed pubkey and then RIPEMD-160
        public_key_in_bytes = codecs.decode(public_key_compressed, 'hex')
        sha256_public_key_compressed = hashlib.sha256(public_key_in_bytes)
        sha256_public_key_compressed_digest = sha256_public_key_compressed.digest()

        ripemd160 = hashlib.new('ripemd160')
        ripemd160.update(sha256_public_key_compressed_digest)
        ripemd160_digest = ripemd160.digest()
        ripemd160_hex = codecs.encode(ripemd160_digest, 'hex')
        elapsed = timeit.default_timer() - start_time
        #Prints status and numbers on screen. Comment out both sys.stdout lines below if not wanted and the countall +=1 ; I liked to know it was working/running.
        sys.stdout.write("\r" + "  Key every: " + str(elapsed)[:7] + " seconds " + " Random RIPEMD160s:  " + ripemd160_hex + "   # of Keys: "  + str(countall))
        sys.stdout.flush()
        fwrite = open('KEYSFOUND.txt', 'a')
        if ripemd160_hex == ripetofind:
            fwrite.write('Key: ' + randomprivkey + '  ' + ripemd160_hex + '\n' )

#Always leave countall = 0 below. If you want the program to run unlimited, comment out the countall +=1 down below
countall = 0
while (countall < 100000000000000):
    if __name__== "__main__":
        
        #Enter the range you want to search through below
        low  = 0x8000000000000000
        high = 0xFFFFFFFFFFFFFFFF
        #high = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140
        randomprivkey = hex( random.randrange( low, high ) ).lstrip("0x").rstrip("L").zfill(64)
        countall +=1
        compressed_RIPEMD(randomprivkey)

[indoarts]

Can this tools use for solve puzzle very old python code?
may be slow than bitcrack

https://github.com/Xefrok/BitBruteForce-Wallet/blob/master/seekanddestroy.py
may be need to modify to can use with custom keyspace for puzzle #64
done have other python script recommend to use better than?

all python code use random method right not calculate not pattern

I looking to bitcrack version python code

I would like to try use for puzzle #64 by random keyspace set it each 1000000 key and scan it and do random next keyspace
I can't not code c++ but python is easy more than. I can modify on python code

Sure it can , but in 3000000000 years ? OMG 

[fecell]

Zero chance that these random numbers have a weakness on PRNG side.

no, i search not a weakness.
each generator produce different randoms.
for example, python's randint create 256 bit with about 50/50 +/-10% zeros and ones.
but mt19937_64 in cpp produce only 32 bit, i generate pair (32+32=64) to test and got ~70/30% zeros and ones.
at 2013 bitcoin core used openssl to generate random keys. question is author are used this openssl generator or something else.
if yes, openssl compile different code for win, mac and *nix. compile flags also give different result.
if get statistic for exactly used generator, so possible make a faster bruteforcer to skip values wich have low score and probably cant be generated at 2013.

[fxsniper]

@fxsniper

Here is the code I told you I would upload.  It's not the exact one I was looking for but it is based on the same principle.  Easy to change the range you want to search through. I modified my code to search for the RIPEMD of the address I was looking for. Shaves a few milliseconds off versus processing all the way to the address. I created this probably 6 months ago and I am sure it is not the most efficient coding.  Hopefully it gives you some ideas on how to tweak and make exactly what you are wanting.

Code:

#Amateur, very amateur coding by the Wandering Philosopher
#Tested with Python 2.7
import binascii, hashlib, base58, sys, ecdsa, codecs, os, random
import time
import timeit
#Enter the RIPEMD160 of the address you want to search for; make sure it is in LOWERCASE
ripetofind = '3ee4133d991f52fdf6a25c9834e0745ac74248a4'

def compressed_RIPEMD(privkey):
    start_time = timeit.default_timer()
    pvk_to_bytes = codecs.decode (privkey, 'hex')
    
    #Generates the public key
    key = ecdsa.SigningKey.from_string (pvk_to_bytes, curve=ecdsa.SECP256k1).verifying_key
    key_bytes = key.to_string()
    key_hex = codecs.encode(key_bytes, 'hex')

    if(ord(bytearray.fromhex(key_hex[-2:])) % 2 == 0):
        #If the last byte of Y is Even, add '02'
        public_key_compressed = '02' + key_hex[0:64]

        #Making SHA-256 of compressed pubkey and then RIPEMD-160
        public_key_in_bytes = codecs.decode(public_key_compressed, 'hex')
        sha256_public_key_compressed = hashlib.sha256(public_key_in_bytes)
        sha256_public_key_compressed_digest = sha256_public_key_compressed.digest()

        ripemd160 = hashlib.new('ripemd160')
        ripemd160.update(sha256_public_key_compressed_digest)
        ripemd160_digest = ripemd160.digest()
        ripemd160_hex = codecs.encode(ripemd160_digest, 'hex')
        
    else:
        #If the last byte of Y is Odd, add '03'
        public_key_compressed = '03' + key_hex[0:64]

        #Making SHA-256 of compressed pubkey and then RIPEMD-160
        public_key_in_bytes = codecs.decode(public_key_compressed, 'hex')
        sha256_public_key_compressed = hashlib.sha256(public_key_in_bytes)
        sha256_public_key_compressed_digest = sha256_public_key_compressed.digest()

        ripemd160 = hashlib.new('ripemd160')
        ripemd160.update(sha256_public_key_compressed_digest)
        ripemd160_digest = ripemd160.digest()
        ripemd160_hex = codecs.encode(ripemd160_digest, 'hex')
        elapsed = timeit.default_timer() - start_time
        #Prints status and numbers on screen. Comment out both sys.stdout lines below if not wanted and the countall +=1 ; I liked to know it was working/running.
        sys.stdout.write("\r" + "  Key every: " + str(elapsed)[:7] + " seconds " + " Random RIPEMD160s:  " + ripemd160_hex + "   # of Keys: "  + str(countall))
        sys.stdout.flush()
        fwrite = open('KEYSFOUND.txt', 'a')
        if ripemd160_hex == ripetofind:
            fwrite.write('Key: ' + randomprivkey + '  ' + ripemd160_hex + '\n' )

#Always leave countall = 0 below. If you want the program to run unlimited, comment out the countall +=1 down below
countall = 0
while (countall < 100000000000000):
    if __name__== "__main__":
        
        #Enter the range you want to search through below
        low  = 0x8000000000000000
        high = 0xFFFFFFFFFFFFFFFF
        #high = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140
        randomprivkey = hex( random.randrange( low, high ) ).lstrip("0x").rstrip("L").zfill(64)
        countall +=1
        compressed_RIPEMD(randomprivkey)

Thanks

this code find RIPEMD-160 hash before convert to address right


if(ord(bytearray.fromhex(key_hex[-2:])) % 2 == 0):


TypeError: fromhex() argument must be str, not bytes

[WanderingPhilospher]

Thanks

this code find RIPEMD-160 hash before convert to address right


if(ord(bytearray.fromhex(key_hex[-2:])) % 2 == 0):


TypeError: fromhex() argument must be str, not bytes

I use it on python 2.7 (windows) and it works like a charm.  Are you using 2.7 or 3.x?

[fxsniper]

I use it on python 2.7 (windows) and it works like a charm.  Are you using 2.7 or 3.x?

ok, I use 3.9

will try on 2.7

I have both 2.7 and 3.x use on miniconda two version

[fxsniper]

I use it on python 2.7 (windows) and it works like a charm.  Are you using 2.7 or 3.x?

ok now it work fine on 2.7


how can I change 

ripetofind = '3ee4133d991f52fdf6a25c9834e0745ac74248a4'


I try use this web is correct
http://gobittest.appspot.com/Address

put address below and submit get address upper  RIPEMD-160 Hash

puzzle #64  3EE4133D991F52FDF6A25C9834E0745AC74248A4
puzzle #120   AE6804B35C82F47F8B0A42D8C5E514FE5EF0A883

[fxsniper]

one thing about all script python and any script

if it display show message detail like show key or show generate, show random, show runing number

try test until make sure it work 100%

then modify change to hide all message it make to working fast than show massage

just turn off show display it make to faster

show display it make script works slowly it not necessary

try it you can see it work better.

let script calculate work without display and make it save result to file make show only when success

[WanderingPhilospher]

one thing about all script python and any script

if it display show message detail like show key or show generate, show random, show runing number

try test until make sure it work 100%

then modify change to hide all message it make to working fast than show massage

just turn off show display it make to faster

show display it make script works slowly it not necessary

try it you can see it work better.

let script calculate work without display and make it save result to file make show only when success

I know it works faster without any printout, 100%...just shows it's working. Run small range test, like F to FFF. Once convinced it works, turn it off.

[WanderingPhilospher]

I use it on python 2.7 (windows) and it works like a charm.  Are you using 2.7 or 3.x?

ok now it work fine on 2.7


how can I change 

ripetofind = '3ee4133d991f52fdf6a25c9834e0745ac74248a4'


I try use this web is correct
http://gobittest.appspot.com/Address

put address below and submit get address upper  RIPEMD-160 Hash

puzzle #64  3EE4133D991F52FDF6A25C9834E0745AC74248A4
puzzle #120   AE6804B35C82F47F8B0A42D8C5E514FE5EF0A883

yes, #64 is in the ripetofind by default. You can change ripe to whichever one you prefer/want. Yes, that site works for ripemd160; just put the address in bottom box and select send. or you can decode the address in base58. Just change it to lowercase once you receive the ripemd160...

or use this code:

Code:

import base58

addr58 = '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN'

addr160 = base58.b58decode_check(addr58).encode('hex')[2:]

print (addr160)

[Andzhig]

continuation of research https://bitcointalk.org/index.php?topic=1306983.msg56527262#msg56527262...

2^...
4194303
8388607  
16777215 pz > 14428676
33554431 pz > 33185509
67108863 pz > 54538862
134217727
268435455
2^...


14428676

[5, 6, 14, 13]
5460
[6, 7, 5, 6]
1260               84 x 12, 24

33185509

[6, 9, 10, 9]
4860
[7, 10, 9, 10]
6300               12 x 12  


54538862

[9, 8, 16, 8]
9216
[10, 9, 3, 9]
2430               24 x 12


1x1x1x1       1
10x10x10x10 10000

1

1260    
2430  
6300  

10000



54538862

(5, 9, 9, 6) 2430
(9, 9, 5, 6) 2430
(6, 5, 9, 9) 2430
(10, 3, 9, 9) 2430
(6, 9, 9, 5) 2430
(9, 3, 10, 9) 2430
(9, 6, 9, 5) 2430
(10, 9, 3, 9) 2430 10, 9, 3, 9
(3, 9, 10, 9) 2430
(9, 5, 9, 6) 2430
(5, 9, 6, 9) 2430
(10, 9, 9, 3) 2430
(9, 3, 9, 10) 2430
(9, 9, 3, 10) 2430
(9, 10, 3, 9) 2430
(6, 9, 5, 9) 2430
(3, 10, 9, 9) 2430
(3, 9, 9, 10) 2430
(5, 6, 9, 9) 2430
(9, 5, 6, 9) 2430
(9, 9, 10, 3) 2430
(9, 6, 5, 9) 2430
(9, 10, 9, 3) 2430
(9, 9, 6, 5) 2430
24


(3, 9, 9, 10)
(9, 9, 10, 3)
(9, 3, 10, 9)
(9, 9, 3, 10)
(9, 10, 9, 3)
(10, 3, 9, 9)
(9, 10, 3, 9)
(10, 9, 3, 9) 10, 9, 3, 9
(3, 9, 10, 9)
(3, 10, 9, 9)
(10, 9, 9, 3)
(9, 3, 9, 10)
12

and that 24 options, 12 for each 24 x 12 = 288 ,  288 x 2430 = 699840

54538862 54 53 88 62
[10, 9, 3, 9] 2430
[9, 8, 16, 8] 9216      

10 <> 9
[(0, 9), (1, , (2, 7), (3, 6), (4, 5), (5, 4), (6, 3), (7, 2), (8, 1), (9, 0)]

9 <> 8
[(0, , (1, 7), (2, 6), (3, 5), (4, 4), (5, 3), (6, 2), (7, 1), (8, 0)]

3 <> 16
[(7, 9), (8, 8), (9, 7)]

9 <> 8
[(0, , (1, 7), (2, 6), (3, 5), (4, 4), (5, 3), (6, 2), (7, 1), (8, 0)]


***************************

224
467
514

[4, 4]
16
[5, 5]
25

[10, 7]
70
[9, 8]
72

[6, 4]
24
[7, 5]
35


1155
2683
5216

[2, 10]
20
[3, 9]
27

[8, 11]
88
[9, 8]
72

[7, 7]
49
[8, 8]
64


10544
26867
51510
95823

[1, 9, 4]
36
[2, 10, 5]
100

[8, 14, 7]
784
[9, 5, 8]
360

[6, 6, 0]
0
[7, 7, 2]
98

[14, 10, 3]
420
[5, 9, 4]
180


198669
357535
863317

[10, 14, 15]
2100
[9, 5, 4]
180

[8, 12, 8]
768
[9, 7, 9]
567

[14, 6, 8]
672
[5, 7, 9]
315


1811764
3007503
5598802

[9, 2, 13, 4]
936
[10, 3, 6, 5]
900

[3, 7, 5, 3]
315
[4, 8, 6, 4]
768

[10, 17, 8, 2]
2720
[9, 2, 9, 3]
486


14428676
33185509
54538862

[5, 6, 14, 13]
5460
[6, 7, 5, 6]
1260

[6, 9, 10, 9]
4860
[7, 10, 9, 10]
6300

[9, 8, 16, 8]
9216
[10, 9, 3, 9]
2430


111949941
227634408
400708894

[2, 10, 13, 13, 1]
3380
[3, 9, 6, 6, 2]
1944

[4, 13, 7, 4, 8]
11648
[5, 6, 8, 5, 9]
10800

[4, 7, 8, 17, 4]
15232
[5, 8, 9, 2, 5]
3600


1033162084
2102388551
3093472814
7137437912

[1, 6, 7, 2, 12]
1008
[2, 7, 8, 3, 7]
2352

[3, 2, 11, 13, 6]
5148
[4, 3, 8, 6, 7]
4032

[3, 12, 11, 10, 5]
19800
[4, 7, 8, 9, 6]
12096

[8, 10, 7, 16, 3]
26880
[9, 9, 8, 3, 4]
7776


14133072157
20112871792
42387769980

[5, 4, 3, 9, 6, 7]
22680
[6, 5, 4, 10, 7, 8]
67200

[2, 2, 10, 8, 16, 2]
10240
[3, 3, 9, 9, 3, 3]
6561

[6, 11, 14, 15, 17, 0]
0
[7, 8, 5, 4, 2, 2]
4480


100251560595
146971536592
323724968937

[1, 2, 6, 11, 5, 14]
9240
[2, 3, 7, 8, 6, 5]
10080

[5, 15, 8, 8, 11, 11]
580800
[6, 4, 9, 9, 8, 8]
124416

[5, 10, 6, 15, 17, 10]
765000
[6, 9, 7, 4, 2, 9]
27216


1003651412950
1458252205147
2895374552463
7409811047825

[1, 3, 11, 5, 3, 14, 0]
6930
[2, 4, 8, 6, 4, 5, 2]
15360

[5, 13, 7, 4, 5, 5, 7]
318500
[6, 6, 8, 5, 6, 6, 8]
414720

[10, 14, 10, 9, 7, 10, 3]
2646000
[9, 5, 9, 10, 8, 9, 4]
1166400

[11, 9, 9, 1, 11, 10, 5]
490050
[8, 10, 10, 2, 8, 9, 6]
691200


15404761757071
19996463086597
51408670348612

[6, 4, 11, 7, 12, 7, 8]
1241856
[7, 5, 8, 8, 7, 8, 9]
1128960

[10, 18, 10, 9, 8, 11, 16]
22809600
[9, 1, 9, 10, 9, 8, 3]
174960

[6, 4, 14, 7, 7, 14, 3]
691488
[7, 5, 5, 8, 8, 5, 4]
224000


119666659114170
191206974700443
409118905032525
611140496167764

[2, 15, 12, 11, 10, 5, 8, 0]
1584000
[3, 4, 7, 8, 9, 6, 9, 2]
653184

[10, 3, 6, 16, 11, 0, 8, 3]
760320
[9, 4, 7, 3, 8, 2, 9, 4]
435456

[4, 10, 9, 9, 5, 5, 7, 5]
2835000
[5, 9, 10, 10, 6, 6, 8, 6]
7776000

[7, 2, 4, 13, 7, 13, 13, 4]
3444896
[8, 3, 5, 6, 8, 6, 6, 5]
1036800


2058769515153876
4216495639600700
6763683971478124
9974455244496707

[2, 13, 13, 14, 6, 6, 11, 13]
24360336
[3, 6, 6, 5, 7, 7, 8, 6]
1270080

[6, 7, 13, 11, 12, 6, 7, 0]
3027024
[7, 8, 6, 8, 7, 7, 8, 2]
2107392

[13, 9, 14, 12, 8, 11, 9, 6]
93405312
[6, 10, 5, 7, 9, 8, 10, 7]
10584000

[18, 11, 9, 7, 8, 13, 13, 7]
118053936
[1, 8, 10, 8, 9, 6, 6, 8]
1658880


30045390491869460
44218742292676575

[3, 4, 8, 9, 13, 9, 15, 10, 0]
15163200
[4, 5, 9, 10, 6, 10, 4, 9, 2]
7776000

[8, 3, 15, 6, 11, 8, 13, 12, 5]
148262400
[9, 4, 4, 7, 8, 9, 6, 7, 6]
18289152


138245758910846492
199976667976342049
525070384258266191

[4, 10, 9, 12, 17, 1, 12, 10, 11]
96940800
[5, 9, 10, 7, 2, 2, 7, 9, 8]
6350400

[10, 18, 13, 12, 16, 13, 7, 2, 13]
1062996480
[9, 1, 6, 7, 3, 6, 8, 3, 6]
979776

[7, 5, 7, 11, 6, 13, 8, 7, 10]
117717600
[8, 6, 8, 8, 7, 6, 9, 8, 9]
83607552


1135041350219496382
1425787542618654982
3908372542507822062
8993229949524469768

[2, 8, 4, 4, 5, 3, 13, 15, 11, 2]
16473600
[3, 9, 5, 5, 6, 4, 6, 4, 8, 3]
9331200

[5, 7, 15, 12, 6, 7, 14, 9, 17, 2]
1133546400
[6, 8, 4, 7, 7, 8, 5, 10, 2, 3]
22579200

[12, 8, 10, 7, 6, 5, 15, 4, 6, 2]
145152000
[7, 9, 9, 8, 7, 6, 4, 5, 7, 3]
80015040

[17, 12, 4, 18, 13, 7, 8, 15, 13, 8]
16680867840
[2, 7, 5, 1, 6, 8, 9, 4, 6, 9]
6531840





25
27
35
64
72
72
100
180
180
315
360
486
567
768
900
1260
1944
2352
2430
3600
4032
4480
6300
6561
7776
10080
10800
12096
15360
27216
67200
124416
174960
224000
414720
435456
653184
691200
979776   pz 58
1036800  pz 50
1128960
1166400  
1270080  pz 51
1658880  pz 54
2107392  pz 52
6350400  pz 57
6531840  pz 63
7776000  pz 55 30045390491869460 [4, 5, 9, 10, 6, 10, 4, 9, 2]  pz 49 409118905032525    [5, 9, 10, 10, 6, 6, 8, 6]
7776000  pz 49 409118905032525    [5, 9, 10, 10, 6, 6, 8, 6]      pz 55 30045390491869460 [4, 5, 9, 10, 6, 10, 4, 9, 2]
9331200  pz 60
10584000 pz 53
18289152 pz 56
22579200 pz 61
41990400 pz 65 30568377312064202855
80015040 pz 62
83607552 pz 59
              pz 64

cobra throw https://ibb.co/qYsbBsV

***

It would be possible, on the one hand, to generate arrays of numbers for a kangaroo in this way ,but not the fact that the kangaroo will be able to quickly work with arrays (probably by the counter step by step it is easier).

and what space to choose and how much it will require ram or space on hdd...

pz 125

4 2, 5 3, 5 2, 9 5, 8 6, 5 1, 1 7, 3 0, 7 9, 3 2, 9 2, 1 8, 2 5, 9 2, 8 9, 7 1, 0 2, 6 4, 3 1
 6    8,   7    14,  14   6,   8    3,   16   5,   11   9,   7    11,  17   8,   2    10,   4
   14         21,       20       11,        21        20,       18        25,       12      4
         35                  31,                  41                  43,                14  
                    66                                        84                            14
                                       150                                                  14
                                                                 164                             

6×8×7×14×14×6×8×3×16×5×11×9×7×11×17×8×2×10×4 62922018049228800

6
[(0, 6), (1, 5), (2, 4), (3, 3), (4, 2), (5, 1), (6, 0)] 7
8
[(0, , (1, 7), (2, 6), (3, 5), (4, 4), (5, 3), (6, 2), (7, 1), (8, 0)] 9
7
[(0, 7), (1, 6), (2, 5), (3, 4), (4, 3), (5, 2), (6, 1), (7, 0)] 8
14
[(5, 9), (6, , (7, 7), (8, 6), (9, 5)] 5
14
[(5, 9), (6, , (7, 7), (8, 6), (9, 5)] 5
6
[(0, 6), (1, 5), (2, 4), (3, 3), (4, 2), (5, 1), (6, 0)] 7
8
[(0, , (1, 7), (2, 6), (3, 5), (4, 4), (5, 3), (6, 2), (7, 1), (8, 0)] 9
3
[(0, 3), (1, 2), (2, 1), (3, 0)] 4
16
[(7, 9), (8, , (9, 7)] 3
5
[(0, 5), (1, 4), (2, 3), (3, 2), (4, 1), (5, 0)] 6
11
[(2, 9), (3, , (4, 7), (5, 6), (6, 5), (7, 4), (8, 3), (9, 2)] 8
9
[(0, 9), (1, , (2, 7), (3, 6), (4, 5), (5, 4), (6, 3), (7, 2), (8, 1), (9, 0)] 10
7
[(0, 7), (1, 6), (2, 5), (3, 4), (4, 3), (5, 2), (6, 1), (7, 0)] 8
11
[(2, 9), (3, , (4, 7), (5, 6), (6, 5), (7, 4), (8, 3), (9, 2)] 8
17
[(8, 9), (9, ] 2
8
[(0, , (1, 7), (2, 6), (3, 5), (4, 4), (5, 3), (6, 2), (7, 1), (8, 0)] 9
2
[(0, 2), (1, 1), (2, 0)] 3
10
[(1, 9), (2, , (3, 7), (4, 6), (5, 5), (6, 4), (7, 3), (8, 2), (9, 1)] 9
4
[(0, 4), (1, 3), (2, 2), (3, 1), (4, 0)] 5

7×9×8×5×5×7×9×4×3×6×8×10×8×8×2×9×3×9×5 711082229760000

1
...
711082229760000          <42535295865117307932921825928971026431
...
10000000000000000000

***

one thing about all script python and any script

if it display show message detail like show key or show generate, show random, show runing number

try test until make sure it work 100%

only in this way, do not run several (hundreds) programs at the same time (unless you have 100500 processor threads).

***

example

30568377312064202855

[3, 11, 11, 14, 4, 2, 10, 2, 10, 10]
81312000
[4, 8, 8, 5, 5, 3, 9, 3, 9, 9]
41990400

[4, 8, 8, 5, 5, 3, 9, 3, 9, 9] for a fixed this set of all brute-force 75600

and a whole bunch of combinations that can give in multiplications 41990400 (which are easier to generate not to use)

(8, 9, 3, 7, 6, 6, 10, 9, 1, 9) 44089920
(3, 8, 7, 6, 9, 6, 3, 9, 10, 3) 44089920
(3, 8, 3, 9, 5, 6, 9, 7, 6, 6) 44089920
(10, 3, 3, 3, 8, 7, 9, 4, 9, 9) 44089920
(7, 6, 9, 4, 9, 9, 3, 2, 10, 6) 44089920
(6, 6, 9, 4, 3, 9, 3, 6, 7, 10) 44089920
(6, 1, 6, 10, 7, 4, 9, 9, 6, 9) 44089920
(9, 3, 6, 6, 4, 7, 9, 5, 6, 6) 44089920
(3, 3, 4, 9, 9, 5, 8, 6, 9, 7) 44089920
(3, 4, 9, 7, 9, 8, 9, 5, 6, 3) 44089920
(3, 8, 9, 3, 6, 7, 10, 3, 6, 9) 44089920
(5, 2, 6, 9, 7, 3, 9, 9, 6, 44089920
(2, 2, 10, 9, 6, 9, 9, 9, 7, 4) 44089920
(9, 9, 5, 9, 8, 4, 7, 3, 6, 3) 44089920
(9, 5, 9, 9, 4, 7, 4, 9, 2, 6) 44089920
(9, 9, 8, 3, 10, 7, 6, 3, 2, 9) 44089920
(9, 6, 3, 9, 3, 7, 6, 8, 6, 5) 44089920
(9, 7, 2, 8, 9, 1, 6, 10, 9, 9) 44089920
(10, 7, 8, 6, 6, 3, 9, 9, 3, 3) 44089920
(10, 2, 7, 4, 9, 9, 9, 3, 4, 9) 44089920
(6, 6, 9, 2, 6, 5, 4, 9, 7, 9) 44089920
(6, 9, 8, 7, 3, 9, 3, 9, 10, 2) 44089920
(9, 8, 9, 6, 3, 7, 1, 10, 9, 6) 44089920
(6, 7, 6, 4, 10, 9, 9, 6, 1, 9) 44089920
(7, 6, 6, 3, 5, 9, 8, 9, 9, 2) 44089920
(6, 6, 5, 7, 9, 4, 6, 9, 3, 6) 44089920
(2, 9, 5, 9, 9, 7, 6, 9, 8, 2) 44089920
(9, 6, 4, 10, 6, 9, 7, 3, 2, 9) 44089920
(3, 2, 6, 10, 7, 9, 9, 6, 4, 9) 44089920
(3, 4, 9, 5, 8, 9, 7, 6, 3, 9) 44089920
(9, 7, 6, 4, 6, 9, 9, 3, 2, 10) 44089920
(5, 3, 8, 9, 9, 8, 1, 9, 9, 7) 44089920
(4, 6, 9, 4, 7, 9, 9, 10, 9, 1) 44089920
(9, 2, 10, 9, 3, 9, 6, 7, 6, 4) 44089920
(9, 9, 3, 8, 7, 5, 3, 9, 8, 3) 44089920
(9, 8, 9, 4, 5, 6, 9, 7, 3, 3) 44089920
(9, 2, 7, 9, 9, 9, 4, 2, 10, 6) 44089920
(9, 3, 4, 6, 9, 8, 5, 3, 9, 7) 44089920
(7, 6, 6, 10, 4, 9, 6, 1, 9, 9) 44089920
(9, 7, 2, 10, 6, 9, 3, 6, 6, 6) 44089920
(2, 2, 9, 9, 10, 8, 3, 7, 9, 9) 44089920
(3, 7, 4, 2, 9, 6, 10, 6, 9, 9) 44089920
(3, 7, 8, 3, 10, 4, 9, 3, 9, 9) 44089920
(6, 9, 6, 1, 8, 10, 9, 7, 3, 9) 44089920
(1, 5, 9, 8, 9, 9, 7, 9, 4, 6) 44089920
(2, 10, 9, 3, 7, 6, 3, 8, 9, 9) 44089920
(8, 9, 7, 2, 6, 9, 3, 5, 6, 9) 44089920
(8, 10, 7, 9, 2, 9, 6, 9, 9, 1) 44089920
(5, 9, 7, 4, 6, 3, 8, 3, 9, 9) 44089920
(9, 6, 7, 6, 6, 6, 10, 2, 9, 3) 44089920
(6, 9, 1, 7, 6, 6, 9, 4, 10, 9) 44089920
(9, 6, 2, 6, 6, 5, 9, 7, 6, 6) 44089920

[/size]
...

[WanderingPhilospher]

It would be possible, on the one hand, to generate arrays of numbers for a kangaroo in this way ,but not the fact that the kangaroo will be able to quickly work with arrays (probably by the counter step by step it is easier).

and what space to choose and how much it will require ram or space on hdd...

If only I had an inkling to what you are trying to do...I can run kangaroo step by step; jump any number, 1 to to 2^256 with no impact on RAM. But I am lost when it comes to all your numbers. I know they seem common to you, but not the common person.

[Andzhig]

It would be possible, on the one hand, to generate arrays of numbers for a kangaroo in this way ,but not the fact that the kangaroo will be able to quickly work with arrays (probably by the counter step by step it is easier).

and what space to choose and how much it will require ram or space on hdd...

If only I had an inkling to what you are trying to do...I can run kangaroo step by step; jump any number, 1 to to 2^256 with no impact on RAM. But I am lost when it comes to all your numbers. I know they seem common to you, but not the common person.

I myself am in the process of thinking, throwing ideas on, maybe someone will add something ...

For example pz 30568377312064202855

we decomposed it (number composition https://en.wikipedia.org/wiki/Composition_(combinatorics))

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]      

their multiplication, the number of steps

[3x11x11x14x4x2x10x2x10x10]         81312000                 [4x8x8x5x5x3x9x3x9x9]       41990400


a1= [(0, 3), (3, 0), (1, 2), (2, 1)]
a2= [(0, 11), (11, 0), (1, 10), (2, 9), (3, , (4, 7), (5, 6), (6, 5), (7, 4), (8, 3), (9, 2), (10, 1)]
a3= [(0, 11), (11, 0), (1, 10), (2, 9), (3, , (4, 7), (5, 6), (6, 5), (7, 4), (8, 3), (9, 2), (10, 1)]
a4= [(0, 14), (14, 0), (1, 13), (2, 12), (3, 11), (4, 10), (5, 9), (6, , (7, 7), (8, 6), (9, 5), (10, 4), (11, 3), (12, 2), (13, 1)]
a5= [(0, 4), (4, 0), (1, 3), (2, 2), (3, 1)]
a6= [(0, 2), (2, 0), (1, 1)]
a7= [(0, 10), (10, 0), (1, 9), (2, , (3, 7), (4, 6), (5, 5), (6, 4), (7, 3), (8, 2), (9, 1)]
a8= [(0, 2), (2, 0), (1, 1)]
a9= [(0, 10), (10, 0), (1, 9), (2, 8), (3, 7), (4, 6), (5, 5), (6, 4), (7, 3), (8, 2), (9, 1)]
a10=[(0, 10), (10, 0), (1, 9), (2, , (3, 7), (4, 6), (5, 5), (6, 4), (7, 3), (8, 2), (9, 1)]

after discarding the excess (there may be problems with converting back, but this is not important yet)

a1= [(0, 3), (3, 0), (1, 2), (2, 1)]
a2= [(2, 9), (3, , (4, 7), (5, 6), (6, 5), (7, 4), (8, 3), (9, 2)]
a3= [(2, 9), (3, , (4, 7), (5, 6), (6, 5), (7, 4), (8, 3), (9, 2)]
a4= [(5, 9), (6, , (7, 7), (8, 6), (9, 5)]
a5= [(0, 4), (4, 0), (1, 3), (2, 2), (3, 1)]
a6= [(0, 2), (2, 0), (1, 1)]
a7= [(1, 9), (2, , (3, 7), (4, 6), (5, 5), (6, 4), (7, 3), (8, 2), (9, 1)]
a8= [(0, 2), (2, 0), (1, 1)]
a9= [(1, 9), (2, , (3, 7), (4, 6), (5, 5), (6, 4), (7, 3), (8, 2), (9, 1)]
a10=[(1, 9), (2, , (3, 7), (4, 6), (5, 5), (6, 4), (7, 3), (8, 2), (9, 1)]

running them sequentially step by step we got 41990400 steps (20 lenght numbers).

but we, as if, do not know what we are looking for specifically

so we start to mix them up and go through a new one, now the number you are looking for will start with 29, 38, 47, 56, 65, 74 etc...

a1= [(2, 9), (3, , (4, 7), (5, 6), (6, 5), (7, 4), (8, 3), (9, 2)] [(0, 3), (3, 0), (1, 2), (2, 1)]
a2= [(0, 3), (3, 0), (1, 2), (2, 1)]
a3= [(2, 9), (3, , (4, 7), (5, 6), (6, 5), (7, 4), (8, 3), (9, 2)]
a4= [(5, 9), (6, , (7, 7), (8, 6), (9, 5)]
a5= [(0, 4), (4, 0), (1, 3), (2, 2), (3, 1)]
a6= [(0, 2), (2, 0), (1, 1)]
a7= [(1, 9), (2, , (3, 7), (4, 6), (5, 5), (6, 4), (7, 3), (8, 2), (9, 1)]
a8= [(0, 2), (2, 0), (1, 1)]
a9= [(1, 9), (2, , (3, 7), (4, 6), (5, 5), (6, 4), (7, 3), (8, 2), (9, 1)]
a10=[(1, 9), (2, , (3, 7), (4, 6), (5, 5), (6, 4), (7, 3), (8, 2), (9, 1)]

and so here

[3, 11, 11, 14, 4, 2, 10, 2, 10, 10]81312000  [4, 8, 8, 5, 5, 3, 9, 3, 9, 9]  41990400 x (75600 fixed)  3174474240000 numbers.

For other sets of equal 41990400 (which can be a wagon and a cart with manure  )

[5, 10, 9, 4, 3, 6, 9, 3, 6, 8] 41990400 x (453600 konm fixed)  19046845440000  numbers
[6, 10, 8, 2, 9, 6, 3, 6, 5, 9] 41990400 x (302400 konm fixed)  12697896960000  numbers

these numbers need to run through the kangaroo, but how much space will they take in memory or hdd...

Therefore, we need to consider how it can be optimized.

for example we can restrict selection, so that we will create arrays only that start with the numbers we need

a1= [(0, 3), (3, 0), (1, 2), (2, 1)]                                        <= here we only need (3, 0)
a2= [(2, 9), (3, , (4, 7), (5, 6), (6, 5), (7, 4), (8, 3), (9, 2)]  <= if it comes first (to a1 place) we don't need (8, 3), (9, 2) etc...
a3= [(2, 9), (3, , (4, 7), (5, 6), (6, 5), (7, 4), (8, 3), (9, 2)]
a4= [(5, 9), (6, , (7, 7), (8, 6), (9, 5)]
a5= [(0, 4), (4, 0), (1, 3), (2, 2), (3, 1)]
a6= [(0, 2), (2, 0), (1, 1)]
a7= [(1, 9), (2, , (3, 7), (4, 6), (5, 5), (6, 4), (7, 3), (8, 2), (9, 1)]
a8= [(0, 2), (2, 0), (1, 1)]
a9= [(1, 9), (2, , (3, 7), (4, 6), (5, 5), (6, 4), (7, 3), (8, 2), (9, 1)]
a10=[(1, 9), (2, , (3, 7), (4, 6), (5, 5), (6, 4), (7, 3), (8, 2), (9, 1)]

in other words, we need to travel distances to check

979776   pz 58
1036800  pz 50
1128960
1166400  
1270080  pz 51
1658880  pz 54
2107392  pz 52
6350400  pz 57
6531840  pz 63
7776000  pz 55 30045390491869460 [4, 5, 9, 10, 6, 10, 4, 9, 2]  pz 49 409118905032525    [5, 9, 10, 10, 6, 6, 8, 6]
7776000  pz 49 409118905032525    [5, 9, 10, 10, 6, 6, 8, 6]      pz 55 30045390491869460 [4, 5, 9, 10, 6, 10, 4, 9, 2]
9331200  pz 60
10584000 pz 53
18289152 pz 56
22579200 pz 61
41990400 pz 65 30568377312064202855
80015040 pz 62
83607552 pz 59

from
10000000
to
99999999
(or 150000000)

or some mathematical manipulation to highlight more explicit places for search...

***

using an example from 4

54538862 54 53 88 62

[9, 8, 16, 8] 9216       
[10, 9, 3, 9] 2430

10 <> 9
[(0, 9), (1, , (2, 7), (3, 6), (4, 5), (5, 4), (6, 3), (7, 2), (8, 1), (9, 0)]

9 <> 8
[(0, , (1, 7), (2, 6), (3, 5), (4, 4), (5, 3), (6, 2), (7, 1), (8, 0)]

3 <> 16
[(7, 9), (8, , (9, 7)]

9 <> 8
[(0, , (1, 7), (2, 6), (3, 5), (4, 4), (5, 3), (6, 2), (7, 1), (8, 0)]



       1        2        3        4        5       6         7         8         9        10

0   [(0, 0)                                                                                          1
1   [(1, 0), (0, 1)]                                                                               2
2   [(2, 0), (1, 1), (0, 2)]                                                                     3
3   [(3, 0), (2, 1), (1, 2), (0, 3)]                                                            4
4   [(4, 0), (3, 1), (2, 2), (1, 3), (0, 4)]                                                  5
5   [(5, 0), (4, 1), (3, 2), (2, 3), (1, 4), (0, 5)]                                         6
6   [(6, 0), (5, 1), (4, 2), (3, 3), (2, 4), (1, 5), (0, 6)]                               7
7   [(7, 0), (6, 1), (5, 2), (4, 3), (3, 4), (2, 5), (1, 6), (0, 7)]                      8
8   [(8, 0), (7, 1), (6, 2), (5, 3), (4, 4), (3, 5), (2, 6), (1, 7), (0, ]            9
9   [(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)]  10
10  [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)]           9
11  [(9, 2), (8, 3), (7, 4), (6, 5), (5, 6), (4, 7), (3, , (2, 9)]                     8
12  [(9, 3), (8, 4), (7, 5), (6, 6), (5, 7), (4, , (3, 9)]                               7
13  [(9, 4), (8, 5), (7, 6), (6, 7), (5, , (4, 9)]                                        6
14  [(9, 5), (8, 6), (7, 7), (6, , (5, 9)]                                                  5
15  [(9, 6), (8, 7), (7, , (6, 9)]                                                           4
16  [(9, 7), (8, , (7, 9)]                                                                     3
17  [(9, , (8, 9)]                                                                               2
18  [(9, 9)]                                                                                        1



wrong find looks like that (check that the first line contains (5, 4))

18×18×18×18 = 104976

num                                           elem count

2   [(2, 0), (1, 1), (0, 2)]   3
9   [(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)]   10
10   [(10, 0), (9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9), (0, 10)]   11
10   [(10, 0), (9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9), (0, 10)]   11

***
cut off set (18, 0), (0, 18), (17, 1), (1, 17)... , 10×10×10×10 = 10000 (from 0 to 10) combination

elem count

3   [(2, 0), (1, 1), (0, 2)]
10   [(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)]
9   [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)]
9   [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)]

from 0 to 10 combination 3 10 9 9 = 2430 all steps

(3, 10, 9, 9) 2430
***

([(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)], [(2, 0), (1, 1), (0, 2)], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)])
([(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)], [(2, 0), (1, 1), (0, 2)], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)])
([(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)], [(2, 0), (1, 1), (0, 2)], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)])
([(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)], [(2, 0), (1, 1), (0, 2)])
([(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)], [(2, 0), (1, 1), (0, 2)], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)])
([(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)], [(2, 0), (1, 1), (0, 2)])

then we took 3 which we don't need

2   [(2, 0), (1, 1), (0, 2)]                                                                   3



what we need



18×18×18×18 = 104976

num                                           elem count

8   [(8, 0), (7, 1), (6, 2), (5, 3), (4, 4), (3, 5), (2, 6), (1, 7), (0, ]   9
16   [(16, 0), (15, 1), (14, 2), (13, 3), (12, 4), (11, 5), (10, 6), (9, 7), (8, , (7, 9), (6, 10), (5, 11), (4, 12), (3, 13), (2, 14), (1, 15), (0, 16)]   17
9   [(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)]   10
10   [(10, 0), (9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9), (0, 10)]   11

***
cut off set (18, 0), (0, 18), (17, 1), (1, 17)..., 10×10×10×10 = 10000 (from 0 to 10) combination

elem count

9   [(8, 0), (7, 1), (6, 2), (5, 3), (4, 4), (3, 5), (2, 6), (1, 7), (0, ]
3   [(9, 7), (8, , (7, 9)]
10   [(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)]
9   [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)]

from 0 to 10 combination 9 3 10 9 = 2430 all steps

(9, 3, 10, 9) 2430
***

([(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)], [(8, 0), (7, 1), (6, 2), (5, 3), (4, 4), (3, 5), (2, 6), (1, 7), (0, ], [(9, 7), (8, , (7, 9)], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)])
([(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)], [(8, 0), (7, 1), (6, 2), (5, 3), (4, 4), (3, 5), (2, 6), (1, 7), (0, ], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)], [(9, 7), (8, , (7, 9)])
([(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)], [(9, 7), (8, , (7, 9)], [(8, 0), (7, 1), (6, 2), (5, 3), (4, 4), (3, 5), (2, 6), (1, 7), (0, ], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)])
([(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)], [(9, 7), (8, , (7, 9)], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)], [(8, 0), (7, 1), (6, 2), (5, 3), (4, 4), (3, 5), (2, 6), (1, 7), (0, ])
([(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)], [(8, 0), (7, 1), (6, 2), (5, 3), (4, 4), (3, 5), (2, 6), (1, 7), (0, ], [(9, 7), (8, , (7, 9)])
([(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, , (0, 9)], [(9, 1), (8, 2), (7, 3), (6, 4), (5, 5), (4, 6), (3, 7), (2, , (1, 9)], [(9, 7), (8, , (7, 9)], [(8, 0), (7, 1), (6, 2), (5, 3), (4, 4), (3, 5), (2, 6), (1, 7), (0, ])


16  [(9, 7), (8, , (7, 9)]                                                                     3

[David Dagher]

Hello,
I'm a total newbie for the bitcoin puzzle and bitcoin in general, but I have some experience in Python.
I wrote the following codes depending on my knowledge in Python.
first of all, I'm running these codes on 2 laptops [core i3 & core i5], but it runs extremely slow on both of them ~333keys/s
I tried to use Bitcrack but I couldn't manage to get it run on Kali Linux "I have just installed it couple of days ago so I'm not experienced with it"
I tried https://privatekeys.pw/scanner "which by the way shows that I'm generating ~15,000 Keys/s on both laptops!"
I tried to find a faster bitcoin library for Python but I couldn't manage to make it work like bitcoin standard library
anyway, here are my codes:
CODE #1

Code:

import random
from bitcoin import *
while True:
    x = random.randint(2**63, 2**64)
    y = privtoaddr(x)
    if y == '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN':
        print(hex(i))
        break

CODE #2

Code:

from bitcoin import privtoaddr
i = 18446744073709551616
while i >= 9223372036854775808:
    i -= 1
    y = privtoaddr(i)
    if y == '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN':
        print(hex(i))
        break

I try to play around a lot with CODE #2, but still getting the same results.
Any suggestions to make it run faster or recommending faster tools are appreciated.
Thanks in advance.

[David Dagher]

DAVID DAGHER YOU CAN MSG ME DIRECTLY

Why?

[hr7864]

bro you know how this series genrated and what logic used behind this formula.
                         

                                          1
                                        11
                                      111
                                    1000
                                  10101
                                110001
                              1001100
                            11100000