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

Andzhig

jr. member

Activity: 184

Merit: 3

next observation.

we take the seed so that all permutations of 30 ((15> 1, 15> 0) 111111111111111000000000000000) fit into it, let's say this is 2^30 (1073741824 this number can also control the final result)

and we begin to divide it by 1 by 2 by 3, etc. and use these numbers to initiate a permutation 30.

Quote

from math import sqrt
import random
from bit import Key
#from bit.format import bytes_to_wif
#from PyRandLib import *
#rand = FastRand63()
#random.seed(rand())
#mp.dps = 100; mp.pretty = True
import time

#n = 16
lst = ["1111000011110111","1111110000001011","0001110001111100","0000000011111111"]#["{:0{}b}".format(x, n) for x in range(2**n)]

for FFFF in lst:

   ass = 1073741824

   O=1
   while O<=1000:


   bbb=ass//O
   count = -1
   I=0
   while I <= 1073741824:
   #print("2^30 //",O,"= seed",I)

   count += 1

   random.seed(I)
   s = "111111111111111000000000000000" #111111111111111111111111111111111111100000000000
   sv = ''.join(random.sample(s,len(s)))
   #ssv = "1"
   #sssv = ssv+sv
   V1 = sv#int(sssv)
   XXX2 = V1




   TTT=[]


   Nn1=FFFF #["0110011001011001"] #1011000010110010




   R=XXX2

   random.seed(R)




   Nn = "0","1" #"0","1"

   RRR = [] #func()

   for RR in range(16):
   DDD = random.choice(Nn)
   RRR.append(DDD)

   d = ''.join(RRR)
   dd = d#[0:20]
   kkk = []
   kkk2 = []
   kkk.append(dd)
   kkk2.append(Nn1)
   #print("2^30 //",O,"*",count,"= seed",I,"> seed ",XXX2,"16 bit >",dd)
   #print(Nn1,kkk)
   if kkk == kkk2:



   print("2^30 //",O,"*",count,"= seed",I,"> seed ",XXX2,"16 bit >",dd,"find...........................................",Nn1,lst.index(Nn1)) #int(dd,2)

   break

   I=I+bbb


   O=O+1

2^30 // 210 * 89 = seed 455061984 > seed 001110001010101101011000110101 16 bit > 1111000011110111 find........................................... 1111000011110111 0
2^30 // 420 * 178 = seed 455061984 > seed 001110001010101101011000110101 16 bit > 1111000011110111 find........................................... 1111000011110111 0
2^30 // 421 * 320 = seed 816145600 > seed 100001010011000010111011101101 16 bit > 1111000011110111 find........................................... 1111000011110111 0
2^30 // 525 * 473 = seed 967390006 > seed 110100001011011110011101100000 16 bit > 1111000011110111 find........................................... 1111000011110111 0
2^30 // 630 * 267 = seed 455061984 > seed 001110001010101101011000110101 16 bit > 1111000011110111 find........................................... 1111000011110111 0
2^30 // 840 * 356 = seed 455061984 > seed 001110001010101101011000110101 16 bit > 1111000011110111 find........................................... 1111000011110111 0
2^30 // 982 * 177 = seed 193535871 > seed 010111011100100010011011110000 16 bit > 1111000011110111 find........................................... 1111000011110111 0
2^30 // 426 * 169 = seed 425967880 > seed 001011000111101101000001011011 16 bit > 1111110000001011 find........................................... 1111110000001011 1
2^30 // 706 * 383 = seed 582497040 > seed 100011011001110011000111010001 16 bit > 1111110000001011 find........................................... 1111110000001011 1
2^30 // 726 * 49 = seed 72470167 > seed 010010011111110101000100111000 16 bit > 1111110000001011 find........................................... 1111110000001011 1
2^30 // 806 * 515 = seed 686075275 > seed 100000011001101011100110010111 16 bit > 1111110000001011 find........................................... 1111110000001011 1
2^30 // 850 * 44 = seed 55581900 > seed 011000001111011001001100011011 16 bit > 1111110000001011 find........................................... 1111110000001011 1
2^30 // 852 * 338 = seed 425967880 > seed 001011000111101101000001011011 16 bit > 1111110000001011 find........................................... 1111110000001011 1
2^30 // 858 * 481 = seed 601946007 > seed 000100110110010110110010011101 16 bit > 1111110000001011 find........................................... 1111110000001011 1
2^30 // 967 * 272 = seed 302024448 > seed 000101110001111010110100101010 16 bit > 1111110000001011 find........................................... 1111110000001011 1
2^30 // 999 * 427 = seed 458946432 > seed 000010111010111010011011101000 16 bit > 1111110000001011 find........................................... 1111110000001011 1
2^30 // 671 * 51 = seed 81610761 > seed 110010001100001110100110111100 16 bit > 0001110001111100 find........................................... 0001110001111100 2
2^30 // 727 * 98 = seed 144740904 > seed 010101010001100101010111110001 16 bit > 0001110001111100 find........................................... 0001110001111100 2
2^30 // 893 * 861 = seed 1035264678 > seed 110110100000100100111011011001 16 bit > 0001110001111100 find........................................... 0001110001111100 2
2^30 // 989 * 488 = seed 529813792 > seed 101010001000111011000101110110 16 bit > 0001110001111100 find........................................... 0001110001111100 2
2^30 // 181 * 10 = seed 59322750 > seed 110100001100101011011101001001 16 bit > 0000000011111111 find........................................... 0000000011111111 3
2^30 // 439 * 120 = seed 293505720 > seed 011111100010111000110111000000 16 bit > 0000000011111111 find........................................... 0000000011111111 3
2^30 // 500 * 366 = seed 785978778 > seed 001010100111011101001100000111 16 bit > 0000000011111111 find........................................... 0000000011111111 3
2^30 // 543 * 30 = seed 59322750 > seed 110100001100101011011101001001 16 bit > 0000000011111111 find........................................... 0000000011111111 3
2^30 // 703 * 334 = seed 510141914 > seed 110011010111000110111001000100 16 bit > 0000000011111111 find........................................... 0000000011111111 3
2^30 // 727 * 363 = seed 536132124 > seed 111110001010001011100100101100 16 bit > 0000000011111111 find........................................... 0000000011111111 3
2^30 // 816 * 373 = seed 490815780 > seed 110011011101100001011001000011 16 bit > 0000000011111111 find........................................... 0000000011111111 3
2^30 // 844 * 218 = seed 277340690 > seed 011110110010000101101011010001 16 bit > 0000000011111111 find........................................... 0000000011111111 3
2^30 // 865 * 234 = seed 290468880 > seed 100011000010101000011011101111 16 bit > 0000000011111111 find........................................... 0000000011111111 3
2^30 // 905 * 50 = seed 59322750 > seed 110100001100101011011101001001 16 bit > 0000000011111111 find........................................... 0000000011111111 3
2^30 // 966 * 12 = seed 13338396 > seed 110111000010110100000110010111 16 bit > 0000000011111111 find........................................... 0000000011111111 3

now we have combinations the length that we ourselves determine, in the example above, the length 1000 can be reduced to 500 (but there may be misses).

2^30 // 210 * 89 = seed 455061984 > seed 001110001010101101011000110101 16 bit > 1111000011110111 find........................................... 1111000011110111 0
2^30 // 426 * 169 = seed 425967880 > seed 001011000111101101000001011011 16 bit > 1111110000001011 find........................................... 1111110000001011 1
2^30 // 671 * 51 = seed 81610761 > seed 110010001100001110100110111100 16 bit > 0001110001111100 find........................................... 0001110001111100 2
2^30 // 181 * 10 = seed 59322750 > seed 110100001100101011011101001001 16 bit > 0000000011111111 find........................................... 0000000011111111 3

210 x 426 x 671 x 181 = 10865006460 (89 x 169 x 51 x 10 = 7670910)

can also search only in 9**, 8**, 7**, etc (100 x 100 x 100 x 100)

2^30 // 982 * 177 = seed 193535871 > seed 010111011100100010011011110000 16 bit > 1111000011110111 find........................................... 1111000011110111 0
2^30 // 967 * 272 = seed 302024448 > seed 000101110001111010110100101010 16 bit > 1111110000001011 find........................................... 1111110000001011 1
2^30 // 999 * 427 = seed 458946432 > seed 000010111010111010011011101000 16 bit > 1111110000001011 find........................................... 1111110000001011 1
2^30 // 989 * 488 = seed 529813792 > seed 101010001000111011000101110110 16 bit > 0001110001111100 find........................................... 0001110001111100 2
2^30 // 905 * 50 = seed 59322750 > seed 110100001100101011011101001001 16 bit > 0000000011111111 find........................................... 0000000011111111 3
2^30 // 966 * 12 = seed 13338396 > seed 110111000010110100000110010111 16 bit > 0000000011111111 find........................................... 0000000011111111 3

or example all (4 to 16) at 500

Quote

from math import sqrt
import random
from bit import Key
#from bit.format import bytes_to_wif
#from PyRandLib import *
#rand = FastRand63()
#random.seed(rand())
#mp.dps = 100; mp.pretty = True
import time

n = 16
lst = ["{:0{}b}".format(x, n) for x in range(2**n)]

for FFFF in lst:

   ass = 1073741824

   O=1
   while O<=500:


   bbb=ass//O
   count = -1
   I=0
   while I <= 1073741824:
   #print("2^30 //",O,"= seed",I)

   count += 1

   random.seed(I)
   s = "111111111111111000000000000000" #111111111111111111111111111111111111100000000000
   sv = ''.join(random.sample(s,len(s)))
   #ssv = "1"
   #sssv = ssv+sv
   V1 = sv#int(sssv)
   XXX2 = V1




   TTT=[]


   Nn1=FFFF #["0110011001011001"] #1011000010110010




   R=XXX2

   random.seed(R)




   Nn = "0","1" #"0","1"

   RRR = [] #func()

   for RR in range(16):
   DDD = random.choice(Nn)
   RRR.append(DDD)

   d = ''.join(RRR)
   dd = d#[0:20]
   kkk = []
   kkk2 = []
   kkk.append(dd)
   kkk2.append(Nn1)
   #print("2^30 //",O,"*",count,"= seed",I,"> seed ",XXX2,"16 bit >",dd)
   #print(Nn1,kkk)
   if kkk == kkk2:



   print("2^30 //",O,"*",count,"= seed",I,"> seed ",XXX2,"16 bit >",dd,"find...........................................",Nn1,lst.index(Nn1)) #int(dd,2)

   break

   I=I+bbb


   O=O+1

***

this variation is applicable to the whole puzzle at once, forum inserts spaces, they should not be s = "1111111111111111111111111111111111111111111111111111111111111111111111111111111 1111111111100000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000" # initiation (160 "bit" "0","1") seed len 180

Quote

import random
from bit import Key

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"]

ass = 1532495540865888858358347027150309183618739122183602176

