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

bikkesbakker

newbie

Activity: 4

Merit: 0

Quote from: BitDominator00 on April 13, 2022, 02:21:43 AM

Quote from: bikkesbakker on April 12, 2022, 10:42:52 PM

Quote from: zahid888 on April 11, 2022, 09:59:09 PM

https://i.imgur.com/VGuN8R1.png

I was checking exatly the same the other day, hi everyone im new into this puzzle, and im obsessed with it. Spend hours and hours looking for a pattern, and there is no pattern as the "owner" mentioned it but i was looking for the already found keys and i think i found something.

If someone is brute forcing this, you need to start from eb851eb851eb8000 to ffffffffffffffff, thats why this is not still be found, the hex is almost at the end of the range. Im bruteforcing this from feb851eb851eb800 to ffffffffffffffff at 25 MKey/s (yes is a little slow but is honest work Tongue

) and i will be checking from the back after finish a range.

I hope this helps anyone, and if i do please share something as i will share to 2 users of this forum (if i find the key) who gives me the idea

Regards from AR and sorry about my english.

based on what you say to start from that point of the range ?

so i was right, and i think where to start from for puzzle 66, i think i found a pattern. Ive also got a 1080 at a good price so im searching at 240 MKeys/s

zahid888

member

Activity: 275

Merit: 20

the right steps towerds the goal

Quote from: zahid888 on July 25, 2021, 04:21:39 AM

@Andzhig And if we increase one more character of address 16jY7qLJn & 'x' then most binaries are started from '111'

few examples -

16jY7qLJnxLQQRYPX5BLuCtcBs6tvXz8BE   1110000000100110101001101101010100100011010011001000100000110110000   7013536A91A6441B0
16jY7qLJnX9uchnyf26t3QJnsUf78Xdikb   1110010000101000111010000001111110010000001011001101111011100000   E428E81F902CDEE0
16jY7qLJnX9eX8j612s8fnbn6uzR48xjua   1110100000001101111010110011001110101001011001111010000010001111   E80DEB33A967A08F
16jY7qLJnx2EZZumnYFke3GutCrRnHKs1M   111010110100110101001101101010111010101000110011101011001010110000   3AD3536AEA8CEB2B0
16jY7qLJnx2ixrxCnTLSraerkgyB3YYAiT   1110110111111001110011010110000000110101011011011100110000011001   EDF9CD60356DCC19
16jY7qLJnxHBp3dqwV2kzYq1LucfZzgxsH   1110111010111001101010110011001101001101111100100111011100001101   EEB9AB334DF2770D
16jY7qLJnX2cZXJ78wV1ef42e7cLAZJ1Vn   1111111000101000011001011100011011011011111111101100001110000011   FE2865C6DBFEC383
16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN   1111011100000101000111110010011110110000100100010001001011010100 F7051F27B09112D4

Could this also be some logic?

can you shed more light on this issue

Evillo

member

Activity: 185

Merit: 15

Two things you should never abandon: Family & BTC

Quote from: james5000 on January 11, 2023, 10:36:14 AM

https://github.com/Jamerson1000/btc-puzzle Wink

Can i ask what did you mean by "bitcrack doesn't work when workspace is larger than 999.999" ?

Feron

jr. member

Activity: 67

Merit: 1

120 scan delete print for run 10% speed increase

Code:

from timeit import default_timer as timer
import secp256k1 as ice
import random
while True:
 stackk = 1000000
 target = "02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630"
 number = round(random.getrandbits(120)/stackk)
 public = (ice.scalar_multiplication(number*stackk))
 startt = timer()
 checkk = (ice.point_sequential_increment(stackk,public)).hex()
 if target[2:66] in checkk:
  f=open("results.txt","a")
  f.write(str(target[2:66])+"-start number for key "+str(number)+"\n")
  f.close()
 print('Key/s: ' + str(stackk/(timer()-startt))[:7]  + ' Time:' + str(timer()-startt)[:3]+' start number for key:'+str(number))

james5000

jr. member

Activity: 69

Merit: 2

https://github.com/Jamerson1000/btc-puzzle Wink

Feron

jr. member

Activity: 67

Merit: 1

Quote from: The_Prof on January 08, 2023, 03:30:57 AM

Quote from: ?? on ??

