Bitcoin puzzle transaction ~32 BTC prize to who solves it

[cookiebro]

A revised effort to consolidate our compute power by means of a pool:

https://discord.gg/YeUYPDUmVV

[wipall]

Is there a python code that proceeds sequentially with the binary number system and can specify the range, guys?

[cookiebro]

Is there a python code that proceeds sequentially with the binary number system and can specify the range, guys?

Why would you want the binary value over hex?

[wipall]

Is there a python code that proceeds sequentially with the binary number system and can specify the range, guys?

Why would you want the binary value over hex?

I think the scanning process will be faster.

[itod]

Is there a python code that proceeds sequentially with the binary number system and can specify the range, guys?

Why would you want the binary value over hex?

I think the scanning process will be faster.

No it won't, python interpreter represents these numbers in the exact same way.

[wipall]

Is there a python code that proceeds sequentially with the binary number system and can specify the range, guys?

Why would you want the binary value over hex?

I think the scanning process will be faster.

No it won't, python interpreter represents these numbers in the exact same way.

arrow. So do you have a python code that I can scan in order? a sequential code where I can specify the scan interval.

[Jolly Jocker]

A fast scanner that completely covers the 64-bit range with more than 12000 keys/s (depending on the CPU clock) with Intel Xeon E3-1240 V2 @ 3.40GHz (13500 keys/s)

Code:

import sys
import random
from bit import *
from time import sleep
from tqdm import tqdm
print('\n              ================16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN============== \n\n')
x=1048576
list=[]
print(' WAIT!....', end='\r')
while x:
    b01 = random.choice("0123456789abcdef")
    b02 = random.choice("0123456789abcdef")
    b03 = random.choice("0123456789abcdef")
    b04 = random.choice("0123456789abcdef")
    b05 = random.choice("0123456789abcdef")
    b06 = random.choice("0123456789abcdef")
    b07 = random.choice("0123456789abcdef")
    b08 = random.choice("0123456789abcdef")
    b09 = random.choice("0123456789abcdef")
    b10 = random.choice("0123456789abcdef")
    b11 = random.choice("0123456789abcdef")
    b12 = random.choice("0123456789abcdef")
    b13 = random.choice("0123456789abcdef")
    b14 = random.choice("0123456789abcdef")
    b15 = random.choice("0123456789abcdef")
    
    hex = (b01+b02+b03+b04+b05+b06+b07+b08+b09+b10+b11+b12+b13+b14+b15)
    hex8 = '8'+ hex
    list.append(hex8)
    hex9 = '9'+ hex
    list.append(hex9)
    hexa = 'a'+ hex
    list.append(hexa)
    hexb = 'b'+ hex
    list.append(hexb)
    hexc = 'c'+ hex
    list.append(hexc)
    hexd = 'd'+ hex
    list.append(hexd)
    hexe = 'e'+ hex
    list.append(hexe)
    hexf = 'f'+ hex
    list.append(hexf)
    if len(list)==x:    
        line_count=0
        for line0 in tqdm(list):
            line0!='\n'             
            line_count+=1
            line = int(line0, 16)
            a = len(bin(line))-2
            key = Key.from_int(line)
            addr = key.address                                       
         #  sys.stdout.write('\r scanning.... [' + (line0) + '] ' + str(a) + ' bit ')
                        
            if addr.startswith('16jY7'): # 16jY7q
                sys.stdout.write('\n\n ' + line0 + ' | ' + addr)
                sleep(1)
                sys.stdout.write('\n\n continue...\n\n')
                sleep(1)

            if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
                print('\n\n Target found!!' + line0 + ' \n ' + addr,'\n')
                file=open(u"16j.Target.Info.txt","a")
                file.write('\n ' + line0 + '| ' + addr)
                file.close()
                sleep(2)
                wait = input("Press Enter to Exit.")
                sleep(1)
                exit()
                
            if line_count==x:
                list.clear()
                
    if len(list)==0:
        print('\n WAIT!....\n')

[Andzhig]

faster "bit" there is a library from "ice" https://github.com/iceland2k14/secp256k1 there it is necessary to throw its libraries into the folder with the script.