O=1
while O<=1000000:

   bbb=ass//O

   I=0
   while I <= 1532495540865888858358347027150309183618739122183602176:


   random.seed(I) # seed initiation () random or (X)

   #1111111111111111111111111111111111111111111111111111111111111111111111
   #string = "HuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhH uhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHu hHuhHuhHuh??" # 70 "11?HuhHuhHuhHuhHuh?1?HuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuh?" 64 "11?HuhHuhHuhHuhHuh?0?HuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuhHuh?"
   #for i in range(0,len(string)):
   #string = string.replace("?",random.choice(['0','1']),1)
   #print(string,len(string))

   s = "1111111111111111111111111111111111111111111111111111111111111111111111111111111 1111111111100000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000" # initiation (160 "bit" "0","1") seed len 180
   sv = ''.join(random.sample(s,len(s)))


   random.seed(sv) #string

   Nn = "0","1" #"0","1"
   RRR = []

   for RR in range(160): # pz bit range
   DDD = random.choice(Nn)
   RRR.append(DDD)

   d = ''.join(RRR)
   #print(d,len(d))
   ii = 64
   while ii <= 160:

   dd = (d)[0:ii]

   b = int(dd,2)
   if b >= 9223372036854775807:
   key = Key.from_int(b)
   addr = key.address
   if addr in list:
   print ("found!!!",b,addr)
   s1 = str(b)
   s2 = addr
   f=open("a.txt","a")
   f.write(s1)
   f.write(s2)
   f.close()
   pass
   else:
   #print (X,"seed mask len",len(string),string,",","64 bit pz",dd,",",b,addr)
   print (O,b,addr) #print (X,sv,len(sv),dd,len(dd),b,addr)

   ii=ii+1

   I=I+bbb

   O=O+1

***

going back to the previous message "18-12, 48620 x (924 x 924 x 924 x 924 = 728933458176) = 35440744736517120" few observations

if we take any part of 30 and watch there 12 (111111000000) these 1000^4 "collisions" are distributed there

4:10 - 22:28 1-5 5-1

000010 111101 000000001011010010110111110111 0000000000000000
100000 111110 000010000000001111111011111011 0000000000000000
100000 111110 000010000011110101101011111010 1111111111111111
000010 011111 000100001010100110010101111111 1111111100000000
001000 111101 000100100010110100011111110110 1111111111111111
010000 111011 000101000010101000111111101110 1111111100000000
100000 111011 000110000001100111011111101100 1111111111111111
000001 111101 001000000110101011110011110101 0000000011111111
000010 111011 001000001001100011111011101110 1111111111111111
010000 101111 001001000010010101101110111110 0000000011111111
100000 011111 001010000011001001111101111100 0000000000000000
000010 011111 001100001010111010110001111100 0000000011111111
000010 111110 010000001000001111111011111001 1111111100000000
000010 111101 010000001000101101001111110111 0000000011111111
100000 011111 010010000001111001101001111110 0000000000000000
100000 111101 010010000011011100100111110110 1111111100000000
000010 111101 010100001001111000110011110101 0000000011111111
000100 111011 010100010000110101001111101110 0000000000000000
010000 110111 010101000000101111000111011110 1111111100000000
010000 011111 010101000011000111011001111100 1111111100000000
010000 101111 010101000011011000111010111100 1111111111111111
000010 111101 011000001011100011010111110100 0000000011111111
001000 111011 011000100000100101110111101110 1111111100000000
001000 011111 011000100000111101110001111100 1111111100000000
000010 111101 011100001000110011001111110100 1111111111111111
001000 111110 011100100011110010000011111001 0000000000000000
010000 111110 011101000000110001001011111011 1111111100000000
100000 111101 100010000001011100011011110111 0000000000000000
001000 111101 100100100001100010110111110101 1111111111111111
000001 011111 101000000100001111110001111101 1111111100000000
000001 110111 101000000100100110100111011111 0000000000000000
000001 101111 101000000100101100101110111101 1111111111111111
001000 110111 101000100001010011110111011100 0000000000000000
001000 011111 101000100011011010001001111101 1111111111111111
100000 110111 101010000010011011001111011100 0000000011111111
100000 111110 101010000011001010011111111000 0000000011111111
000001 011111 101100000100011000011001111111 0000000000000000
001000 110111 101100100011001000100111011110 0000000000000000
100000 110111 101110000010100110010011011110 1111111111111111
000100 110111 110000010001000111010111011110 0000000011111111
000100 111101 110100010000011100100111110101 1111111111111111
001000 101111 110100100000111001000110111110 0000000011111111
010000 101111 110101000011000010011110111100 0000000000000000
100000 111011 110110000010100100011011101110 1111111111111111
000010 111101 111000001001001001101011110110 1111111111111111
000010 101111 111000001011000100001110111101 1111111100000000
000010 111101 111000001011010001110011110100 1111111100000000
000100 111101 111000010011110101000011110100 0000000011111111
010000 101111 111001000000110100100010111111 0000000011111111
010000 111011 111001000010101011000011101101 1111111100000000
000001 111011 111100000110011000110011101100 1111111111111111
000010 111101 111100001010110100010011110100 1111111100000000
001000 111011 111100100000000110110011101110 1111111100000000
001000 101111 111100100000010010110010111101 1111111111111111
100000 111110 111110000010010000010111111001 0000000000000000

0-6-24-30 3-3 3-3

000111 010101 000111000101111100000111010101 0000000000000000
000111 100011 000111000111010110101100100011 1111111111111111
000111 001101 000111000111110000011101001101 0000000011111111
000111 010101 000111001000100101101111010101 1111111100000000
000111 010110 000111001110001111110000010110 0000000000000000
000111 010110 000111001111100000011110010110 1111111100000000
000111 101100 000111010001010110111010101100 0000000000000000
000111 011100 000111010100001111110010011100 1111111111111111
000111 011001 000111010110000111000111011001 0000000000000000
000111 100101 000111011000011011010101100101 1111111100000000
000111 011100 000111011001101011110000011100 1111111111111111
000111 010101 000111011011010000110110010101 1111111111111111
000111 101010 000111100100111010000111101010 0000000011111111
000111 101010 000111101100010100101011101010 1111111100000000
000111 011010 000111110000001110010111011010 1111111111111111
000111 001110 000111110010000010011111001110 1111111111111111
000111 011100 000111110011001101100001011100 0000000011111111
000111 011010 000111111000101010101001011010 0000000011111111
000111 001011 000111111010010000011011001011 1111111111111111
000111 000111 000111111011010001000110000111 1111111100000000
000111 101001 000111111110010010001001101001 0000000011111111
001011 011001 001011000011111010010110011001 1111111100000000
001011 001011 001011000110011110010101001011 1111111111111111
001011 101100 001011001000001111010111101100 0000000011111111
001011 001101 001011001100011000111011001101 1111111111111111
001011 101010 001011001100011101011100101010 0000000000000000
001011 100110 001011001100110100101011100110 0000000011111111
001011 111000 001011001101100101100110111000 1111111100000000
...
111000 011010 111000010111011010010001011010 1111111100000000
111000 101100 111000010111101100001010101100 0000000000000000
111000 000111 111000011001100001110101000111 1111111111111111
111000 001101 111000100011010110101010001101 1111111111111111
111000 011001 111000100100011001111001011001 0000000011111111
111000 110001 111000100101011001000111110001 0000000011111111
111000 111000 111000100111111010100000111000 0000000000000000
111000 110100 111000110000011001110101110100 0000000011111111
111000 101010 111000110000101110011010101010 1111111100000000
111000 100101 111000110001101110000011100101 1111111100000000
111000 101100 111000110101010110001100101100 1111111100000000
111000 010011 111000110111110001100000010011 1111111100000000
111000 101100 111000111000011010010011101100 1111111100000000
111000 110001 111000111001000000101111110001 0000000000000000
111000 010110 111000111001111000000011010110 1111111100000000
111000 101100 111000111011000100011010101100 0000000011111111
111000 111000 111000111110001000100110111000 1111111111111111
111000 011010 111000111111100000101000011010 0000000011111111

7:19 6-6

001000110111 000000000100011011111111110011 0000000000000000
010110100101 000000001011010010110111110111 0000000000000000
011000101110 000000001100010111011111110110 1111111100000000
010001111001 000000101000111100110101110111 1111111100000000
101110100001 000000110111010000111101011011 1111111100000000
001100110011 000001000110011001100111110111 1111111111111111
011110001001 000001001111000100101111111001 0000000011111111
100001001111 000001010000100111111011101110 0000000011111111
101001111000 000001010100111100001111110110 1111111100000000
110101101000 000001011010110100010111101011 0000000011111111
000110011011 000001100011001101111000111101 0000000000000000
010001111010 000001101000111101010011101110 1111111111111111
010100001111 000001101010000111101111100101 1111111111111111
...
011000110101 111100101100011010100100110100 1111111111111111
101011000011 111100110101100001100101010001 1111111111111111
111001001010 111100111100100101001100001010 1111111100000000
111010000101 111100111101000010100010110001 0000000011111111
001010101011 111101000101010101100001110010 1111111100000000
010011110010 111101001001111001010100001010 1111111100000000
011001000111 111101001100100011110000011100 1111111100000000
011010010110 111101001101001011001010100001 0000000011111111
011101001001 111101001110100100100001110010 0000000011111111
100011011100 111101010001101110000000101110 0000000000000000
101011001001 111101010101100100100011011000 1111111111111111
101110100100 111101010111010010000101100100 0000000000000000
110001011001 111101011000101100111010010000 0000000011111111
010011101010 111101101001110101001010000001 1111111111111111
010110011001 111101101011001100100010000101 0000000011111111
011001101010 111101101100110101001010000100 0000000011111111
011110000011 111101101111000001101001100000 0000000000000000
100011010101 111101110001101010100100001010 0000000011111111
001011010101 111110000101101010101010010001 0000000011111111
001101110010 111110000110111001011100100000 0000000011111111
011100001110 111110001110000111000100010011 1111111100000000
101110000101 111110010111000010100100110001 0000000000000000
110101100100 111110011010110010001000010011 1111111100000000

it remains to understand "18-12, 48620 x (924 x 924 x 924 x 924 = 728933458176) = 35440744736517120" can we take any of 18 48620 randomly and iterate over all 12 (924 x 924 x 924 x 924 = 728933458176)

of course can just take

111111111111111000000000000000
111111111000000000111111000000
111111000000111111111000000000