It is slow compared to ICE secp256k1. Twice the speed...However, I am currently creating a script that will be Full ICE - to search for lost parts of the private key. About 2 million per second per CPU thread.. Grin

I would love to see your 2 mil/sec as I am stuck on 500k/s with ice. Would be interested to see which route you went.

Edit: 2 mil+... CPU dependent. But that is on a public key hunt. So for those who want to try their luck.... It's set for 120 bit key...I guess if you link enough machines with enough CPU's you may hit in a few hundred years.

Code:

import secp256k1 as ice
from timeit import default_timer as timer
import random
import multiprocessing

cores = 1
perRound = 1000000
bitRange = 120
target_Key = '02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630'
    
def new_Number():
    doneSet = set()
    rotate = True
    with open("120-Nums.txt", "r+") as textfile:  
        for checking in textfile: doneSet.add(str(checking.replace("\n","").replace(",", "")))
        while rotate != False:
            number = round(random.randint(2**(bitRange-1),2**bitRange)/perRound)
            if str(number) not in doneSet:
                rotate = False
                textfile.write(str(number) + "\n") 
            if str(number) in doneSet:
                print('Collision')
    textfile.close()
    return number

def seek(r,cores):
    startStart = timer()
    dog = False
    while dog != True:
        number = new_Number()
        p = (ice.scalar_multiplication(number*perRound))
        start = timer()
        check = str((ice.point_sequential_increment(perRound, p)).hex())
        if target_Key[5:25] in check:
            print('Success: ' + str(number))
            print('Test Run Time Length: ' + str((timer()-startStart))[:6])
            with open("results.txt", "a") as completed:
                completed.write(str(p) + '   ' + str(number)) 
            completed.close()
            dog = True
        else:
            print('Core: ' + str(r) + '   Key/s: ' + str(perRound/(timer()-start))[:10]  + '   Time: ' + str(timer()-start)[:6] + '   RandInt: ' + str(number))

if __name__ == '__main__':
    jobs = []
    for r in range(cores):
        p = multiprocessing.Process(target=seek, args=(r,cores))
        jobs.append(p)
        p.start()

I tried your code with fastrand but the speed is similar

Code:

from timeit import default_timer as timer
import secp256k1 as ice
import fastrand
#import random
perRound = 1000000
target_Key = '031a864bae3922f351f1b57cfdd827c25b7e093cb9c88a72c1cd893d9f90f44ece'
#donset = set()
#number = round(fastrand.pcg32bounded(134217727)/perRound)
dog = False
while dog != True:
 number = round(fastrand.pcg32bounded(134217727)/perRound)
 #if str(dog) in str(dog):
  #ke = ice.privatekey_loop_h160(0,0,True,number).hex()
 public = (ice.scalar_multiplication(number*perRound))
 checkk = (ice.point_sequential_increment(perRound,public)).hex()
 start = timer()
 if target_Key[2:66] in checkk:
 #if "0c7aaf6caa7e5424b63d317f0f8f1f9fa40d5560" in (ke):
  f=open("result.txt","a")
  f.write(str(target_Key[2:66])+"-start number for key "+str(number)+"\n")
  #f.write(str(ke)+"-"+str(number)+"\n")
  f.close()
  #dog = True
 else:
  print('Key/s: ' + str(perRound/(timer()-start))[:7]  + '   Time: ' + str(timer()-start)[:3] + '   start number for key: ' + str(number))

27 puzzle address is collision test

JamesH1453

newbie

Activity: 1

Merit: 0

Quote from: ?? on ??

Quote from: VinIVaderr on October 25, 2022, 03:30:41 PM

I cannot get your @jolly_jocker code to run correctly.

However, I think what you are trying to achieve is using the known WIF key part and tumble searching the remaining characters to find the WIF private key. I am able to again, use the known key part and add a randomize search for the remaining part and output this in hexadecimal format. It is not any faster than a general hexadecimal search.

I am not sure if you can generate a WIF private key with a check sum and convert/compare ; and then print the WIF key again in the same script.
I do agree that this puzzle is about testing the strength and secure-ness of bitcoin with new, creative code.

This is a basic python script and variation of VanityGen:

Code:

import secrets
import base58
import binascii
from bitcoin import privtopub, pubtoaddr
import sys

vanity = "13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so"
btc_addr = ""