***

and read (with a translator) https://istina.msu.ru/profile/FilatovOV/ , https://vk.com/@fil_post-eta-statya-rvet-vse-predstavleniya-o-veroyatnostyah , https://disk.yandex.ru/i/LsEWmhs3ArM7Tw

This article breaks all ideas about probabilities.

Everyone knows that it is impossible to guess the sides of a coin, but this article will show a mechanism that allows you to predict the sides of a coin, that is, you can actually guess. First, I will briefly describe the traditional way of working with probabilities, working in this way does not allow you to predict the sides of the coin. And then, in the same terse way, I will describe the way I discovered to work with probability, which allows you to predict the loss of the sides of the coin.

And so, the coin was tossed many times N and the result of its loss formed a sequence of ones and zeros. Let's determine the average length of a drop-down series of repeating identical events, for example: "00000.." or "11111.." in our large series of N flips.

It is described here: how to look at a random sequence so that the probabilities of guessing and not guessing are equal.

The traditional way to determine the average length of outliers from repeating identical events is to sequentially look through all the recorded values ​​and accurately count the number of runs of detected lengths.

The total number of series of unit lengths: "0" and "1" will be N/4. The total number of series of length two: "00" and "11" will be N/8. The total number of series of length three: "000" and "111" will be N/16. The total number of series of length four: "0000" and "1111" will be N/32. Etc. Of course, the detected numbers of series are unlikely to be exactly equal to the calculated values, since, despite the frequency stability, there are still random probabilistic fluctuations in the actual number of events around the theoretically obtained mats.expectations. Taking into account all elementary events N of our sequence, we find that the total number of all our series ("0" + "1" + "00" + "11" + "000" + "111" + ...) is equal to N / 2 (again up to random fluctuations). Now let's solve the problem: to determine the average length of the drop-down series, for this we need to divide the number of members of the sequence N by the sum of all series N / 2. Divide N / (N/2) = 2. That is, we found that the average length of a series with the traditional way of looking at and guessing the sides of a coin is two. That is, with an average length of a consecutive series of two events, it is impossible to guess the fallout of the sides. Obviously, if the average length of a consecutive series ("0"; "1"; "00"; "11"; "000"; "111"; ...) were three events, then we would begin to guess the fallout of the sides of the coin much more often than not guessing. Let's now look at my way of getting the average event length, which is three.

It describes how to look at a random sequence so that the probabilities of guessing and not guessing become different.

In order to influence the probability, it is necessary to change the average length of a series of events falling out in a row. This is achieved by applying a well-known geometric probability to the guessing process.
The principle of geometric probability states that objects with a larger size are hit more often than objects with a smaller size. With regard to our random sequence N, this means that if we count, for example, every hundredth member of the sequence and determine the length of the series ("0"; "1"; "00"; "11"; "000"; "111"; ... ) to which it belongs, it turns out that the frequency of hits of every hundredth event in long series increased, and decreased in short series.

That is, the average length of the detected series, in the case of a geometric set of statistics, will become equal to three. And it is precisely this increase in the average length of a series from two events (with sequential counting of each event) to three events (with gaps of sufficient length between guesses) that makes it possible to guess the side of the dropped coin more often than in half of the predictions. Here, now, I have described the fundamental principle of geometric probability, in relation to changing the average length of the found series in a random binary sequence.

he has studies of random events, sequences, there are formulas, I still don’t understand everything, he launches a probe there into a file with 20000000 random bits and...

pz64 ripmd160 hex to bin 1111101110010000010011001111011001100100011111010100101111110111110110101000100 1011100100110000011010011100000011101000101101011000111010000100100100010100100

11111 0 111 00 1 00000 1 00 11 00 1111 0 11 00 11 00 1 000 11111 0 1 0 1 00 1 0 111111 0 11111 0 11 0 1 0 1 000 1 00 1 0 111 00 1 00 11 00000 11 0 1 00 111 000000 111 0 1 000 1 0 11 0 1 0 11 000 111 0 1 0000 1 00 1 00 1 000 1 0 1 00 1 00