but suddenly can shorten and 35440744736517120 (or in general that's enough 728933458176) Huh

Andzhig

jr. member

Activity: 184

Merit: 3

This crap was a long time ago, we have new crap, we need to think it over (for the magic to happen).

we have seed (15> 1, 15> 0) 111111111111111000000000000000 rearranging which we get 16 "bits"

let's say we are looking for 64 bits by 16, 4 parts "1111111111111111","0000000000000000","1111111100000000","0000000011111111"

Quote

import random
GGG=[]
for XXX in range(0,10000000,1):
   random.seed()
   s = "111111111111111000000000000000"
   sv = ''.join(random.sample(s,len(s)))
   ssv = "1"
   sssv = ssv+sv
   V1 = sv
   XXX2 = V1
   TTT=[]

   Nn1=["1111111111111111","0000000000000000","1111111100000000","0000000011111111"] # ["1111111111111111","0000000000000000","1111111100000000","0000000011111111"]

   for EEE in Nn1:
   for i in range (0,1,1):
   R=XXX2
   random.seed(R)
   import time
   Nn = "0","1" #"0","1"
   RRR = []

   for RR in range(16):
   DDD = random.choice(Nn)
   RRR.append(DDD)

   d = ''.join(RRR)
   dd = d#[0:20]
   if EEE in dd:
   if XXX2 not in GGG:
   kkk= XXX2, EEE
   GGG.append(kkk)
   pass

ffd= set(GGG)
print("start sorted...")
fd = sorted(ffd)
for Eelem in fd:
   print(Eelem)

print("end sorted...pause")
time.sleep(600.0)

('000000000001111111101101100111', '1111111111111111')
('000000000011111111001111000111', '1111111100000000')
('000000000100011011111111110011', '0000000000000000')
('000000000111110110101010101111', '0000000011111111')
('000000001011010010110111110111', '0000000000000000')
('000000001100010111011111110110', '1111111100000000')
('000000001111011011110001111100', '1111111100000000')
('000000001111100111110011001110', '0000000000000000')
('000000010001010111111111001110', '1111111100000000')
('000000010011011111110011101001', '0000000011111111')
('000000010100111111110000111011', '0000000011111111')
('000000010110111101101110110001', '0000000000000000')
('000000011101100111001111101010', '0000000000000000')
('000000011101111000011010110111', '0000000011111111')
('000000011110001100100111101111', '0000000011111111')
('000000011111111110000101101100', '1111111111111111')
('000000100101111101110011101001', '0000000011111111')
('000000100110011110111001110110', '1111111100000000')
('000000101000111100110101110111', '1111111100000000')
('000000101010111100100111011101', '0000000011111111')
('000000101101011101001111101100', '1111111100000000')
('000000110011110101111100011001', '0000000011111111')
('000000110011110101111110100010', '0000000011111111')
('000000110011111001101001101101', '0000000011111111')
('000000110100101111011011101100', '1111111100000000')
('000000110101011110001101101110', '1111111111111111')
('000000110101111001101100111100', '0000000011111111')
('000000110111000110110010111011', '1111111111111111')
('000000110111010000111101011011', '1111111100000000')
('000000111011011100111010110001', '1111111100000000')
('000000111100011110111001110100', '1111111100000000')
('000000111100101111111001001010', '1111111111111111')
('000000111100111110101000111001', '1111111100000000')
('000000111101100110011000101111', '1111111111111111')
('000000111101100111011000111010', '0000000011111111')
('000000111101110001011110110001', '0000000011111111')
('000000111101110110101110100100', '1111111111111111')
('000000111110010010100110101111', '0000000011111111')
('000001000110011001100111110111', '1111111111111111')
('000001000111001111110111001010', '1111111100000000')
('000001001011100011110110101011', '1111111111111111')
('000001001110010011101011001111', '1111111111111111')
('000001001110110110111101001001', '0000000011111111')
('000001001111000100101111111001', '0000000011111111')
('000001001111100001101010011111', '1111111111111111')
...
('111110111000110111000010000010', '0000000000000000')
('111110111001100100000100100101', '1111111100000000')
('111110111010001100110010100000', '0000000011111111')
('111110111010101101011000000000', '1111111111111111')
('111110111011010011010000010000', '1111111100000000')
('111110111011101101000010000000', '1111111111111111')
('111110111101100001000001001100', '0000000011111111')
('111111000000010101011101110000', '1111111111111111')
('111111000000100011101110010010', '0000000011111111')
('111111000000110011101010001001', '0000000011111111')
('111111000000110100100101001101', '0000000011111111')
('111111000010110001001010010101', '0000000000000000')
('111111000010111001000010001101', '1111111111111111')
('111111000011001110110100000001', '0000000011111111')
('111111000100001000010011111100', '1111111100000000')
('111111000100100001110100001110', '1111111100000000')
('111111000100100100101001011100', '1111111111111111')
('111111000101011100011001010000', '0000000011111111')
('111111000101101100001010110000', '0000000000000000')
('111111000110010011010001100100', '1111111111111111')
('111111000110100010101001001001', '1111111111111111')
('111111001000011001110000001110', '1111111111111111')
('111111001000110110001101000001', '0000000011111111')
('111111001001001010000011101010', '1111111111111111')
('111111001001001010101001010010', '0000000000000000')
('111111001001010100000000111101', '1111111111111111')
('111111001100000011001100011100', '1111111100000000')
('111111001110000000001011001110', '1111111111111111')
('111111010000111001100100100100', '0000000011111111')
('111111010010000100110011000101', '1111111111111111')
('111111010011001000010011100001', '1111111100000000')
('111111010011010101010100001000', '0000000000000000')
('111111010011011011011000000000', '1111111100000000')
('111111010100101000110100001001', '1111111111111111')
('111111011000000000100101011011', '1111111111111111')
('111111011001000010110010000011', '0000000000000000')
('111111100000010000111100100101', '0000000011111111')
('111111100001101100001110100000', '1111111111111111')
('111111100010001010000001011011', '0000000011111111')
('111111100100011001100010100010', '0000000000000000')
('111111101100001101000010000011', '0000000011111111')
('111111101101000001100101000001', '1111111111111111')
('111111110000000010011010111000', '1111111100000000')
('111111110000010100010110101000', '0000000000000000')
('111111110010100011000001100100', '0000000011111111')
('111111111010100100000000110100', '1111111100000000')
('111111111010110000000101010000', '0000000011111111')

having sorted them (I got ~4500), we see that some places are repeated and can use a "mask", actually the main question is how to catch the values we need.

000000000001111111101101100111 1111111111111111
000000000011111111001111000111 1111111100000000
000000000100011011111111110011 0000000000000000
000000000111110110101010101111 0000000011111111
000000000____1__1___1_______11 1111111111000000 14 1 5-9 0 ,14 item matches

000011110010011000110111001011 0000000000000000
000011110011001100010011101011 0000000011111111
000011110011011001010101010011 1111111100000000
000011110011101001011110010001 1111111111111111
00001111001___1_0__1_______0_1 11111110000000 16 1 8-8 0 ,16 item matches

001001001011010010011011111010 1111111111111111
001001001011011011011000011011 0000000000000000
001001001011101010111000011110 0000000011111111
001001001011111001010100111001 1111111100000000
001001001011___0___1_____11___ 11111110000000 16 1 8-8 0 ,16 item matches

and even 18 come across

100010110100110010100110010111 1111111100000000
100000110100110011100110010111 0000000011111111
110010011100110000100110110011 1111111111111111
100110110100010000101100110111 0000000000000000
1_0__0_1_100_100__10_1_0_10_11 111111000000 18 1 9-9 0 , 18 item matches

some calculations, here we have 18 (111111111000000000) and 12 (111111000000) , all permutations 18 (111111111000000000) = 48620, all permutations 12 (111111000000) = 924, if for each combination of 18 we take all combinations for 12, 48620 x (924 x 924 x 924 x 924 = 728933458176) = 35440744736517120 range, we will go through all the other possible). or 1 from 9223372036854775807-18446744073709551615 or "?" let's say so much 0-35440744736517120 (in theory, for each 16 "bit" it will be somewhere around 1000, this means that on 0-35440744736517120 range we got 1000×1000×1000×1000 = 1000000000000 possible collisions).

or again take through seed with a margin
0-35440744736517120
100000000000000000

from seed 0 to seed 100000000000000000 and somehow catch "1000000000000 possible collisions" (in the next post, a variant of division by natural, whole numbers)

or here it is necessary to choose 18 and 12 in this way immediately and not from 30 Cheesy

although if we mix them all the same then 30 each is normal (we do not need to move them, we have 1 and 0 jumping, therefore, with fixed positions 18 and fixed 12, when moving 1 and 0, all combinations 30 pass)

although all the same it looks like all 30 will not work or will (damn your head)

111111111111111000000000000000
011111111111111100000000000000
or
011111111111111100000000000000

if we take all permutations of 20 11111111110000000000 = 184756
184756 x 184756 x 184756 x 184756 = 1165183173971324375296
and here we have
18-12, 48620 x (924 x 924 x 924 x 924 = 728933458176) = 35440744736517120

it means that at 18 to 12, not all possible for 30 are triggered and what part of the possible "collisions" (1000×1000×1000×1000 = 1000000000000) will turn out to be here... it is necessary in the received ~4500 to count all the combinations included in them from 12 111111000000, but they will be included in any of the 30 just scattered throughout the space...

Quote

import random

for X in range(0,10,1):
   random.seed(X)

   s1 = "111111111111111000000000000000"
   string1 = ''.join(random.sample(s1,len(s1)))

   s2 = "111111111111111000000000000000"
   string2 = ''.join(random.sample(s2,len(s2)))

   s3 = "111111111111111000000000000000"
   string3 = ''.join(random.sample(s3,len(s3)))

   s4 = "111111111111111000000000000000"
   string4 = ''.join(random.sample(s4,len(s4)))

   print("seed",X)
   print(string1)
   print(string2)
   print(string3)
   print(string4)

seed 0
010111000101101010001001110011
110010010110111100000110001110
010011010011000110001011010111
110010010101000110101011011001
seed 1
100001110101100110010101101100
100010110011001110010010111010
000110000101010011111000111011
001011000011001001111101110010
seed 2
001101101101001101000111010001
011010010101011101101001000101
001001010001000100101111011111
000000000011101110111101101101
seed 3
100110000101010100011101111100
100110110011011000011100011001
001011011010011001111100000011
011110011000111000000001011111
seed 4
111010110100010111000100011100
100011010101100111110010100100
111001101000001001011011001011
101011000011111001011001110000
seed 5
010100000111111000100100111101
001100100101010001111011101100
111100100000100010111010101110
100111010111010011001000001110
seed 6
000100111100110011110101110000
111011101110100100000110110000
000011001101011001011111000110
110011101111100001010000011001
seed 7
111011011000100010001111010010
110011100100010011000100110111
100111100100001001010110011110
000010010001101100111011101101
seed 8
111110110000011000111001000110
010101010000111100000011110111
101111010100010101011001010001
111110010010110100001100111000
seed 9
101111011001011001110110000000
011010111010110110000010101100
111100000001101100110001101110
100111001100100110001111100010

when searching by "mask", do not say that the search time is significantly reduced (either somehow figure out how to reduce the space or complete randomness of everything).

all random search

Quote

import random
from bit import Key
import time

def func():

   random.seed()
   #______________________________ ...-26-30-... mask
   #string = "______________________________" # < mask
   #for i in range(0,len(string)):
   #string = string.replace("_",random.choice(['0','1']),1)
   #print(string,len(string))

   s = "111111111111111000000000000000"
   string = ''.join(random.sample(s,len(s)))

   return string

list = ["16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN"] #,"13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so","1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9"

Nn = "0","1"