while btc_addr[:len(vanity)] != vanity:
    prefix = "KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qa"
    alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
    postfix = ''.join(secrets.choice(alphabet) for i in range(18))
    first_encode = base58.b58decode(prefix + postfix)
    private_key_full = binascii.hexlify(first_encode)
    private_key = private_key_full[2:-8]
    btc_pubkey = privtopub(private_key.decode())
    btc_addr = pubtoaddr(btc_pubkey)
    
print(private_key.decode())
print(btc_pubkey)
print(btc_addr)

sys.exit()

Hello, Thanks for all your posts !
I modified your script a little, so that it loads the database of all BTC addresses plus searches for puzzle patterns at the same time. Grin

Code:

import os
import time
import secrets
import base58
import binascii
from bitcoin import privtopub, pubtoaddr
import sys
import multiprocessing
from halo import Halo
import random, string
import threading

print("Loading TXT Please Wait and Good Luck...")  
filename ='list.txt'
with open(filename) as f:
    add = f.read().split()
add = set(add)

spinner = Halo(text='Loading', spinner='dots')

r = 0
cores=1 #CPU Control Set Cores
def seek(r):
        F = []
        while True: 
            prefix = "KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qa"
            alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
            postfix = ''.join(secrets.choice(alphabet) for i in range(18))
            first_encode = base58.b58decode(f'{prefix}{postfix}')
            private_key_full = binascii.hexlify(first_encode)
            private_key = private_key_full[2:-8]
            btc_pubkey = privtopub(private_key.decode())
            btc_addr = pubtoaddr(btc_pubkey)
            spinner.start()
              
            if btc_addr.startswith("13zb1"):
               t = time.ctime()
               spinner.stop()
               print("Pattern Found:",t, btc_addr, private_key) 
               print("\n continue...\n")
               spinner.start()

            if btc_addr in add:
               t = time.ctime()
               spinner.stop()
               print("Winner Found!:",t, btc_addr, private_key)  
               f=open(u"Winner.txt","a") #Output File
               f.write('WIF private key: ' + str(private_key) + '\n' +
                            'public key: ' + str(btc_pubkey) + '\n' +
                            'BTC address: ' + str(btc_addr) + '\n\n')
               f.close()
               sleep(1)
               break

#CPU Control Command
if __name__ == '__main__':
        os.system('clear')
        t = time.ctime()
        print(t, "GOOD LUCK AND HAPPY HUNTING...") 
        
        jobs = []
        for r in range(cores):
                p = multiprocessing.Process(target=seek, args=(r,))
                jobs.append(p)
                p.start()

HI
after run code:

Code:

Wed Jan 11 16:00:39 2023 GOOD LUCK AND HAPPY HUNTING...
⠙ LoadingProcess Process-1:
Traceback (most recent call last):
  File "/usr/lib/python3.8/multiprocessing/process.py", line 315, in _bootstrap
    self.run()
  File "/usr/lib/python3.8/multiprocessing/process.py", line 108, in run
    self._target(*self._args, **self._kwargs)
  File "ffff.py", line 32, in seek
    btc_pubkey = privtopub(private_key.decode())
  File "/usr/local/lib/python3.8/dist-packages/bitcoin/main.py", line 294, in privkey_to_pubkey
    raise Exception("Invalid privkey")
Exception: Invalid privkey

The_Prof

sr. member

Activity: 345

Merit: 250

Quote from: ?? on ??

It is slow compared to ICE secp256k1. Twice the speed...However, I am currently creating a script that will be Full ICE - to search for lost parts of the private key. About 2 million per second per CPU thread.. Grin

I would love to see your 2 mil/sec as I am stuck on 500k/s with ice. Would be interested to see which route you went.

Edit: 2 mil+... CPU dependent. But that is on a public key hunt. So for those who want to try their luck.... It's set for 120 bit key...I guess if you link enough machines with enough CPU's you may hit in a few hundred years.

Code:

import secp256k1 as ice
from timeit import default_timer as timer
import random
import multiprocessing

cores = 1
perRound = 1000000
bitRange = 120
target_Key = '02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630'
    