1       22
11      8
111     5
1111    1
11111   3
111111  1
1111111
11111111

0       17
00      14
000     5
0000    1
00000   2
000000  1
0000000
00000000

0, 1 - elementary events, they make waves 111 000 1111 0000... when nearby the same half-wavelength 111000 11110000...  

In order to influence the probability, it is necessary to change the average length of a series of events falling out in a row. This is achieved by applying a well-known geometric probability to the guessing process.
The principle of geometric probability states that objects with a larger size are hit more often than objects with a smaller size. With regard to our random sequence N, this means that if we count, for example, every hundredth member of the sequence and determine the length of the series ("0"; "1"; "00"; "11"; "000"; "111"; ... ) to which it belongs, it turns out that the frequency of hits of every hundredth event in long series increased, and decreased in short series.

what does this mean? we can run over the 2^256 range and generate these bit sets over several hashes...

[Jolly Jocker]

with "ice" to address.. 42500 keys/s ... nice one!!


              ================16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN==============


 11%|██████                                            | 115508/1048576 [00:02<00:21, 42521.10it/s]



I will work on it to make it faster...I will see the 3.5 Million Keys/s Speed... in combination with such scanners..


"[faster "bit" there is a library from "ice" https://github.com/iceland2k14/secp256k1 there it is necessary to throw its libraries into the folder with the script.]"

Code:

import sys
import random
import secp256k1 as ice
from time import sleep
from tqdm import tqdm
print('\n              ================16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN============== \n\n')
x=1048576
list=[]
print(' WAIT!....', end='\r')
while x:
    b01 = random.choice("0123456789abcdef")
    b02 = random.choice("0123456789abcdef")
    b03 = random.choice("0123456789abcdef")
    b04 = random.choice("0123456789abcdef")
    b05 = random.choice("0123456789abcdef")
    b06 = random.choice("0123456789abcdef")
    b07 = random.choice("0123456789abcdef")
    b08 = random.choice("0123456789abcdef")
    b09 = random.choice("0123456789abcdef")
    b10 = random.choice("0123456789abcdef")
    b11 = random.choice("0123456789abcdef")
    b12 = random.choice("0123456789abcdef")
    b13 = random.choice("0123456789abcdef")
    b14 = random.choice("0123456789abcdef")
    b15 = random.choice("0123456789abcdef")
    
    hex = (b01+b02+b03+b04+b05+b06+b07+b08+b09+b10+b11+b12+b13+b14+b15)
    hex8 = '8'+ hex
    list.append(hex8)
    hex9 = '9'+ hex
    list.append(hex9)
    hexa = 'a'+ hex
    list.append(hexa)
    hexb = 'b'+ hex
    list.append(hexb)
    hexc = 'c'+ hex
    list.append(hexc)
    hexd = 'd'+ hex
    list.append(hexd)
    hexe = 'e'+ hex
    list.append(hexe)
    hexf = 'f'+ hex
    list.append(hexf)
    if len(list)==x:    
        line_count=0
        for line0 in tqdm(list):
            line0!='\n'             
            line_count+=1
         #  line = int(line0, 16)
         #  a = len(bin(line))-2
            addr = ice.privatekey_to_address(0, True, int(line0, 16))                               
         #  sys.stdout.write('\r scanning.... [' + (line0) + '] ' + str(a) + ' bit ')
                        
            if addr.startswith('16jY7'): # 16jY7q
                sys.stdout.write('\n\n ' + line0 + ' | ' + addr)
                sleep(1)
                sys.stdout.write('\n\n continue...\n\n')
                sleep(1)

            if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
                print('\n\n Target found!!' + line0 + ' \n ' + addr,'\n')
                file=open(u"16j.Target.Info.txt","a")
                file.write('\n ' + line0 + '| ' + addr)
                file.close()
                sleep(2)
                wait = input("Press Enter to Exit.")
                sleep(1)
                exit()
                
            if line_count==x:
                list.clear()
                
    if len(list)==0:
        print('\n WAIT!....\n')

[dextronomous]

whats the ice jolly jocker. paste code pls

[jeniferangel79]