for X in range(0,1000000,1):

   r1 = func()
   random.seed(r1)

   RRR1 = []
   for RR1 in range(16):
   DDD1 = random.choice(Nn)
   RRR1.append(DDD1)
   d1 = ''.join(RRR1)

   r2 = func()
   random.seed(r2)

   RRR2 = []
   for RR2 in range(16):
   DDD2 = random.choice(Nn)
   RRR2.append(DDD2)
   d2 = ''.join(RRR2)

   r3 = func()
   random.seed(r3)

   RRR3 = []
   for RR3 in range(16):
   DDD3 = random.choice(Nn)
   RRR3.append(DDD3)
   d3 = ''.join(RRR3)

   r4 = func()
   random.seed(r4)

   RRR4 = []
   for RR4 in range(16):
   DDD4 = random.choice(Nn)
   RRR4.append(DDD4)
   d4 = ''.join(RRR4)

   #print(d1,d2,d3,d4)

   H = []
   from itertools import permutations
   stuff = d1,d2,d3,d4
   #ddd = d1+d2+d3+d4
   for i in range(len(stuff), len(stuff)+1):
   for subset in permutations(stuff, i):
   H.append(subset)
   h = H
   for elem in h:
   d = ''.join(elem)
   ran = int(d,2)
   if ran >= 9223372036854775807:
   #ran = int(ddd,2)
   #print(ran)

   key1 = Key.from_int(ran)
   addr1 = key1.address
   if addr1 in list:

   print (ran,"found!!!")

   s5 = str(ran)
   f=open("a.txt","a")
   f.write(s5 + '\n')
   f.close()
   time.sleep(600.0)
   break

   else:
   #pass

   #print(X,"seed 1 2 3 4 ",v1,v2,v3,v4,"4 by 16 bit",d1,d2,d3,d4,ran,addr1)
   #print(X,"seed 1 2 3 4 ",v1,v2,v3,v4,"4 by 16 bit",elem,ran,addr1)
   print(X,"seed 1 2 3 4 ",r1,r2,r3,r4,"4 by 16 bit",elem,ran,addr1)
   #print("")

by "mask", "mask" can be customized

Quote

import random
from bit import Key
#from bit.format import bytes_to_wif
#from PyRandLib import *
#rand = FastRand63()
#random.seed(rand())
#mp.dps = 100; mp.pretty = True
import time

def func():

   random.seed()
   string = sv
   j1= string.count("1")
   jj2 = int(j1)
   dd = 15 - jj2
   #print(j1)
   h = [zi for zi, x in enumerate(string) if x == "_"]
   #print(h)

   indexstring = []
   lenaindexstring=len(indexstring)
   while lenaindexstring != dd:
   #for i in range(dd):
   hh = random.choice(h)
   if hh not in indexstring:

   indexstring.append(hh)
   lenaindexstring += 1

   str_list = ([string[ai:ai + 1] for ai in range(0, len(string), 1)]) #list(string)
   #print(str_list)
   for ii in indexstring:
   str_list[ii] = '1'
   string = ''.join(str_list)

   #print(indexstring)
   #print(string,len(string),string.count("1"))

   for i in range(0,len(string)):
   string = string.replace(random.choice("_"),'0',1)

   #print(string,len(string),string.count("1"),string.count("0"))

   return string

#print(func())

while True:

   random.seed()
   #______________________________ 30, 26-30 mask, 7-7 (6-8,4,10...) 1-0 = 18 (auto)manu + 12 _ random
   s = "111111111000000000____________" # 18-12, 48620 x (924 x 924 x 924 x 924 = 728933458176) = 35440744736517120 range
   sv = ''.join(random.sample(s,len(s))) # sv = s
   print(sv)

   list = ["16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN"] #,"13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so","1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9"

   Nn = "0","1"

   for X in range(0,1000000,1):

   r1 = func()
   random.seed(r1)

   RRR1 = []
   for RR1 in range(16):
   DDD1 = random.choice(Nn)
   RRR1.append(DDD1)
   d1 = ''.join(RRR1)

   r2 = func()
   random.seed(r2)

   RRR2 = []
   for RR2 in range(16):
   DDD2 = random.choice(Nn)
   RRR2.append(DDD2)
   d2 = ''.join(RRR2)

   r3 = func()
   random.seed(r3)

   RRR3 = []
   for RR3 in range(16):
   DDD3 = random.choice(Nn)
   RRR3.append(DDD3)
   d3 = ''.join(RRR3)

   r4 = func()
   random.seed(r4)

   RRR4 = []
   for RR4 in range(16):
   DDD4 = random.choice(Nn)
   RRR4.append(DDD4)
   d4 = ''.join(RRR4)

   #print(d1,d2,d3,d4)

   H = []
   from itertools import permutations
   stuff = d1,d2,d3,d4
   #ddd = d1+d2+d3+d4
   for i in range(len(stuff), len(stuff)+1):
   for subset in permutations(stuff, i):
   H.append(subset)
   h = H
   for elem in h:
   d = ''.join(elem)
   ran = int(d,2)
   if ran >= 9223372036854775807:
   #ran = int(ddd,2)
   #print(ran)

   key1 = Key.from_int(ran)
   addr1 = key1.address
   if addr1 in list:

   print (ran,"found!!!")

   s5 = str(ran)
   f=open("a.txt","a")
   f.write(s5 + '\n')
   f.close()
   time.sleep(600.0)
   break

   else:
   #pass

   #print(X,"seed 1 2 3 4 ",v1,v2,v3,v4,"4 by 16 bit",d1,d2,d3,d4,ran,addr1)
   #print(X,"seed 1 2 3 4 ",v1,v2,v3,v4,"4 by 16 bit",elem,ran,addr1)
   print(X,sv,r1,r2,r3,r4,elem,ran,addr1) # print(X,"mask",sv,r1,r2,r3,r4,"seed to bit",elem,ran,addr1)
   #print("")
   pass

why does he insert these emoticons there 30 and 14 "?" Grin

POD5

member

Activity: 251

Merit: 10

Keep smiling if you're loosing!

dextronomous

full member

Activity: 431

Merit: 105

andzhig man, you frikking awesome dude, with playing all those numbers, man you a wizzard? of numbers

thanks again for the greatness,

Andzhig

jr. member

Activity: 184

Merit: 3

Andzhig

jr. member

Activity: 184

Merit: 3

Quote from: WanderingPhilospher on May 25, 2021, 12:34:06 PM

Quote

what does kangaroo do with numbers?

we give him

1000
1004

he processes them step by step

1000
1001
1002
1003
1004

or

or glues into a string

10001001100210031004

can a kangaroo handle a string of numbers? if it can, can try such a search

Not sure if this was a real question or if you are just pondering how to change Kangaroo.

But Kangaroo, you give it a range, we will stay with your 1000-1004 example. And we are searching for key/pub 1000.

Tame
KEY/#/Point PUBKEY/#/Distance
1000 = 01000
1001 = A1001
1002 = 91002
1003 = 01003
1004 = 71004

Wild (offset of PubKey)
KEY/#/Point PUBKEY/#/Distance
1000 = 00000
1001 = A0001
1002 = 90002
1003 = 00003
1004 = 70004

Above is just example. But, if user told Kangaroo to search for leading DP = 0 bits, then all keys would eventually be entered into hashtable (because Kangaroo makes jumps, not sequential). If you told Kangaroo to search for leading DP = 4 bits, then only key 1000 and 1003 would be entered into hashtable. Then Kangaroo would do a collision check between Tame and Wild; checking if any of the KEY/#/Points match:

Tame
1000 pub = 01000
1000 pub = 00000
Key = Tame Distance - Wild Distance = Priv Key
Key = 01000 - 00000 = Priv Key 1000

Priv key could also be found with 1003.

yes real question.

from https://github.com/Telariust/pollard-kangaroo

Quote

How pollard-kangaroo works, the Tame and Wild kangaroos, is a simple explanation.