def new_Number():
    doneSet = set()
    rotate = True
    with open("120-Nums.txt", "r+") as textfile:  
        for checking in textfile: doneSet.add(str(checking.replace("\n","").replace(",", "")))
        while rotate != False:
            number = round(random.randint(2**(bitRange-1),2**bitRange)/perRound)
            if str(number) not in doneSet:
                rotate = False
                textfile.write(str(number) + "\n") 
            if str(number) in doneSet:
                print('Collision')
    textfile.close()
    return number

def seek(r,cores):
    startStart = timer()
    dog = False
    while dog != True:
        number = new_Number()
        p = (ice.scalar_multiplication(number*perRound))
        start = timer()
        check = str((ice.point_sequential_increment(perRound, p)).hex())
        if target_Key[5:25] in check:
            print('Success: ' + str(number))
            print('Test Run Time Length: ' + str((timer()-startStart))[:6])
            with open("results.txt", "a") as completed:
                completed.write(str(p) + '   ' + str(number)) 
            completed.close()
            dog = True
        else:
            print('Core: ' + str(r) + '   Key/s: ' + str(perRound/(timer()-start))[:10]  + '   Time: ' + str(timer()-start)[:6] + '   RandInt: ' + str(number))

if __name__ == '__main__':
    jobs = []
    for r in range(cores):
        p = multiprocessing.Process(target=seek, args=(r,cores))
        jobs.append(p)
        p.start()

ProjectSe7en

jr. member

Activity: 59

Merit: 1

Quote from: albert0bsd on December 28, 2022, 06:36:40 PM

Quote from: ProjectSe7en on December 28, 2022, 04:45:06 PM

But it doesn't have multithread, and it's not as fast as others.

The problem with multithread is that the output can be in different order than the Input file, if that doesn't matter to your output then it is OK.

Why you only need the output address or rmd hash ?

Regards!

Doesn't matter cause it's for:

Experimental purposes with different languages and scripts, learn many more!!!, and have fun with the impossible luck.

BTW, my DM inbox is open.

Thanks for reply!

albert0bsd

hero member

Activity: 862

Merit: 662

Quote from: ProjectSe7en on December 28, 2022, 04:45:06 PM

But it doesn't have multithread, and it's not as fast as others.

The problem with multithread is that the output can be in different order than the Input file, if that doesn't matter to your output then it is OK.

Why you only need the output address or rmd hash ?

Regards!

ProjectSe7en

jr. member

Activity: 59

Merit: 1

Anyone knows a C program that can convert hexadecimal integer like "0000000000000000000000000000000000000000000000000000f7051f27b09112d4" to hash 160 or btc address, but from a text file or better in parallel in bash?

The only one I've found something similar is brainlayer https://github.com/ryancdotorg/brainflayer

your_generator | brainflayer -v -b example.blf

But it doesn't have multithread, and it's not as fast as others.

Thank you, happy holidays, and greetings. Grin

Evillo

member

Activity: 185

Merit: 15

Two things you should never abandon: Family & BTC

Quote from: saxydev on December 27, 2022, 01:38:18 AM

Quote from: Evillo on December 27, 2022, 01:16:27 AM

Quote from: saxydev on December 26, 2022, 02:48:18 PM

For half a year I use my cpu to scan for the #67 puzzle. I am 0.000039% scanned addresses of the range ;( A lifetime more to wait. I wonder how many supercomputers out there scan the bitcoin chain for these keys every minute. If you remember the pipeline hack, the FBI had already the privkey for the address used and it was not obtain during a hack or seize.

But Why the 67th puzzle ?.. why not the easier one? I mean the amount of private keys in 66 is unbelievably enormous already .. why go for the double of that gigantic range?

It's all about luck isn't it? Everyone is on the 66th puzzle. I just wanted to go on a different one. And the mining power cost is arround 15-20$ a month, I don't even feel it or me being disturbed about it.

The factor that you're forgetting here is "probability" .. when you target the 67th, you are basically cutting your probability of being lucky in half .. I'm just saying, but you can do whatever you want of course

saxydev

member

Activity: 429

Merit: 52

Quote from: Evillo on December 27, 2022, 01:16:27 AM

Quote from: saxydev on December 26, 2022, 02:48:18 PM

For half a year I use my cpu to scan for the #67 puzzle. I am 0.000039% scanned addresses of the range ;( A lifetime more to wait. I wonder how many supercomputers out there scan the bitcoin chain for these keys every minute. If you remember the pipeline hack, the FBI had already the privkey for the address used and it was not obtain during a hack or seize.