How about you ask Robert Langdon, I heard he is very great at something like this Well the arrangement doesn't sound good to me at this point yet will attempt with it somewhat more later. Regardless, I don't figure somebody will give out 32 BTC just to address some riddle... there should be something different that we don't have the foggiest idea or can't see.
Sherlock to protect perhaps?

[Jolly Jocker]

jeniferangel79,

take a look at when the puzzle is from and what the BTC was worth at that time... surely there is a reason, security plays a big role in the crypto universe... and see what and how far the programmers get solving the puzzle is certainly an interesting aspect for future crypto projects... ^^

[Jolly Jocker]

Code:

import sys
import time
import random
#from tqdm import tqdm
from time import sleep
import secp256k1 as ice

print('\n      B I N A R Y   S E E D   S C A N   Q U A D R O   \n')
print(' 11_________________0____________________________________________\n')
x=16000
y=131071
list=[]
x0=0b100000000000000000000000000000000000000000000
for n in range(y):
    x1 = (x0+n)
    a1 = bin(random.randrange(131072,262143))#[2:].zfill(18)
    a1 = (a1)[2:]
    for i in range(x):
        a0 = str("1")            
        a2 = str("0")
        a3 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111)) 
        a3 = (a3)[3:]#.zfill(44)
        a4 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111)) 
        a4 = (a4)[3:]#.zfill(44)
        a5 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111)) 
        a5 = (a5)[3:]#.zfill(44)
        a6 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111)) 
        a6 = (a6)[3:]#.zfill(44)
        binb = "".join(a0+a1+a2+a3)
        binc = "".join(a0+a1+a2+a4)
        bind = "".join(a0+a1+a2+a5)
        bine = "".join(a0+a1+a2+a6)
        list.append(binb)
        list.append(binc)
        list.append(bind)
        list.append(bine)
        if len(list)==x:
            line_count=0
            for bina in (list):
                bina!='\n'
                addr = ice.privatekey_to_address(0, True, int(bina,2))
                line_count+=1
                                 
                if addr.startswith('16jY7'): # 16jY7
                    ran = int(bina,2)
                    print('',bina, '\n')
                    sys.stdout.write('\r ' + hex(ran))
                    sys.stdout.write(' ' + '| ' + addr + ' ' + str(n))
                    sleep(1)
                    sys.stdout.write('\n\n continue...\n\n')
                    sleep(1)

                if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
                    ran = int(bina,2)
                    print('\n\n Target found!!' + hex(ran) + ' \n ' + addr,'\n')
                    file=open(u"16j.Target.Info.txt","a")
                    file.write('\n ' + hex(ran) + ' | ' + addr)
                    file.close()
                    sleep(2)
                    wait = input("Press Enter to Exit.")
                    sleep(1)
                    exit()
                    
                if line_count==x:
                    list.clear()
                    
        if len(list)==0:
            print(' scan... ', str(n), end='\r')                        

Ca 42000 keys/s from c000000000000000 to ffffffffffffffff... The sector between  11_________________0 comprise a range of 131071 and will be processed.
The rest of this line are random numbers from 4 different generators..
The counter reflects the number of loops...

      B I N A R Y   S E E D   S C A N   Q U A D R O

 11_________________0____________________________________________

 1110010110110011011010011110001111111110100110111011100101000111

 0xe5b369e3fe9bb947 | 16jY7mM6wrpuAy53vKkh7QXm1JNdWK9Myu 19

 continue...

 1110010011000111001010001111000110100111001000001001110001000100

 0xe4c728f1a7209c44 | 16jY7Ezk5et98CVBWYEigGRwWovzhEtaQ3 121

 continue...

 scan...  192

[wipall]

Code:

import sys
import time
import random
#from tqdm import tqdm
from time import sleep
import secp256k1 as ice