Suppose there is pubkeyX, unknow privkeyX, but privkeyX is in range w=[L..U]. The keys have a property - if we increase pubkey by S, then its privkey will also increase by S. We start step-by-step to increase pubkeyX by S(i), keeping sumX(S(i)). This is a Wild kangaroo. We select a random privkeyT from range [L..U], compute pubkeyT. We start step-by-step to increment pubkeyT by S(i) while maintaining sumT(S(i)). This is a Tame kangaroo. The size of the jump S(i) is determined by the x coordinate of the current point, so if a Wild or Tame kangaroo lands on one point, their paths will merge. (we are concerned with pseudo random walks whose next step is determined by the current position) Thanks to the Birthday Paradox (Kruskal's card trick), their paths will one day meet. Knowing each traveled path (sumX and sumT), privkeyX is calculated. The number of jumps is approximately 2w1/2 group operations, which is much less than a full search w.

Suppose there is pubkeyX, unknow privkeyX, but privkeyX is in range w=[L..U].

that is, we give him a range, he checks everything num from there?

Quote

if user told Kangaroo to search for leading DP = 0 bits, then all keys would eventually be entered into hashtable (because Kangaroo makes jumps, not sequential)

it means that he enters everything into the table, otherwise he can skip past...

if give the program instead range w=[L..U] randomly generated (in seed(0...1...2...3...etc) order) numbers long of our range w=[L..U]. We just iterate over the seed(). pz 125, 48 dec lenght. It is necessary to empirically find out in which randomly selected number (the longest of our range, acceptable for the search time) the desired number, 48 characters long, may turn out to be. The length of the number we have is limited range w=[L..U] left to jump on seed() relying on the probability of falling out of the desired.

If so, then you need to investigate the probability of the desired number falling out in the randomly generated range. And this is already the probability both from the length of the random number and from the seed () of the sample from which this number is selected.

of course, it will be quite difficult to find such a number so that the desired one could be in it 48 dec lenght, but in any case it is faster than just search by brute force shifting by a character in a large number...

exampl

123

4567890123
456
567
678
789
890
901
012
123

exampl

num 6 lenght 305683 similarly for 48 lengths pz 125 etc

in set "0","1","2","3","4","5","6","7","8","9" seed(250), random take 1000 char lenght (range w=[L..U])

6628108325646789492263743967369759335755330180876937749882483905138112428915013 9054848072269264202560819040354104866048607654607172251754376123013651469513049 5648200952501634505347303680081039514653337468980735311573971468007409323052011 0473225788077579473811677176050310606326591721387075750832843405067707502985666 6876617145832945544955613229276911559767104378637512948667047379064542492920975 2581324109003398367155062153265046958882531259230674050006267332751608318114807 7659936936197772897279551958970524784024371622381672464294673986840979653120419 1377973297040059463032741096578635370403280126662410147279435963632903139195988 5921142354005159220109798247570353825280747075846602460555303063249395364226634 21000204867084028267152068561737783193563121328046590591700368123056830692780420939899081369619843410377252264486201655086656380393186164736079012228 1549123570206781972709793858486954913794909950390553544102005076775328421225780 7616262718853368296898188896602573351571258671721308746732768

in set "0","1","2","3","4","5","6","7","8","9" seed(618), random take 1000 char lenght (range w=[L..U])

7271521025244124365207776189223775239575217553231514830801677530250829188476058 9584051073104191163434015636888665573089788551375513886590346145184878898638183 4230725850807208425593908647286354440391516972196316264217327283069791943047407 5435634408623970271715415048852321736405170224546087621981489103051717180611070 20222597054471800446206783586979040918344375062719573056839567470799313032694934668609814254346562430837032347542160481539801144283721315 6670881397651734966049767791051628938419947125563206965150322651169759574845400 8146472584315136519775634397917280791885905913181878738809851212016739847096395 9225726584627361788453049048321033166991196942042496479487251890643160344901152 5862764587101576517380872702619180367502816723326130852163890478289995273918557 1149637309515538725747409365493288233833950817026792553627640508339998102336790 8186198609312546415241068577642916179067686979509941374153769851338568026033509 7991411852864023386165725877650939884695604158402095378392973053699905562

here's another joke, when you change the set itself for randomness, the final number also changes... "0","1","2","3","4","5","6","7","8","9" > "9","1","2","3","4","5","6","7","8","0" etc can simply enumerate all the permutation options. all combinations of 10 characters (then can choose the length of the sample of the number, "1000 char lenght (range w=[L..U]" , for the run of all variants of the permutation by adapting to the kangaroo run time). but they can be duplicated))) and the final numbers also change "0","0","0","1","2","3","4","5","6","7","8","9" etc.

***

Or maybe can do without a kangaroo.

pz 64 bit / 4 = 16

4 pieces of 16 bits

look at the dropouts of 16 bit pieces from the set "0","1" random take 16 by manual seed()

example (seed 1000000-10000000)

1111111111111111
1111111100000000
0000000011111111
0000000000000000

num random take seed

1111111111111111 1111111111111111 1114948
1111111111111111 1111111111111111 1160968
1111111111111111 1111111111111111 1195787
1111111111111111 1111111111111111 1234445
1111111111111111 1111111111111111 1236719
1111111111111111 1111111111111111 1416203
1111111111111111 1111111111111111 1446793
1111111111111111 1111111111111111 1456000
1111111111111111 1111111111111111 1473679
1111111111111111 1111111111111111 1528372
1111111111111111 1111111111111111 1700283
1111111111111111 1111111111111111 1863356
1111111111111111 1111111111111111 2067213
1111111111111111 1111111111111111 2130736
1111111111111111 1111111111111111 2135579
1111111111111111 1111111111111111 2165771
1111111111111111 1111111111111111 2238665
1111111111111111 1111111111111111 2239115
1111111111111111 1111111111111111 2272997
1111111111111111 1111111111111111 2275808
1111111111111111 1111111111111111 2449621
1111111111111111 1111111111111111 2473996
1111111111111111 1111111111111111 2551922
1111111111111111 1111111111111111 2588763
1111111111111111 1111111111111111 2652283
1111111111111111 1111111111111111 2663455
1111111111111111 1111111111111111 2803001
1111111111111111 1111111111111111 2829236
1111111111111111 1111111111111111 2840962
1111111111111111 1111111111111111 2850965
1111111111111111 1111111111111111 3078960
1111111111111111 1111111111111111 3085366
1111111111111111 1111111111111111 3235395
1111111111111111 1111111111111111 3301219
1111111111111111 1111111111111111 3353239
1111111111111111 1111111111111111 3367803
1111111111111111 1111111111111111 3434427
1111111111111111 1111111111111111 3464486
1111111111111111 1111111111111111 3567095
1111111111111111 1111111111111111 3617683
1111111111111111 1111111111111111 3776795
1111111111111111 1111111111111111 3834023
1111111111111111 1111111111111111 3902301
1111111111111111 1111111111111111 3906723
1111111111111111 1111111111111111 3998158
1111111111111111 1111111111111111 4395447
...

1111111100000000 1111111100000000 1054187
1111111100000000 1111111100000000 1056509
1111111100000000 1111111100000000 1117232
1111111100000000 1111111100000000 1176072
1111111100000000 1111111100000000 1188876
1111111100000000 1111111100000000 1243485
1111111100000000 1111111100000000 1331323
1111111100000000 1111111100000000 1332986
1111111100000000 1111111100000000 1337370
1111111100000000 1111111100000000 1363459
1111111100000000 1111111100000000 1381417
1111111100000000 1111111100000000 1611291
1111111100000000 1111111100000000 1645681
1111111100000000 1111111100000000 1650418
1111111100000000 1111111100000000 1670070
1111111100000000 1111111100000000 1706046
1111111100000000 1111111100000000 1815838
1111111100000000 1111111100000000 1834227
1111111100000000 1111111100000000 1886796
1111111100000000 1111111100000000 1922279
1111111100000000 1111111100000000 2010195
1111111100000000 1111111100000000 2128263
1111111100000000 1111111100000000 2290889
1111111100000000 1111111100000000 2302560
1111111100000000 1111111100000000 2399428
1111111100000000 1111111100000000 2404067
1111111100000000 1111111100000000 2508910
1111111100000000 1111111100000000 2566310
1111111100000000 1111111100000000 2644365
1111111100000000 1111111100000000 2660616
1111111100000000 1111111100000000 2682201
1111111100000000 1111111100000000 2720460
1111111100000000 1111111100000000 2788235
1111111100000000 1111111100000000 2803556
1111111100000000 1111111100000000 2995909
1111111100000000 1111111100000000 3016738
1111111100000000 1111111100000000 3053510
1111111100000000 1111111100000000 3110902
1111111100000000 1111111100000000 3131325
1111111100000000 1111111100000000 3204443
1111111100000000 1111111100000000 3215189
1111111100000000 1111111100000000 3263944
1111111100000000 1111111100000000 3353340
1111111100000000 1111111100000000 3378959
1111111100000000 1111111100000000 3446082
1111111100000000 1111111100000000 3452072
1111111100000000 1111111100000000 3715477
1111111100000000 1111111100000000 3721299
1111111100000000 1111111100000000 3734948
1111111100000000 1111111100000000 3774280
1111111100000000 1111111100000000 3802499
1111111100000000 1111111100000000 3924776
1111111100000000 1111111100000000 3956617
1111111100000000 1111111100000000 4028377
1111111100000000 1111111100000000 4030971
1111111100000000 1111111100000000 4034149
1111111100000000 1111111100000000 4050906
1111111100000000 1111111100000000 4170148
...

0000000011111111 0000000011111111 1014612
0000000011111111 0000000011111111 1092983
0000000011111111 0000000011111111 1181805
0000000011111111 0000000011111111 1262356
0000000011111111 0000000011111111 1362375
0000000011111111 0000000011111111 1363250
0000000011111111 0000000011111111 1364709
0000000011111111 0000000011111111 1385381
0000000011111111 0000000011111111 1473580
0000000011111111 0000000011111111 1478257
0000000011111111 0000000011111111 1537714
0000000011111111 0000000011111111 1565537
0000000011111111 0000000011111111 1599065
0000000011111111 0000000011111111 1647800
0000000011111111 0000000011111111 1660773
0000000011111111 0000000011111111 1770209
0000000011111111 0000000011111111 1815169
0000000011111111 0000000011111111 1833177
0000000011111111 0000000011111111 1870243
0000000011111111 0000000011111111 1990606
0000000011111111 0000000011111111 2027523
0000000011111111 0000000011111111 2240311
0000000011111111 0000000011111111 2265141
0000000011111111 0000000011111111 2278178
0000000011111111 0000000011111111 2278407
0000000011111111 0000000011111111 2428071
0000000011111111 0000000011111111 2555130
0000000011111111 0000000011111111 2646700
0000000011111111 0000000011111111 2648761
0000000011111111 0000000011111111 2654497
0000000011111111 0000000011111111 2661170
0000000011111111 0000000011111111 2754612
0000000011111111 0000000011111111 2797761
0000000011111111 0000000011111111 2857678
0000000011111111 0000000011111111 2882756
0000000011111111 0000000011111111 2901323
0000000011111111 0000000011111111 2903732
0000000011111111 0000000011111111 2967723
0000000011111111 0000000011111111 2998580
0000000011111111 0000000011111111 3010310
0000000011111111 0000000011111111 3111819
0000000011111111 0000000011111111 3173905
0000000011111111 0000000011111111 3326081
0000000011111111 0000000011111111 3382942
0000000011111111 0000000011111111 3419409
0000000011111111 0000000011111111 3517988
0000000011111111 0000000011111111 3583895
0000000011111111 0000000011111111 3584603
0000000011111111 0000000011111111 3719106
0000000011111111 0000000011111111 3734597
0000000011111111 0000000011111111 3798617
0000000011111111 0000000011111111 3800519
0000000011111111 0000000011111111 3863353
0000000011111111 0000000011111111 3905083
0000000011111111 0000000011111111 3971224
0000000011111111 0000000011111111 4198934
...

0000000000000000 0000000000000000 1102455
0000000000000000 0000000000000000 1198695
0000000000000000 0000000000000000 1344516
0000000000000000 0000000000000000 1467638
0000000000000000 0000000000000000 1475136
0000000000000000 0000000000000000 1556961
0000000000000000 0000000000000000 1612858
0000000000000000 0000000000000000 1657598
0000000000000000 0000000000000000 1701975
0000000000000000 0000000000000000 1751267
0000000000000000 0000000000000000 1866699
0000000000000000 0000000000000000 1916710
0000000000000000 0000000000000000 1988329
0000000000000000 0000000000000000 2020138
0000000000000000 0000000000000000 2128086
0000000000000000 0000000000000000 2356070
0000000000000000 0000000000000000 2428562
0000000000000000 0000000000000000 2533401
0000000000000000 0000000000000000 2598383
0000000000000000 0000000000000000 2657193
0000000000000000 0000000000000000 2816858
0000000000000000 0000000000000000 2879692
0000000000000000 0000000000000000 2920961
0000000000000000 0000000000000000 3020439
0000000000000000 0000000000000000 3027475
0000000000000000 0000000000000000 3028599
0000000000000000 0000000000000000 3084737
0000000000000000 0000000000000000 3101038
0000000000000000 0000000000000000 3106651
0000000000000000 0000000000000000 3239026
0000000000000000 0000000000000000 3245561
0000000000000000 0000000000000000 3263552
0000000000000000 0000000000000000 3266550
0000000000000000 0000000000000000 3404616
0000000000000000 0000000000000000 3446912
0000000000000000 0000000000000000 3468930
0000000000000000 0000000000000000 3534875
0000000000000000 0000000000000000 3584724
0000000000000000 0000000000000000 3723616
0000000000000000 0000000000000000 3764518
0000000000000000 0000000000000000 3800737
0000000000000000 0000000000000000 3923726
0000000000000000 0000000000000000 3976055
0000000000000000 0000000000000000 3978420
0000000000000000 0000000000000000 3988943
0000000000000000 0000000000000000 4190617
0000000000000000 0000000000000000 4231445
0000000000000000 0000000000000000 4233459
0000000000000000 0000000000000000 4287465
0000000000000000 0000000000000000 4321838
0000000000000000 0000000000000000 4328623
0000000000000000 0000000000000000 4364994
...

as can see, some seeds() match the first numbers

1111111111111111 1111111111111111 3776795

1111111100000000 1111111100000000 3715477
1111111100000000 1111111100000000 3721299
1111111100000000 1111111100000000 3734948
1111111100000000 1111111100000000 3774280

0000000011111111 0000000011111111 3719106
0000000011111111 0000000011111111 3734597
0000000011111111 0000000011111111 3798617

0000000000000000 0000000000000000 3723616
0000000000000000 0000000000000000 3764518

then there will be such with repeated first 3 or even 4 digits

and will have to iterate over just 0000-9999 or even 000-999

we can play with seed however we want

1111111111111111 1111111111111111 100000000000000000092928
1111111111111111 1111111111111111 100000000000000000454716
1111111111111111 1111111111111111 100000000000000000532054
1111111111111111 1111111111111111 100000000000000000861504
1111111111111111 1111111111111111 100000000000000001063166
1111111111111111 1111111111111111 100000000000000001079457
1111111111111111 1111111111111111 100000000000000001125196
1111111111111111 1111111111111111 100000000000000001137021
1111111111111111 1111111111111111 100000000000000001196552
1111111111111111 1111111111111111 100000000000000001258352
...

1111111111111111 1111111111111111 100100000000000000054516
1111111111111111 1111111111111111 100100000000000000069416
1111111111111111 1111111111111111 100100000000000000076498
1111111111111111 1111111111111111 100100000000000000178589
1111111111111111 1111111111111111 100100000000000000198487
1111111111111111 1111111111111111 100100000000000000338758
1111111111111111 1111111111111111 100100000000000000341690
1111111111111111 1111111111111111 100100000000000000385849
1111111111111111 1111111111111111 100100000000000000403566
1111111111111111 1111111111111111 100100000000000000459732
1111111111111111 1111111111111111 100100000000000000474863
...

1111111111111111 1111111111111111 100000000100000000078636
1111111111111111 1111111111111111 100000000100000000113259
1111111111111111 1111111111111111 100000000100000000116786
1111111111111111 1111111111111111 100000000100000000206369
1111111111111111 1111111111111111 100000000100000000272648
1111111111111111 1111111111111111 100000000100000000292722
1111111111111111 1111111111111111 100000000100000000405295
1111111111111111 1111111111111111 100000000100000000478474
...

1111111111111111 1111111111111111 107749499999999999922505
1111111111111111 1111111111111111 120909799999999999790902
1111111111111111 1111111111111111 123115299999999999768847
1111111111111111 1111111111111111 131149399999999999688506
1111111111111111 1111111111111111 132521899999999999674781
1111111111111111 1111111111111111 133511799999999999664882
1111111111111111 1111111111111111 134918899999999999650811
1111111111111111 1111111111111111 138612599999999999613874
1111111111111111 1111111111111111 139319399999999999606806
1111111111111111 1111111111111111 146412799999999999535872
...

...
1111111111111111 1111111111111111 101000000000000000000000000000000000000000000000000002123668
1111111111111111 1111111111111111 101000000000000000000000000000000000000000000000000002146904
1111111111111111 1111111111111111 101000000000000000000000000000000000000000000000000002159762
1111111111111111 1111111111111111 101000000000000000000000000000000000000000000000000002206181
1111111111111111 1111111111111111 101000000000000000000000000000000000000000000000000002264561
1111111111111111 1111111111111111 101000000000000000000000000000000000000000000000000002344811
1111111111111111 1111111111111111 101000000000000000000000000000000000000000000000000002455486
1111111111111111 1111111111111111 101000000000000000000000000000000000000000000000000002480462
1111111111111111 1111111111111111 101000000000000000000000000000000000000000000000000002534433
1111111111111111 1111111111111111 101000000000000000000000000000000000000000000000000002729400
1111111111111111 1111111111111111 101000000000000000000000000000000000000000000000000003140504
1111111111111111 1111111111111111 101000000000000000000000000000000000000000000000000003212460
1111111111111111 1111111111111111 101000000000000000000000000000000000000000000000000003284649
1111111111111111 1111111111111111 101000000000000000000000000000000000000000000000000003301676
1111111111111111 1111111111111111 101000000000000000000000000000000000000000000000000003327779
1111111111111111 1111111111111111 101000000000000000000000000000000000000000000000000003409748
...

...
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000001944130
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000001964911
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000002022639
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000002245698
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000002339489
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000002435444
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000002567005
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000002693538
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000002729828
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000002737254
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000002972374
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000002984002
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000003082988
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000003216730
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000003221258
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000003271554
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000003360276
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000003476620
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000003626369
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000003627591
1111111100000000 1111111100000000 101000000000000000000000000000000000000000000000000003679463
...

etc

take fixed first parts for 4 parts of 16 bits

seed

155(random 0000-9999)
155(random 0000-9999)
155(random 0000-9999)
155(random 0000-9999)

1155(random 0000-9999)
1155(random 0000-9999)
1155(random 0000-9999)
1155(random 0000-9999)

10155(random 0000-9999)
10155(random 0000-9999)
10155(random 0000-9999)
10155(random 0000-9999)

100000000000000155(random 0000-9999)
100000000000000155(random 0000-9999)
100000000000000155(random 0000-9999)
100000000000000155(random 0000-9999)

etc

seed(100000000000000155(random 0000-9999))+seed(100000000000000155(random 0000-9999))+seed(100000000000000155(random 0000-9999))+seed(100000000000000155(random 0000-9999))= 64 bit pz 64.

for the next few puzzles, can simply add in front or behind 1 by 2 by 3 all combinations of bits

+0
+1

+00
+10
+01
+11

etc

WanderingPhilospher

full member

Activity: 1148

Merit: 237

Shooters Shoot...

Quote

what does kangaroo do with numbers?

we give him

1000
1004

he processes them step by step

1000
1001
1002
1003
1004

or

or glues into a string

10001001100210031004

can a kangaroo handle a string of numbers? if it can, can try such a search

Not sure if this was a real question or if you are just pondering how to change Kangaroo.

But Kangaroo, you give it a range, we will stay with your 1000-1004 example. And we are searching for key/pub 1000.

Tame
KEY/#/Point PUBKEY/#/Distance
1000 = 01000
1001 = A1001
1002 = 91002
1003 = 01003
1004 = 71004

Wild (offset of PubKey)
KEY/#/Point PUBKEY/#/Distance
1000 = 00000
1001 = A0001
1002 = 90002
1003 = 00003
1004 = 70004

Above is just example. But, if user told Kangaroo to search for leading DP = 0 bits, then all keys would eventually be entered into hashtable (because Kangaroo makes jumps, not sequential). If you told Kangaroo to search for leading DP = 4 bits, then only key 1000 and 1003 would be entered into hashtable. Then Kangaroo would do a collision check between Tame and Wild; checking if any of the KEY/#/Points match:

Tame
1000 pub = 01000
1000 pub = 00000
Key = Tame Distance - Wild Distance = Priv Key
Key = 01000 - 00000 = Priv Key 1000

Priv key could also be found with 1003.

Andzhig

jr. member

Activity: 184

Merit: 3

apparently have not yet come up with.

kangaroo emerged from Floyd's "tortoise and hare" https://en.wikipedia.org/wiki/Cycle_detection

It seems that the smaller the set, the easier it is to find the desired element. for example from a set of 0 and 1 finds 20 longest number faster...

30568377312064202855 11010100000111000101100010011010100000101101100100110100001100111

from "0","1" number of characters 100000 lenght

seed(4)

etc...

if take 16 from "0","1" number of characters 10000 lenght

110101000001110

seed

110101000001110 0
110101000001110 1
110101000001110 4
110101000001110 5
110101000001110 6
110101000001110 7
110101000001110 8
110101000001110 9

001011000100110

seed

001011000100110 0
001011000100110 1
001011000100110 2
001011000100110 3
001011000100110 4
001011000100110 5
001011000100110 6
001011000100110 7
001011000100110 8
001011000100110 9

10000x10000=100000000 combinations and for each it will be necessary to sort out "if take 31(pz 63-16+16) from "0","1" number of characters 5000000 lenght" (somewhere in this range, a number of 31 bits is caught)
et's say you can run each of 500000 to 100000000 per second = 1157 days for 1 prog...

Quote

import random
from bit import Key

for XXX in range(0,10,1):

   # 30568377312064202855
   # 11010100000111000101100010011010100000101101100100110100001100111
   # 110101000001110 001011000100110

   TTT=[]

   Nn1=["110101000001110"]

   for EEE in Nn1:
   for i in range (0,1,1):
   R=i

   random.seed(XXX)

   import time

   Nn = "0","1"

   RRR = []

   for RR in range(100000): # number of characters lenght
   DDD = random.choice(Nn)
   RRR.append(DDD)

   d = ''.join(RRR)
   dd = d#[0:20]

   if EEE in dd:

   print("",EEE,d,XXX)

   pass

CanalGanheAgora

newbie

Activity: 24

Merit: 0

is there any new method for trying to find private keys? Sad

it is so difficult to find private keys without the public keys of the addresses. Undecided

fxsniper

member

Activity: 406

Merit: 47

Quote from: Andzhig on May 12, 2021, 04:51:43 PM

Telariust / pollard-kangaroo https://github.com/Telariust/pollard-kangaroo

I think this script in better
http://bitchain.pl/100btc/pollard_kangaroo.txt
https://github.com/secoc/Pollard-Rho-kangaroo/blob/master/Pollard_Rho_kangaroo_with_Python2.7_demo.py
I think this script can found key from difference collision

problem this script
https://github.com/Telariust/pollard-kangaroo
is script always to found key from same collision
it can not found other collision point position
script work fast because work from multi thread cpu using

fxsniper

member

Activity: 406

Merit: 47

Quote from: SimpleMan on May 12, 2021, 03:50:35 PM

But going over the discussion here I am of the impression that there is much more you need than just a state-of-the-art computer. Is this puzzle to be solved just based on luck or an element of luck or could it be solved based on pure logic?

No, I think no logic can solve this puzzle becuase puzzle is random
so, now for puzzle that have only address no pubkey you can do two way one is scan it all key or do random bruteforce
not yet have other way can do for now

Andzhig

jr. member

Activity: 184

Merit: 3

what does kangaroo do with numbers?

we give him

1000
1004

he processes them step by step

1000
1001
1002
1003
1004

or

or glues into a string

10001001100210031004

can a kangaroo handle a string of numbers? if it can, can try such a search

for example we have 3 controls,

controls 1 seed1 mix the set 1,2,3,4,5,6,7,8,9,0
controls 2 seed2 selects from the set seed1
controls 3 lenght seed2

example of search for step-by-step controls, for each step controls 1 1000000 steps controls 2

seed2(selects from the set seed1) lenght seed2(4) seed1(mix the set 1,2,3,4,5,6,7,8,9,0)

0,1000000 lenght 4 1234 0,1000000 set 1,2,3,4,5,6,7,8,9,0

1920 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
2816 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
4201 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
4780 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
11611 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
16731 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
26145 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
61077 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
62795 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
94824 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
97746 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
105143 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
130617 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
132585 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
134100 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
137532 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
147808 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
154336 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
175874 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
185947 1234 1234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
...

lenght 5

202442 12345 12345 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
259589 12345 12345 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
460471 12345 12345 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
505449 12345 12345 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
762002 12345 12345 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
814323 12345 12345 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
820734 12345 12345 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
58631 12345 12345 1 ['2', '1', '4', '0', '3', '5', '7', '9', '8', '6']
144887 12345 12345 1 ['2', '1', '4', '0', '3', '5', '7', '9', '8', '6']
153883 12345 12345 1 ['2', '1', '4', '0', '3', '5', '7', '9', '8', '6']
169489 12345 12345 1 ['2', '1', '4', '0', '3', '5', '7', '9', '8', '6']
286728 12345 12345 1 ['2', '1', '4', '0', '3', '5', '7', '9', '8', '6']
332995 12345 12345 1 ['2', '1', '4', '0', '3', '5', '7', '9', '8', '6']
351328 12345 12345 1 ['2', '1', '4', '0', '3', '5', '7', '9', '8', '6']
...

lenght 6 the longer the net number, the less often the find

460471 123456 123456 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
286728 123456 123456 1 ['2', '1', '4', '0', '3', '5', '7', '9', '8', '6']
644193 123456 123456 1 ['2', '1', '4', '0', '3', '5', '7', '9', '8', '6']
876509 123456 123456 2 ['0', '1', '8', '2', '7', '6', '4', '3', '9', '5']
...

lenght 7

870183 1234567 1234567 20 ['2', '4', '1', '6', '9', '8', '7', '0', '3', '5']
354658 1234567 1234567 26 ['3', '9', '6', '4', '7', '0', '1', '8', '5', '2']
358866 1234567 1234567 35 ['8', '5', '2', '9', '7', '1', '6', '4', '3', '0']
459256 1234567 1234567 43 ['0', '4', '2', '3', '7', '9', '6', '5', '1', '8']
...

lenght 8

631252 12345678 12345678 110 ['6', '3', '9', '8', '5', '2', '0', '4', '1', '7']
88968 12345678 12345678 387 ['7', '3', '0', '6', '1', '5', '4', '8', '2', '9']
928402 12345678 12345678 420 ['0', '5', '4', '3', '9', '8', '7', '2', '1', '6']
501677 12345678 12345678 944 ['0', '5', '8', '9', '2', '3', '6', '4', '1', '7']
930525 12345678 12345678 1093 ['5', '6', '9', '1', '3', '0', '7', '2', '4', '8']
52326 12345678 12345678 1202 ['4', '7', '6', '5', '1', '0', '3', '8', '2', '9']
...

lenght 9

340053 123456789 123456789 2935 ['3', '7', '6', '4', '9', '5', '8', '1', '0', '2']
246637 123456789 123456789 4095 ['7', '2', '4', '3', '9', '1', '8', '6', '5', '0']
40352 123456789 123456789 4667 ['0', '9', '5', '2', '7', '4', '8', '1', '3', '6']
505340 123456789 123456789 5144 ['4', '9', '5', '3', '7', '0', '1', '2', '8', '6']
...

lenght 10 at a length of 10 has been looking for a very long time

340053 1234567890 1234567890 2935 ['3', '7', '6', '4', '9', '5', '8', '1', '0', '2']
344381 1234567890 1234567890 6943 ['2', '8', '5', '4', '0', '9', '3', '7', '6', '1']
...

but we didn't use control 3, increasing the length of the number, the longer the length, the more fallouts.

1234 lenght 50

49 1234 93593886640168827473562095533457765872974878301234 0 ['6', '9', '0', '2', '4', '3', '5', '1', '8', '7']
41 1234 76517892978353011619883483795460123441139658388173 4 ['3', '4', '1', '5', '9', '6', '7', '0', '2', '8']
77 1234 78666471326533979156305884437316664463123446844214 5 ['9', '4', '5', '6', '7', '8', '0', '1', '3', '2']
13 1234 22767677186294759271234720638540401052385733872678 6 ['9', '1', '7', '6', '2', '0', '4', '3', '8', '5']
16 1234 72264123461136678563156385322561676407249856536039 15 ['3', '0', '8', '1', '6', '7', '4', '2', '9', '5']
15 1234 25458255812710139312211234926090706106109705284865 16 ['5', '7', '8', '2', '3', '1', '9', '0', '4', '6']
4 1234 98136711234829445871892889788510534979681482808493 18 ['2', '1', '7', '9', '8', '5', '3', '6', '4', '0']
89 1234 89713812347389169041960538826827310015481303951751 19 ['0', '8', '1', '4', '7', '3', '2', '6', '5', '9']
12 1234 49038123494750278438352756031622056146180370820806 21 ['2', '6', '8', '5', '9', '3', '1', '4', '0', '7']
45 1234 26521234154121247102096176044032331614336887274539 23 ['4', '1', '0', '9', '2', '3', '6', '5', '8', '7']
87 1234 09812383134261587192081242676359397577242123472574 23 ['4', '1', '0', '9', '2', '3', '6', '5', '8', '7']
88 1234 01536765831234380503932856318113617876807087283063 24 ['6', '2', '3', '1', '9', '5', '0', '8', '7', '4']
41 1234 10461275712343866067223923174908653996637042322613 26 ['3', '9', '6', '4', '7', '0', '1', '8', '5', '2']
32 1234 76136500782802584021205636578702715090028615351234 31 ['0', '7', '1', '6', '3', '8', '9', '5', '2', '4']
34 1234 83495973172314801234908193289704227355680404787551 37 ['9', '1', '0', '5', '2', '3', '7', '6', '8', '4']
11 1234 27227806728642164738928683743300832528070123421974 39 ['3', '4', '6', '0', '1', '5', '9', '2', '7', '8']
12 1234 50387948505123417587824126389644326956973813743736 45 ['4', '6', '7', '2', '0', '8', '9', '5', '3', '1']
71 1234 83140720623412343857874814912789564217723801408294 45 ['4', '6', '7', '2', '0', '8', '9', '5', '3', '1']
49 1234 75175992264829930605123471155610021903706909548356 54 ['2', '7', '4', '3', '6', '5', '1', '8', '9', '0']
31 1234 18392123452211254849563319055090655596411202529134 55 ['1', '3', '2', '5', '7', '0', '9', '8', '4', '6']
51 1234 59975594396992123438089486721426586768801079683352 56 ['8', '0', '7', '5', '4', '2', '3', '6', '9', '1']
5 1234 07359469123468520696871812100411996611736561687938 62 ['9', '2', '1', '6', '7', '3', '8', '4', '5', '0']
99 1234 88426446158991234822408463620191308759784091394237 64 ['7', '1', '6', '4', '5', '0', '8', '3', '9', '2']
59 1234 94516317158503672604421234194774334774276814530092 66 ['1', '4', '6', '9', '3', '2', '8', '5', '0', '7']
82 1234 65036636185749306454225456192310205883831234931912 66 ['1', '4', '6', '9', '3', '2', '8', '5', '0', '7']
8 1234 32073147383016660653046319806049440504123468357548 70 ['1', '4', '7', '3', '9', '2', '0', '6', '8', '5']
84 1234 57271402214891512348092717972151670039565661621792 75 ['7', '6', '9', '0', '5', '4', '3', '2', '1', '8']
72 1234 57309706730123418485659042660010810783627038144024 77 ['4', '5', '3', '1', '6', '0', '2', '8', '9', '7']
21 1234 49960507477533289145539980327012341130472904430515 78 ['3', '1', '4', '5', '6', '2', '9', '0', '7', '8']
67 1234 66313753157248748186617235430889041234983045192485 80 ['4', '6', '8', '2', '7', '9', '3', '1', '0', '5']
98 1234 95493417061234944379412083850275082023060838918706 80 ['4', '6', '8', '2', '7', '9', '3', '1', '0', '5']
65 1234 30057885859374580786104252429969677388121909012340 89 ['1', '4', '2', '7', '0', '9', '3', '8', '5', '6']
10 1234 75847514406534291258672880046026414785751610321234 96 ['5', '9', '6', '1', '0', '2', '8', '4', '3', '7']
46 1234 98577136735592556303298426449437981234069729724868 96 ['5', '9', '6', '1', '0', '2', '8', '4', '3', '7']
76 1234 24810581004419201235587781234598691907939551446778 96 ['5', '9', '6', '1', '0', '2', '8', '4', '3', '7']
21 1234 57702829599833417658837712349264356632594725532868 97 ['3', '6', '5', '8', '0', '4', '7', '2', '9', '1']

Quote

import random

for XXX in range(0,1000000,1): # controls 1
   random.seed(XXX)
   Nn =["0","1","2","3","4","5","6","7","8","9"]
   RRRR = []
   SSS = random.sample(Nn, k=len(Nn))
   TTT=[]
   Nn1=["1234"]
   for EEE in Nn1:
   for i in range (0,1000000,1): #controls 2
   R=i
   random.seed(R)
   Nn = SSS
   RRR = []
   for RR in range(50): # controls 3
   DDD = random.choice(Nn)
   RRR.append(DDD)
   d = ''.join(RRR)
   dd = d #[0:5]
   #print(R,d,RRR)
   if EEE in dd:
   print(R,EEE,d,XXX,SSS)
   pass

from observations, in order for the required number of the puzzle to fall out in large quantities, it should be less by 2 characters, but its length will weigh impressively

for a 20 signed number, you need a number with a length of 18 characters

10000000000000000000 pz (20 num lenght)
100000000000000000 byte lenght (in 100 of these, the high probability of the number of the puzzle 63)

for puzzle 120 can feed such pieces of numbers, long strides long range i.e. instead of a range, give a long number randomly generated kangaroo jump Cheesy

***

can try another option, but how to increase the probability... use 2 controls for random (without specifying seed).

0,1000000 4 4 0,1000000

327869 1234 1234 492498 ['8', '3', '6', '2', '5', '4', '9', '7', '0', '1']
813671 1234 1234 713004 ['8', '2', '1', '4', '3', '0', '5', '9', '6', '7']
964510 1234 1234 249510 ['8', '0', '1', '4', '2', '6', '7', '5', '9', '3']
540959 1234 1234 581083 ['9', '4', '1', '6', '8', '2', '0', '5', '7', '3']

0,1000000 4 50 0,1000000

811043 1234 81816778138793770762256346928203086989259654512342 904831 ['2', '9', '0', '4', '7', '8', '1', '3', '6', '5']
752681 1234 82421193686426173990201252195076128638123484792873 780556 ['4', '8', '1', '9', '2', '0', '6', '7', '3', '5']
101889 1234 60937224800624695061798123439073020537533124051540 81252 ['1', '0', '2', '3', '4', '9', '8', '5', '7', '6']
628954 1234 11328677715310449570152377732952732003411106123407 629598 ['1', '2', '8', '4', '3', '6', '5', '7', '9', '0']

***

Telariust / pollard-kangaroo https://github.com/Telariust/pollard-kangaroo

how to insert a string of numbers into this? and why should he [PRNGseed]? if you change it, it finds in any case or the time of finding changes slightly...

example ADE6D7CE3B9B:22BD43C2E9354 02591d682c3da4a2a698633bf5751738b67c343285ebdc3492645cb44658911484

find 000000000000000000000000000000000000000000000000000174176b015f4d

Quote

   if len(sys.argv) > 1 :
      #bits
      try:
         pow2bits = int(sys.argv[1])
         L = 2**(pow2bits-1)
         U = 2**pow2bits
      except:
         flag_pow2bits = False
      else:
         flag_pow2bits = True
      #range
      try:
         L, U = str(sys.argv[1]).split(':')
         L = int(str(L), 16)
         U = int(str(U), 16)
         assert(len(sys.argv)>2)
         bitMin = 8
         bitMax = 256

L gets ADE6D7CE3B9B
U gets 22BD43C2E9354

what is he doing with these data from L to U, from smallest to largest steps or? how to convey this to him?

999999999999999999999999999999174176b015f4d99999999999999999999999
174176b015f4d111111111111111111111111111111111111111111111111111111111111111111 1111111111
232323232323174176b015f4d232323232323232323232323232323232323232323232323232323 232323232323232323232323232323
1111111111111111111111111111111111111111111111111111111111111111111111111111111 111111111111111174176b015f4d

SimpleMan

full member

Activity: 462

Merit: 100

The Standard Protocol - Solving Inflation

Quote from: CanalGanheAgora on May 10, 2021, 05:46:24 PM

Quote from: SimpleMan on May 10, 2021, 12:04:12 PM

This is what I call an interesting thread guys!

Tried to read upon it, is it a solvable puzzle after all? By now the 32 BTC are a juicy prize pool. What is the motivation for that person to do this? How did OP even notice this address cluster? By coincidence is OP involved?

it's very complicated if you don't have a state-of-the-art pc. because there is no standard for finding private keys. Only quantum computers will find these private keys difficult. Now if you know or guess where that private key is, you are too lucky.

But going over the discussion here I am of the impression that there is much more you need than just a state-of-the-art computer. Is this puzzle to be solved just based on luck or an element of luck or could it be solved based on pure logic?

CanalGanheAgora

newbie

Activity: 24

Merit: 0

Quote from: SimpleMan on May 10, 2021, 12:04:12 PM

This is what I call an interesting thread guys!

Tried to read upon it, is it a solvable puzzle after all? By now the 32 BTC are a juicy prize pool. What is the motivation for that person to do this? How did OP even notice this address cluster? By coincidence is OP involved?

it's very complicated if you don't have a state-of-the-art pc. because there is no standard for finding private keys. Only quantum computers will find these private keys difficult. Now if you know or guess where that private key is, you are too lucky.

SimpleMan

full member

Activity: 462

Merit: 100

The Standard Protocol - Solving Inflation

This is what I call an interesting thread guys!

Tried to read upon it, is it a solvable puzzle after all? By now the 32 BTC are a juicy prize pool. What is the motivation for that person to do this? How did OP even notice this address cluster? By coincidence is OP involved?

iparktur

jr. member

Activity: 119

Merit: 1

Tell me what parameters -b -t -p need to set when using an AMD Radeon HD 5670 AX5670 512MD5-HV2 video card ?

https://www.newegg.com/powercolor-radeon-hd-5670-ax5670-512md5-hv2/p/N82E16814131366

Processor - Athlon IIX3 455
RAM - 4 GB

MikeJ_NpC

member

Activity: 107

Merit: 10

if you want to lie *cough*use your data; not mine.

Quote from: itod on April 23, 2021, 05:53:46 AM

Quote from: fxsniper on April 21, 2021, 07:26:42 AM

Quote from: itod on March 10, 2021, 01:05:23 PM

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.

Can entropy formula use for calculate position zone of puzzle

No it can not. The random number generator gathers environmental noise from device drivers and other sources into an entropy pool. That's the beauty of the entropy pool, values are not calculated, instead they are measured, emulating what hardware random number generators do, best and expensive hardware generators measure radiation sources which are totally random. Since you do not hardware random generator in normal PC/server, usually temperature variations are used instead.

Question: That being said, it would be more feasible then to use older hardware 2012 2011 etc if you wallet was created during that time period? for the intention of duplicating entropy for recovery purposes? Ex if you used a laptop with a old chipset when the wallet was spawned...

zahid888

member

Activity: 272

Merit: 20

the right steps towerds the goal

Quote from: ttdclient on October 31, 2019, 12:39:55 AM

I have created a pool of sorts to collectively solve bit 64 of this challenge.

if you goto http://www.ttdsales.com/64bit/

create an account and you will get access to the user and stats page. From there you can download the client software.

It works with bitcrack and the server to hand out work and keep track of what has been checked.

Each range work load is 000000000 - FFFFFFFFF or 68,719,476,735 keys. I selected this range because it does not complete to quickly on top hardware and is still easily completed in less then an hour with slower GPUs.

8000000 - FFFFFFF is generated by the server randomly. There is a btc address I have generated for all 134,217,728 ranges in the DB. The private key for these addresses are used as proof of work for the range work loads. When the client software finishes a range and submits this proof the DB marks that range as checked and dispenses another. Before being dispensed the range is checked against the DB to ensure it hasn't already been checked. What I am calling a random collision.

All work completed is kept track of for each user and displayed on your user stats page.

If/when we find the solution the bitcoin stored in 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN will be split between the contributing users equally according to work completed just like a bitcoin mining pool would for a mined block. This percentage is displayed on your stats page.

Please check it out and pm me with any thoughts comments questions or ideas for improvements.

It is a work in progress but seems to be functioning nicely for my 6 machines that have been running on it for a couple of weeks now. Currently running ~1.37 Billion Keys /s.

forgot my password how can i reset ??

hector3115

sr. member

Activity: 481

Merit: 251

Puzzle has already been solved? I missed something?

Andzhig

jr. member

Activity: 184

Merit: 3

What's the difference that "real" random or "pseudo" random. We have a kind of space, in it we generate, using both options, a certain event, and with the help of "pseudo" finds the "real".

i.e we can generate a number in real random and the same number in pseudo.

and in pseudo we will have "collisions"

num seed("measure radiation sources which are totally random") "collisions" by 3 char

3056 yQL
3056 5G^
3056 Ctn
3056 jK?
3056 S%S
3056 CJn
3056 /'S
3056 61t
3056 wrF
3056 Okx
3056 WoR
3056 ]F4
3056 CJn
3056 u}r
3056 x9#
3056 b9i
3056 qn}
3056 ugA
3056 ?Ig
3056 &u3
3056 0}A
3056 jK?
3056 0}A
3056 "!x
3056 rkX
3056 X9[
3056 55^
3056 Z2!
3056 0A6
3056 n_3
3056 (U0
3056 Ctn
3056 Kpi
3056 =8+
3056 ]F4
3056 55^
3056 O^{
3056 (U0
3056 Kpi

8377 PW>
8377 pF|
8377 3/I
8377 jHk
8377 3s}
8377 ,<:
8377 b0G
8377 ^+.
8377 >[7
8377 (!7
8377 N4?
8377 b0G
8377 _R7
8377 1Pa
8377 wij
8377 4B*
8377 b0G
8377 W`v
8377 Io4
8377 L[3
8377 PW>
8377 wc1
8377 RP=
8377 W`v
8377 /(o
8377 pF|
8377 -wa
8377 JP}
8377 mW@
8377 _R7
8377 (!7
8377 1+$
8377 Qmu
8377 HP/
8377 _R7
8377 UW8
8377 >[7
8377 U2W

6420 4_6
6420 7T
6420 E6I
6420 E6I
6420 7T
6420 7T
6420 7T
6420 3*
6420 3*
6420 7T
6420 7T
6420 7T
6420 3*
6420 5^O
6420 I01
6420 7T
6420 '\S
6420 3*
6420 7T
6420 3*
6420 3*
6420 3*
6420 7T
6420 7T
6420 3*
6420 7T
6420 f?W

...

num seed("measure radiation sources which are totally random") "collisions" by 1-50 char

3056 +9+%y1m238cWRb
3056 u`zx5hgO52HMTLUlS_
3056 O*0LSW
3056 <|d4I
3056 M8S2G
3056 @D,9\2E32.}k?"\p!;
3056 =J-;D2:aX4IwfMN5]B,8
3056 74899
3056 4iu4xS1'EIdUy|m48)-3@F89LLY4AY|[86A7)v9P=D\ry`9P
3056 k@E}|k9XnN7~0K(n3[-Yt66Wm3gw2SrRxL&HtAl0+r87|!3
3056 +>/nd0A0
3056 {[d9;PpO1m>KY]lc90rN48vr907@F_/2"k^mc5^ch1
3056 y;K|Tjsnz3tKYXFuatC'v\/
3056 440:}y4O]h'KK}BZOKw\i
3056 !ZSErVZ)jeCq9OAu8P+DDXJ9dnWr2F3056 0VM6Afkk'R0XF7cBX8+f:M73[i60vM58(oAgr3
3056 Grin

.q1\=sA1L
3056 Ue0LmW[;A6m00i6;LRj5n
3056 ie:5/43+_/
3056 sq1U97[YERQ\
3056 Zxfd2

in theory similarly with numbers 20 or 78 char long, the initial seed stores an array of random values in which the necessary information can be stored.

pseudo random can get stuck in loop at some point, if you use a certain fixed set as a seed () (and it is everywhere fixed, limited by the space of variants itself).

start seed(1111)

1111 3687
3687 5408
5408 6768
6768 3663
3663 9841
9841 4593
4593 2664
2664 3544
3544 4666
4666 6069
6069 7019
7019 7381
7381 9704
9704 5495
5495 3537
3537 0840
0840 5315
5315 7494
7494 1889
1889 6495
6495 2306
2306 0337
0337 0981
0981 3281
3281 3511
3511 6235
6235 3114
3114 9156
9156 9867
9867 3874
3874 7752
7752 6478
6478 9261
9261 7371
7371 5657
5657 7662
7662 9752
9752 7758
7758 0428
0428 9241
9241 6936
6936 7151
7151 2138
2138 2882
2882 3756
3756 8676
8676 2114
2114 4581
4581 4618
4618 1431
1431 1593
1593 6252
6252 2462
2462 3909
3909 0385
0385 0957
0957 1402
1402 7685
7685 0899
0899 0886
0886 8089
8089 6396
6396 4208
4208 4361
4361 4427
4427 3326
3326 6209
6209 0664
0664 4198
4198 2647
2647 6211
6211 6244
6244 1207
1207 8078
8078 1664
1664 3348
3348 7657
7657 3726
3726 9817
9817 6785
6785 0264
0264 9566
9566 6500
6500 9746
9746 6421
6421 5063
5063 3254
3254 2861
2861 3986
3986 9690
9690 9446
9446 8452
8452 4265
4265 4502
4502 8415
8415 3946
3946 9498
9498 9603
9603 3799
3799 3431

start seed(11111)

11111 1750
1750 8638
8638 8652
8652 7331
7331 9122
9122 2471
2471 0793
0793 2033
2033 2331
2331 4310
4310 8877
8877 4807
4807 2783
2783 7012
7012 5607
5607 7770
7770 2494
2494 9092
9092 0649
0649 0512
0512 7351
7351 7859
7859 9155
9155 1976
1976 1402
1402 7685
7685 0899
0899 0886
0886 8089
8089 6396
6396 4208
4208 4361
4361 4427
4427 3326
3326 6209
6209 0664
0664 4198
4198 2647
2647 6211
6211 6244
6244 1207
1207 8078
8078 1664
1664 3348
3348 7657
7657 3726
3726 9817
9817 6785
6785 0264
0264 9566
9566 6500
6500 9746
9746 6421
6421 5063
5063 3254
3254 2861
2861 3986
3986 9690
9690 9446
9446 8452
8452 4265
4265 4502
4502 8415
8415 3946
3946 9498
9498 9603
9603 3799
3799 3431
3431 6074
6074 3060
3060 9250
9250 8841
8841 8577
8577 0202
0202 2892
2892 7744
7744 6297
6297 0171
0171 3155
3155 1237
1237 3533
3533 6677
6677 4221
4221 8616
8616 9186
9186 9651
9651 1317
1317 8216
8216 2377
2377 6311
6311 1042
1042 5695
5695 6150
6150 1506
1506 2577
2577 7291
7291 2327
2327 9056
9056 3531
3531 5244

does this mean that, for example, the desired number is 20 characters, will have a similar seed str "...1111..." and changing the length seed str "...1111..." 11111 111111 11111111 11111111111 we will get less time to find the 20 sign number.

crap find out after how many 20 digits are included in the loop.

for example 8 digits seed(32797908) > 27034054

32797908 27034054
27034054 70025271
70025271 64822558

...7289 steps

43728918 90501448
90501448 32797908
32797908 27034054

7289 steps loop.

***

kangaroo on python can play with seed()

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