But Why the 67th puzzle ?.. why not the easier one? I mean the amount of private keys in 66 is unbelievably enormous already .. why go for the double of that gigantic range?

It's all about luck isn't it? Everyone is on the 66th puzzle. I just wanted to go on a different one. And the mining power cost is arround 15-20$ a month, I don't even feel it or me being disturbed about it.

Evillo

member

Activity: 185

Merit: 15

Two things you should never abandon: Family & BTC

Quote from: saxydev on December 26, 2022, 02:48:18 PM

For half a year I use my cpu to scan for the #67 puzzle. I am 0.000039% scanned addresses of the range ;( A lifetime more to wait. I wonder how many supercomputers out there scan the bitcoin chain for these keys every minute. If you remember the pipeline hack, the FBI had already the privkey for the address used and it was not obtain during a hack or seize.

But Why the 67th puzzle ?.. why not the easier one? I mean the amount of private keys in 66 is unbelievably enormous already .. why go for the double of that gigantic range?

citb0in

hero member

Activity: 630

Merit: 731

Bitcoin g33k

either you scan through the whole range which is time and ressource consuming or you take the short-cut Wink

saxydev

member

Activity: 429

Merit: 52

For half a year I use my cpu to scan for the #67 puzzle. I am 0.000039% scanned addresses of the range ;( A lifetime more to wait. I wonder how many supercomputers out there scan the bitcoin chain for these keys every minute. If you remember the pipeline hack, the FBI had already the privkey for the address used and it was not obtain during a hack or seize.

citb0in

hero member

Activity: 630

Merit: 731

Bitcoin g33k

Quote from: andiu9999 on December 15, 2022, 12:57:03 PM

Hi, anyone can help me split the range for 66 bitcoin address on 64 small ranges- 0x20000000000000000 - 0x3FFFFFFFFFFFFFFFF and to use with clbitcrack? i havce some hardware and is not the best but i get around 5 mkey/s with each. if anyone can help a i want give a try and if i found it i will give a bounty to person who help

Hi andiu9999,

here you go:

Code:

('0x20000000000000000', '0x20800000000000000')
('0x20800000000000000', '0x21000000000000000')
('0x21000000000000000', '0x21800000000000000')
('0x21800000000000000', '0x22000000000000000')
('0x22000000000000000', '0x22800000000000000')
('0x22800000000000000', '0x23000000000000000')
('0x23000000000000000', '0x23800000000000000')
('0x23800000000000000', '0x24000000000000000')
('0x24000000000000000', '0x24800000000000000')
('0x24800000000000000', '0x25000000000000000')
('0x25000000000000000', '0x25800000000000000')
('0x25800000000000000', '0x26000000000000000')
('0x26000000000000000', '0x26800000000000000')
('0x26800000000000000', '0x27000000000000000')
('0x27000000000000000', '0x27800000000000000')
('0x27800000000000000', '0x28000000000000000')
('0x28000000000000000', '0x28800000000000000')
('0x28800000000000000', '0x29000000000000000')
('0x29000000000000000', '0x29800000000000000')
('0x29800000000000000', '0x2A000000000000000')
('0x2A000000000000000', '0x2A800000000000000')
('0x2A800000000000000', '0x2B000000000000000')
('0x2B000000000000000', '0x2B800000000000000')
('0x2B800000000000000', '0x2C000000000000000')
('0x2C000000000000000', '0x2C800000000000000')
('0x2C800000000000000', '0x2D000000000000000')
('0x2D000000000000000', '0x2D800000000000000')
('0x2D800000000000000', '0x2E000000000000000')
('0x2E000000000000000', '0x2E800000000000000')
('0x2E800000000000000', '0x2F000000000000000')
('0x2F000000000000000', '0x2F800000000000000')
('0x2F800000000000000', '0x30000000000000000')
('0x30000000000000000', '0x30800000000000000')
('0x30800000000000000', '0x31000000000000000')
('0x31000000000000000', '0x31800000000000000')
('0x31800000000000000', '0x32000000000000000')
('0x32000000000000000', '0x32800000000000000')
('0x32800000000000000', '0x33000000000000000')
('0x33000000000000000', '0x33800000000000000')
('0x33800000000000000', '0x34000000000000000')
('0x34000000000000000', '0x34800000000000000')
('0x34800000000000000', '0x35000000000000000')
('0x35000000000000000', '0x35800000000000000')
('0x35800000000000000', '0x36000000000000000')
('0x36000000000000000', '0x36800000000000000')
('0x36800000000000000', '0x37000000000000000')
('0x37000000000000000', '0x37800000000000000')
('0x37800000000000000', '0x38000000000000000')
('0x38000000000000000', '0x38800000000000000')
('0x38800000000000000', '0x39000000000000000')
('0x39000000000000000', '0x39800000000000000')
('0x39800000000000000', '0x3A000000000000000')
('0x3A000000000000000', '0x3A800000000000000')
('0x3A800000000000000', '0x3B000000000000000')
('0x3B000000000000000', '0x3B800000000000000')
('0x3B800000000000000', '0x3C000000000000000')
('0x3C000000000000000', '0x3C800000000000000')
('0x3C800000000000000', '0x3D000000000000000')
('0x3D000000000000000', '0x3D800000000000000')
('0x3D800000000000000', '0x3E000000000000000')
('0x3E000000000000000', '0x3E800000000000000')
('0x3E800000000000000', '0x3F000000000000000')
('0x3F000000000000000', '0x3F800000000000000')
('0x3F800000000000000', '0x40000000000000000')