print('\n      B I N A R Y   S E E D   S C A N   Q U A D R O   \n')
print(' 11_________________0____________________________________________\n')
x=16000
y=131071
list=[]
x0=0b100000000000000000000000000000000000000000000
for n in range(y):
    x1 = (x0+n)
    a1 = bin(random.randrange(131072,262143))#[2:].zfill(18)
    a1 = (a1)[2:]
    for i in range(x):
        a0 = str("1")            
        a2 = str("0")
        a3 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111)) 
        a3 = (a3)[3:]#.zfill(44)
        a4 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111)) 
        a4 = (a4)[3:]#.zfill(44)
        a5 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111)) 
        a5 = (a5)[3:]#.zfill(44)
        a6 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111)) 
        a6 = (a6)[3:]#.zfill(44)
        binb = "".join(a0+a1+a2+a3)
        binc = "".join(a0+a1+a2+a4)
        bind = "".join(a0+a1+a2+a5)
        bine = "".join(a0+a1+a2+a6)
        list.append(binb)
        list.append(binc)
        list.append(bind)
        list.append(bine)
        if len(list)==x:
            line_count=0
            for bina in (list):
                bina!='\n'
                addr = ice.privatekey_to_address(0, True, int(bina,2))
                line_count+=1
                                 
                if addr.startswith('16jY7'): # 16jY7
                    ran = int(bina,2)
                    print('',bina, '\n')
                    sys.stdout.write('\r ' + hex(ran))
                    sys.stdout.write(' ' + '| ' + addr + ' ' + str(n))
                    sleep(1)
                    sys.stdout.write('\n\n continue...\n\n')
                    sleep(1)

                if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
                    ran = int(bina,2)
                    print('\n\n Target found!!' + hex(ran) + ' \n ' + addr,'\n')
                    file=open(u"16j.Target.Info.txt","a")
                    file.write('\n ' + hex(ran) + ' | ' + addr)
                    file.close()
                    sleep(2)
                    wait = input("Press Enter to Exit.")
                    sleep(1)
                    exit()
                    
                if line_count==x:
                    list.clear()
                    
        if len(list)==0:
            print(' scan... ', str(n), end='\r')                        

Ca 42000 keys/s from c000000000000000 to ffffffffffffffff... The sector between  11_________________0 comprise a range of 131071 and will be processed.
The rest of this line are random numbers from 4 different generators..
The counter reflects the number of loops...

      B I N A R Y   S E E D   S C A N   Q U A D R O

 11_________________0____________________________________________

 1110010110110011011010011110001111111110100110111011100101000111

 0xe5b369e3fe9bb947 | 16jY7mM6wrpuAy53vKkh7QXm1JNdWK9Myu 19

 continue...

 1110010011000111001010001111000110100111001000001001110001000100

 0xe4c728f1a7209c44 | 16jY7Ezk5et98CVBWYEigGRwWovzhEtaQ3 121

 continue...

 scan...  192

B I N A R Y   S E E D   S C A N   Q U A D R O   

 11_________________0____________________________________________

Traceback (most recent call last):
  File "11.py", line 41, in <module>
    addr = ice.privatekey_to_address(0, True, int(bina,2))
AttributeError: module 'secp256k1' has no attribute 'privatekey_to_address'

[Jolly Jocker]

Code:

import sys
import time
import random
#from tqdm import tqdm
from time import sleep
import secp256k1 as ice