donations are always welcome Grin

just open my user profile and you'll find my BTC address there Wink

Quote from: ?? on ??

It won't work until numba -s shows

Code:

__CUDA Information__
Found 1 CUDA devices
id 0      b'GeForce GTX 970'   [SUPPORTED]
compute capability: 5.2
pci device id: 0
pci bus id: 1

which will confirm whether you have a functioning CUDA or not.

well, it seems that my GPU is supported, cannot see any issue here:

Code:

$ numba -s

Quote from: ?? on ??

Try to generate mandelbrot without GPU

https://numba.pydata.org/numba-doc/dev/user/examples.html#mandelbrot

0.3226363949943334 seconds with GPU
90 seconds with CPU

I get 0.21194690400443505 when running the original mandelbrot code and 2.2377483489981387 when commenting the "from numba import jit" and "@jit..." lines.

andiu9999

newbie

Activity: 74

Merit: 0

Hi, anyone can help me split the range for 66 bitcoin address on 64 small ranges- 0x20000000000000000 - 0x3FFFFFFFFFFFFFFFF and to use with clbitcrack? i havce some hardware and is not the best but i get around 5 mkey/s with each. if anyone can help a i want give a try and if i found it i will give a bounty to person who help

citb0in

hero member

Activity: 630

Merit: 731

Bitcoin g33k

I understand, but I don't believe only numbers in output so I always do cross-checking. I ran your CPU/GPU comparison benchmark program and I ran your latest GPU version for puz66. None of them show GPU utilization on my system so I am puzzled.

Just take your CPU/GPU benchmark program and remove the CPU part. Now raise n to a higher number and you will always get immediate results when executing the program, regardless of n value. That is impossible.

Code:

import os
os.environ['CUDA_VISIBLE_DEVICES'] = "0"
import numpy as np
import numba
from numba import cuda, jit
from timeit import default_timer as timer
from fastecdsa import keys, curve
import secp256k1 as ice
# Run on GPU
numba.jit()
def gpu(x):
    dec   = keys.gen_private_key(curve.P256)
    HEX   = "%064x" % dec
    wifc  = ice.btc_pvk_to_wif(HEX)
    wifu  = ice.btc_pvk_to_wif(HEX, False)
    uaddr = ice.privatekey_to_address(0, False, dec)
    caddr = ice.privatekey_to_address(0, True, dec)
    return x+1
if __name__=="__main__":
    n = 100000000
    a = np.ones(n, dtype = np.float64)
    start = timer()
    gpu(a)
    numba.cuda.profile_stop()
    print("with GPU:", timer()-start)

when you re-run the same command line you will get different result. I am also not sure if it's correct to have float64 used here, possibly it could throw some error when reaching the limits for allocating for the array.

citb0in

hero member

Activity: 630

Merit: 731

Bitcoin g33k

are you sure this will run on GPU? I quickly tested it and I see only 1 CPU thread being used at 100% for the program. There is absolutely no GPU utilization, GPU = 0%

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