print('\n      B I N A R Y   S E E D   S C A N   Q U A D R O   \n')
print(' 11_________________0____________________________________________\n')
x=16000
y=131071
list=[]
x0=0b100000000000000000000000000000000000000000000
for n in range(y):
    x1 = (x0+n)
    a1 = bin(random.randrange(131072,262143))#[2:].zfill(18)
    a1 = (a1)[2:]
    for i in range(x):
        a0 = str("1")            
        a2 = str("0")
        a3 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111)) 
        a3 = (a3)[3:]#.zfill(44)
        a4 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111)) 
        a4 = (a4)[3:]#.zfill(44)
        a5 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111)) 
        a5 = (a5)[3:]#.zfill(44)
        a6 = bin(random.randrange(x1,0b111111111111111111111111111111111111111111111)) 
        a6 = (a6)[3:]#.zfill(44)
        binb = "".join(a0+a1+a2+a3)
        binc = "".join(a0+a1+a2+a4)
        bind = "".join(a0+a1+a2+a5)
        bine = "".join(a0+a1+a2+a6)
        list.append(binb)
        list.append(binc)
        list.append(bind)
        list.append(bine)
        if len(list)==x:
            line_count=0
            for bina in (list):
                bina!='\n'
                addr = ice.privatekey_to_address(0, True, int(bina,2))
                line_count+=1
                                 
                if addr.startswith('16jY7'): # 16jY7
                    ran = int(bina,2)
                    print('',bina, '\n')
                    sys.stdout.write('\r ' + hex(ran))
                    sys.stdout.write(' ' + '| ' + addr + ' ' + str(n))
                    sleep(1)
                    sys.stdout.write('\n\n continue...\n\n')
                    sleep(1)

                if addr == "16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN":
                    ran = int(bina,2)
                    print('\n\n Target found!!' + hex(ran) + ' \n ' + addr,'\n')
                    file=open(u"16j.Target.Info.txt","a")
                    file.write('\n ' + hex(ran) + ' | ' + addr)
                    file.close()
                    sleep(2)
                    wait = input("Press Enter to Exit.")
                    sleep(1)
                    exit()
                    
                if line_count==x:
                    list.clear()
                    
        if len(list)==0:
            print(' scan... ', str(n), end='\r')                        

Ca 42000 keys/s from c000000000000000 to ffffffffffffffff... The sector between  11_________________0 comprise a range of 131071 and will be processed.
The rest of this line are random numbers from 4 different generators..
The counter reflects the number of loops...

      B I N A R Y   S E E D   S C A N   Q U A D R O

 11_________________0____________________________________________

 1110010110110011011010011110001111111110100110111011100101000111

 0xe5b369e3fe9bb947 | 16jY7mM6wrpuAy53vKkh7QXm1JNdWK9Myu 19

 continue...

 1110010011000111001010001111000110100111001000001001110001000100

 0xe4c728f1a7209c44 | 16jY7Ezk5et98CVBWYEigGRwWovzhEtaQ3 121

 continue...

 scan...  192

B I N A R Y   S E E D   S C A N   Q U A D R O   

 11_________________0____________________________________________

Traceback (most recent call last):
  File "11.py", line 41, in <module>
    addr = ice.privatekey_to_address(0, True, int(bina,2))
AttributeError: module 'secp256k1' has no attribute 'privatekey_to_address'

You must use this https://github.com/iceland2k14/secp256k1 for my code.....

[Jolly Jocker]

I have revised this code for 64 bit, this code changes the starting point every 1000000 counters..
the problem in this code, is the truncation of the "zeros" what causes the skipping...it has pros and cons...
the advantage is that you can use it as a filter, the average of the zeros for the address you are looking for is between 22 and 43...

!! zeros = bina.count("100") .. this function only counts the zeros in binary code!!! also zeros = bina.count("0") or you count the ones ... ones = bina.count("1") !!

It's important to understand the functions so that you know what the code does and you can make conscious changes that work...

Code:

from bit import *
import random
from time import sleep

count=0

while True:
    a = random.randint(2**63, 2**64)
 #  while a <= 2**64:
    for x in range(1000000):
        x = x
        bina = bin(a)[2:]
        zeros = bina.count("0")
     #  if x in range(1):
        if x == 0:
            print(" !!!NEW LOOP!!!")
            sleep(2)
        if zeros >= 1:     # "00000000000000000000000000000011111111111111111111111111"
            if zeros <= 63: # "00000000000000000000000000000011111111111111111111111111"
                key = Key.from_int(a)
                addr = key.address
                count+=1
                print (hex(a), bina, zeros, str(count))
                
                if addr.startswith('16jY7qLJnxb'):
                    print(' '+hex(a)+'|'+ addr)
                    file=open(u"16jY.Info.txt","a")
                    file.write('\n '+hex(a)+' | '+ addr)
                    file.close()
                    sleep(3)
                    wait = input("Press Enter to continue.")
                    print(" continue...")
                    sleep(1)
             #  else:
             #      print (' Scan Nr.: ', str(count), end='\r') #pass
        a = a +1
    pass

[nilasahap]

My remark about you taking my Bitcoins was a joke. You can't take them for the numerical reasons I gave. The best way to get the following prize is to beast force search the scope of the prize. You are right that others with a lot quicker equipment will presumably beat you to the prize.There has been a ton of exertion on this string where individuals attempt to "work out" (all in all conjecture) the normal sub-range withing the following prize reach.

You could look through their speculation at the normal sub-range however again without quicker equipment you will most likely not win the following prize.
You could attempt to look through arbitrarily in the following reach (or their speculation at the normal sub-range). You will presumably still lose yet hello, you could actually luck out.

[wipall]

I have revised this code for 64 bit, this code changes the starting point every 1000000 counters..
the problem in this code, is the truncation of the "zeros" what causes the skipping...it has pros and cons...
the advantage is that you can use it as a filter, the average of the zeros for the address you are looking for is between 22 and 43...

!! zeros = bina.count("100") .. this function only counts the zeros in binary code!!! also zeros = bina.count("0") or you count the ones ... ones = bina.count("1") !!

It's important to understand the functions so that you know what the code does and you can make conscious changes that work...

Code:

from bit import *
import random
from time import sleep

count=0

while True:
    a = random.randint(2**63, 2**64)
 #  while a <= 2**64:
    for x in range(1000000):
        x = x
        bina = bin(a)[2:]
        zeros = bina.count("0")
     #  if x in range(1):
        if x == 0:
            print(" !!!NEW LOOP!!!")
            sleep(2)
        if zeros >= 1:     # "00000000000000000000000000000011111111111111111111111111"
            if zeros <= 63: # "00000000000000000000000000000011111111111111111111111111"
                key = Key.from_int(a)
                addr = key.address
                count+=1
                print (hex(a), bina, zeros, str(count))
                
                if addr.startswith('16jY7qLJnxb'):
                    print(' '+hex(a)+'|'+ addr)
                    file=open(u"16jY.Info.txt","a")
                    file.write('\n '+hex(a)+' | '+ addr)
                    file.close()
                    sleep(3)
                    wait = input("Press Enter to continue.")
                    print(" continue...")
                    sleep(1)
             #  else:
             #      print (' Scan Nr.: ', str(count), end='\r') #pass
        a = a +1
    pass

Thank you very much for your attention, my friend.

[Jolly Jocker]

I have revised this code for 64 bit, this code changes the starting point every 1000000 counters..
the problem in this code, is the truncation of the "zeros" what causes the skipping...it has pros and cons...
the advantage is that you can use it as a filter, the average of the zeros for the address you are looking for is between 22 and 43...

!! zeros = bina.count("100") .. this function only counts the zeros in binary code!!! also zeros = bina.count("0") or you count the ones ... ones = bina.count("1") !!

It's important to understand the functions so that you know what the code does and you can make conscious changes that work...

Code:

from bit import *
import random
from time import sleep

count=0

while True:
    a = random.randint(2**63, 2**64)
 #  while a <= 2**64:
    for x in range(1000000):
        x = x
        bina = bin(a)[2:]
        zeros = bina.count("0")
     #  if x in range(1):
        if x == 0:
            print(" !!!NEW LOOP!!!")
            sleep(2)
        if zeros >= 1:     # "00000000000000000000000000000011111111111111111111111111"
            if zeros <= 63: # "00000000000000000000000000000011111111111111111111111111"
                key = Key.from_int(a)
                addr = key.address
                count+=1
                print (hex(a), bina, zeros, str(count))
                
                if addr.startswith('16jY7qLJnxb'):
                    print(' '+hex(a)+'|'+ addr)
                    file=open(u"16jY.Info.txt","a")
                    file.write('\n '+hex(a)+' | '+ addr)
                    file.close()
                    sleep(3)
                    wait = input("Press Enter to continue.")
                    print(" continue...")
                    sleep(1)
             #  else:
             #      print (' Scan Nr.: ', str(count), end='\r') #pass
        a = a +1
    pass

Thank you very much for your attention, my friend.

always a pleasure dude!!

[heribertoX]

  saludos alguien me podria facilitar el instalador de BitCrack para windows 7 64 bites por favor.