Bitcoin puzzle transaction ~32 BTC prize to who solves it

[Ovixx]

@nomachine - for another puzzle, do I need to change anything in the script other than keyrange and pubkey? Why am I asking you? Because, in order to test, I put the public key from #64 and a very small keyrange, between f7051f26b09112d4 and f7051f2ab09112d4 (17799667353283269332:17799667370463138516) and it is obvious that the search is done outside the keyrange, in decimal, from 10000000000000000000 to 29999999999999999999 or even greater.

https://www.talkimg.com/images/2023/10/16/RrO2l.gif

[Baskentliia]

PUZZLE SOLVED: Wed Oct 11 12:13:21 2023, total time: 13.47 sec

• WIF:  -0000000000000000000000000000000000000000000000000022bd43c2e9354

nice catching again nomachine, is this programmable for 120th and up

Yes.
It takes about 3 minutes to start solving Puzzle 130 on my 12 Core - but will start.

Here is code for Puzzle130

Code:

import sys
import os
import time
import random
import hashlib
import gmpy2
from gmpy2 import mpz
from functools import lru_cache
import multiprocessing
from multiprocessing import Pool, cpu_count

# Constants
MODULO = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
ORDER = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141)
GX = gmpy2.mpz(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
GY = gmpy2.mpz(0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)

# Define Point class
class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

PG = Point(GX, GY)
ZERO_POINT = Point(0, 0)

# Function to multiply a point by 2
def multiply_by_2(P, p=MODULO):
    c = gmpy2.f_mod(3 * P.x * P.x * gmpy2.powmod(2 * P.y, -1, p), p)
    R = Point()
    R.x = gmpy2.f_mod(c * c - 2 * P.x, p)
    R.y = gmpy2.f_mod(c * (P.x - R.x) - P.y, p)
    return R

# Function to add two points
def add_points(P, Q, p=MODULO):
    dx = Q.x - P.x
    dy = Q.y - P.y
    c = gmpy2.f_mod(dy * gmpy2.invert(dx, p), p)
    R = Point()
    R.x = gmpy2.f_mod(c * c - P.x - Q.x, p)
    R.y = gmpy2.f_mod(c * (P.x - R.x) - P.y, p)
    return R

# Function to calculate Y-coordinate from X-coordinate
@lru_cache(maxsize=None)
def x_to_y(X, y_parity, p=MODULO):
    Y = gmpy2.mpz(3)
    tmp = gmpy2.mpz(1)

    while Y > 0:
        if Y % 2 == 1:
            tmp = gmpy2.f_mod(tmp * X, p)
        Y >>= 1
        X = gmpy2.f_mod(X * X, p)

    X = gmpy2.f_mod(tmp + 7, p)

    Y = gmpy2.f_div(gmpy2.add(p, 1), 4)
    tmp = gmpy2.mpz(1)

    while Y > 0:
        if Y % 2 == 1:
            tmp = gmpy2.f_mod(tmp * X, p)
        Y >>= 1
        X = gmpy2.f_mod(X * X, p)

    Y = tmp

    if Y % 2 != y_parity:
        Y = gmpy2.f_mod(-Y, p)

    return Y

# Function to compute a table of points
def compute_point_table():
    points = [PG]
    for k in range(255):
        points.append(multiply_by_2(points[k]))
    return points

POINTS_TABLE = compute_point_table()

# Global event to signal all processes to stop
STOP_EVENT = multiprocessing.Event()

# Function to check and compare points for potential solutions
def check(P, Pindex, DP_rarity, A, Ak, B, Bk):
    check = gmpy2.f_mod(P.x, DP_rarity)
    if check == 0:
        message = f"\r[+] [Pindex]: {mpz(Pindex)}"
        messages = []
        messages.append(message)
        output = "\033[01;33m" + ''.join(messages) + "\r"
        sys.stdout.write(output)
        sys.stdout.flush()
        A.append(mpz(P.x))
        Ak.append(mpz(Pindex))
        return comparator(A, Ak, B, Bk)
    else:
        return False

# Function to compare two sets of points and find a common point
def comparator(A, Ak, B, Bk):
    global STOP_EVENT
    result = set(A).intersection(set(B))

    if result:
        sol_kt = A.index(next(iter(result)))
        sol_kw = B.index(next(iter(result)))
        difference = Ak[sol_kt] - Bk[sol_kw]
        HEX = "%064x" % difference
        t = time.ctime()
        pid = os.getpid()  # Get the process ID
        core_number = pid % cpu_count()  # Calculate the CPU core number
        total_time = time.time() - starttime
        print(f"\033[32m[+] PUZZLE SOLVED: {t}, total time: {total_time:.2f} sec, Core: {core_number+1:02} \033[0m")
        print(f"\033[32m[+] WIF: \033[32m {HEX} \033[0m")
        with open("KEYFOUNDKEYFOUND.txt", "a") as file:
            file.write("\n\nSOLVED " + t)
            file.write(f"\nTotal Time: {total_time:.2f} sec")
            file.write("\nPrivate Key (decimal): " + str(difference))
            file.write("\nPrivate Key (hex): " + HEX)
            file.write(
                "\n-------------------------------------------------------------------------------------------------------------------------------------\n"
            )

        STOP_EVENT.set()  # Set the stop event to signal all processes

# Memoization for point multiplication
ECMULTIPLY_MEMO = {}

# Function to multiply a point by a scalar
def ecmultiply(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        if k in ECMULTIPLY_MEMO:
            return ECMULTIPLY_MEMO[k]
        else:
            result = ecmultiply(k // 2, multiply_by_2(P, p), p)
            ECMULTIPLY_MEMO[k] = result
            return result
    else:
        return add_points(P, ecmultiply((k - 1) // 2, multiply_by_2(P, p), p))

# Recursive function to multiply a point by a scalar
def mulk(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        return mulk(k // 2, multiply_by_2(P, p), p)
    else:
        return add_points(P, mulk((k - 1) // 2, multiply_by_2(P, p), p))

# Generate a list of powers of two for faster access
@lru_cache(maxsize=None)
def generate_powers_of_two(hop_modulo):
    return [mpz(1 << pw) for pw in range(hop_modulo)]

# Worker function for point search
def search_worker(
    Nt, Nw, puzzle, kangaroo_power, starttime, lower_range_limit, upper_range_limit
):
    global STOP_EVENT
    pid = os.getpid()  
    core_number = pid % cpu_count()
    #Random seed Config
    #constant_prefix = b''  #back to no constant
    #constant_prefix = b'\xbc\x9b\x8cd\xfc\xa1?\xcf' #Puzzle 50 seed - 10-18s
    constant_prefix = b'\xbc\x9b'
    prefix_length = len(constant_prefix)
    length = 8
    ending_length = length - prefix_length
    with open("/dev/urandom", "rb") as urandom_file:
        ending_bytes = urandom_file.read(ending_length)
    random_bytes = constant_prefix + ending_bytes
    print(f"[+] [Core]: {core_number+1:02}, [Random seed]: {random_bytes}")
    random.seed(random_bytes)  
    t = [
        mpz(
            lower_range_limit
            + mpz(random.randint(0, upper_range_limit - lower_range_limit))
        )
        for _ in range(Nt)
    ]
    T = [mulk(ti) for ti in t]
    dt = [mpz(0) for _ in range(Nt)]
    w = [
        mpz(random.randint(0, upper_range_limit - lower_range_limit)) for _ in range(Nt)
    ]
    W = [add_points(W0, mulk(wk)) for wk in w]
    dw = [mpz(0) for _ in range(Nw)]

    Hops, Hops_old = 0, 0

    oldtime = time.time()
    starttime = oldtime

    while True:
        for k in range(Nt):
            Hops += 1
            pw = T[k].x % hop_modulo
            dt[k] = powers_of_two[pw]
            solved = check(T[k], t[k], DP_rarity, T, t, W, w)
            if solved:
                STOP_EVENT.set()
                break
            t[k] = mpz(t[k]) + dt[k]  # Use mpz here
            T[k] = add_points(POINTS_TABLE[pw], T[k])

        for k in range(Nw):
            Hops += 1
            pw = W[k].x % hop_modulo
            dw[k] = powers_of_two[pw]
            solved = check(W[k], w[k], DP_rarity, W, w, T, t)
            if solved:
                STOP_EVENT.set()
                break
            w[k] = mpz(w[k]) + dw[k]  # Use mpz here
            W[k] = add_points(POINTS_TABLE[pw], W[k])

        if STOP_EVENT.is_set():
            break

# Main script
if __name__ == "__main__":
    os.system("clear")
    t = time.ctime()
    sys.stdout.write("\033[01;33m")
    sys.stdout.write(f"[+] [Kangaroo]: {t}" + "\n")
    sys.stdout.flush()

    # Configuration for the puzzle
    puzzle = 130
    compressed_public_key = "03633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852"  # Puzzle 130  
    lower_range_limit = 2 ** (puzzle - 1)
    upper_range_limit = (2 ** puzzle) - 1  
    kangaroo_power = puzzle // 8
    Nt = Nw = (2 ** kangaroo_power // puzzle) * puzzle + 8
    DP_rarity = 8 * puzzle
    hop_modulo = (puzzle // 2) + 8

    # Precompute powers of two for faster access
    powers_of_two = generate_powers_of_two(hop_modulo)

    T, t, dt = [], [], []
    W, w, dw = [], [], []

    if len(compressed_public_key) == 66:
        X = mpz(compressed_public_key[2:66], 16)
        Y = x_to_y(X, mpz(compressed_public_key[:2]) - 2)
    else:
        print("[error] pubkey len(66/130) invalid!")

    print(f"[+] [Puzzle]: {puzzle}")
    print(f"[+] [Lower range limit]: {lower_range_limit}")
    print(f"[+] [Upper range limit]: {upper_range_limit}")
    print("[+] [Xcoordinate]: %064x" % X)
    print("[+] [Ycoordinate]: %064x" % Y)

    W0 = Point(X, Y)
    starttime = oldtime = time.time()

    Hops = 0

    process_count = cpu_count()
    print(f"[+] [Using  {process_count} CPU cores for parallel search]:")

    # Create a pool of worker processes
    pool = Pool(process_count)
    results = pool.starmap(
        search_worker,
        [
            (
                Nt,
                Nw,
                puzzle,
                kangaroo_power,
                starttime,
                lower_range_limit,
                upper_range_limit,
            )
        ]
        * process_count,
    )
    pool.close()
    pool.join()

I put only 2 bytes as a constant - the rest will be randomized through all CPU cores, since we don't know what the seed for 130 is. . .
constant_prefix = b'\xbc\x9b'
constant_prefix = b'' is all random

ON the smaller puzzles it is easy to guess what the seed is. You need to restart and restart app and you will find out which is the fastest seed by repetition. The script will show exactly which seed and which core hit the WIF. You can experiment with different ones as you like.

FileNotFoundError: [Errno 2] No such file or directory: '/dev/urandom'

I am getting error like this:

C:\Users\abc\Desktop>py 4.py
'clear' is not recognized as an internal or external command,
operable program or batch file.

• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Using  8 CPU cores for parallel search]:

'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.

• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Puzzle]: 130
• [Puzzle]: 130
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Puzzle]: 130
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Lower range limit]: 680564733841876926926749214863536422912
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3

multiprocessing.pool.RemoteTraceback:
"""
Traceback (most recent call last):
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 125, in worker
    result = (True, func(*args, **kwds))
                    ^^^^^^^^^^^^^^^^^^^
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 51, in starmapstar
    return list(itertools.starmap(args[0], args[1]))
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Users\abc\Desktop\4.py", line 219, in search_worker
    with open("/dev/urandom", "rb") as urandom_file:
         ^^^^^^^^^^^^^^^^^^^^^^^^^^
FileNotFoundError: [Errno 2] No such file or directory: '/dev/urandom'
"""

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "C:\Users\abc\Desktop\4.py", line 277, in <module>
    results = pool.starmap(
              ^^^^^^^^^^^^^
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 375, in starmap
    return self._map_async(func, iterable, starmapstar, chunksize).get()
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 774, in get
    raise self._value
FileNotFoundError: [Errno 2] No such file or directory: '/dev/urandom'

C:\Users\abc\Desktop>



help me bro

[unclevito]

PUZZLE SOLVED: Wed Oct 11 12:13:21 2023, total time: 13.47 sec

• WIF:  -0000000000000000000000000000000000000000000000000022bd43c2e9354

nice catching again nomachine, is this programmable for 120th and up

Yes.
It takes about 3 minutes to start solving Puzzle 130 on my 12 Core - but will start.

Here is code for Puzzle130

Code:

import sys
import os
import time
import random
import hashlib
import gmpy2
from gmpy2 import mpz
from functools import lru_cache
import multiprocessing
from multiprocessing import Pool, cpu_count

# Constants
MODULO = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
ORDER = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141)
GX = gmpy2.mpz(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
GY = gmpy2.mpz(0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)

# Define Point class
class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

PG = Point(GX, GY)
ZERO_POINT = Point(0, 0)

# Function to multiply a point by 2
def multiply_by_2(P, p=MODULO):
    c = gmpy2.f_mod(3 * P.x * P.x * gmpy2.powmod(2 * P.y, -1, p), p)
    R = Point()
    R.x = gmpy2.f_mod(c * c - 2 * P.x, p)
    R.y = gmpy2.f_mod(c * (P.x - R.x) - P.y, p)
    return R

# Function to add two points
def add_points(P, Q, p=MODULO):
    dx = Q.x - P.x
    dy = Q.y - P.y
    c = gmpy2.f_mod(dy * gmpy2.invert(dx, p), p)
    R = Point()
    R.x = gmpy2.f_mod(c * c - P.x - Q.x, p)
    R.y = gmpy2.f_mod(c * (P.x - R.x) - P.y, p)
    return R

# Function to calculate Y-coordinate from X-coordinate
@lru_cache(maxsize=None)
def x_to_y(X, y_parity, p=MODULO):
    Y = gmpy2.mpz(3)
    tmp = gmpy2.mpz(1)

    while Y > 0:
        if Y % 2 == 1:
            tmp = gmpy2.f_mod(tmp * X, p)
        Y >>= 1
        X = gmpy2.f_mod(X * X, p)

    X = gmpy2.f_mod(tmp + 7, p)

    Y = gmpy2.f_div(gmpy2.add(p, 1), 4)
    tmp = gmpy2.mpz(1)

    while Y > 0:
        if Y % 2 == 1:
            tmp = gmpy2.f_mod(tmp * X, p)
        Y >>= 1
        X = gmpy2.f_mod(X * X, p)

    Y = tmp

    if Y % 2 != y_parity:
        Y = gmpy2.f_mod(-Y, p)

    return Y

# Function to compute a table of points
def compute_point_table():
    points = [PG]
    for k in range(255):
        points.append(multiply_by_2(points[k]))
    return points

POINTS_TABLE = compute_point_table()

# Global event to signal all processes to stop
STOP_EVENT = multiprocessing.Event()

# Function to check and compare points for potential solutions
def check(P, Pindex, DP_rarity, A, Ak, B, Bk):
    check = gmpy2.f_mod(P.x, DP_rarity)
    if check == 0:
        message = f"\r[+] [Pindex]: {mpz(Pindex)}"
        messages = []
        messages.append(message)
        output = "\033[01;33m" + ''.join(messages) + "\r"
        sys.stdout.write(output)
        sys.stdout.flush()
        A.append(mpz(P.x))
        Ak.append(mpz(Pindex))
        return comparator(A, Ak, B, Bk)
    else:
        return False

# Function to compare two sets of points and find a common point
def comparator(A, Ak, B, Bk):
    global STOP_EVENT
    result = set(A).intersection(set(B))

    if result:
        sol_kt = A.index(next(iter(result)))
        sol_kw = B.index(next(iter(result)))
        difference = Ak[sol_kt] - Bk[sol_kw]
        HEX = "%064x" % difference
        t = time.ctime()
        pid = os.getpid()  # Get the process ID
        core_number = pid % cpu_count()  # Calculate the CPU core number
        total_time = time.time() - starttime
        print(f"\033[32m[+] PUZZLE SOLVED: {t}, total time: {total_time:.2f} sec, Core: {core_number+1:02} \033[0m")
        print(f"\033[32m[+] WIF: \033[32m {HEX} \033[0m")
        with open("KEYFOUNDKEYFOUND.txt", "a") as file:
            file.write("\n\nSOLVED " + t)
            file.write(f"\nTotal Time: {total_time:.2f} sec")
            file.write("\nPrivate Key (decimal): " + str(difference))
            file.write("\nPrivate Key (hex): " + HEX)
            file.write(
                "\n-------------------------------------------------------------------------------------------------------------------------------------\n"
            )

        STOP_EVENT.set()  # Set the stop event to signal all processes

# Memoization for point multiplication
ECMULTIPLY_MEMO = {}

# Function to multiply a point by a scalar
def ecmultiply(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        if k in ECMULTIPLY_MEMO:
            return ECMULTIPLY_MEMO[k]
        else:
            result = ecmultiply(k // 2, multiply_by_2(P, p), p)
            ECMULTIPLY_MEMO[k] = result
            return result
    else:
        return add_points(P, ecmultiply((k - 1) // 2, multiply_by_2(P, p), p))

# Recursive function to multiply a point by a scalar
def mulk(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        return mulk(k // 2, multiply_by_2(P, p), p)
    else:
        return add_points(P, mulk((k - 1) // 2, multiply_by_2(P, p), p))

# Generate a list of powers of two for faster access
@lru_cache(maxsize=None)
def generate_powers_of_two(hop_modulo):
    return [mpz(1 << pw) for pw in range(hop_modulo)]

# Worker function for point search
def search_worker(
    Nt, Nw, puzzle, kangaroo_power, starttime, lower_range_limit, upper_range_limit
):
    global STOP_EVENT
    pid = os.getpid()  
    core_number = pid % cpu_count()
    #Random seed Config
    #constant_prefix = b''  #back to no constant
    #constant_prefix = b'\xbc\x9b\x8cd\xfc\xa1?\xcf' #Puzzle 50 seed - 10-18s
    constant_prefix = b'\xbc\x9b'
    prefix_length = len(constant_prefix)
    length = 8
    ending_length = length - prefix_length
    with open("/dev/urandom", "rb") as urandom_file:
        ending_bytes = urandom_file.read(ending_length)
    random_bytes = constant_prefix + ending_bytes
    print(f"[+] [Core]: {core_number+1:02}, [Random seed]: {random_bytes}")
    random.seed(random_bytes)  
    t = [
        mpz(
            lower_range_limit
            + mpz(random.randint(0, upper_range_limit - lower_range_limit))
        )
        for _ in range(Nt)
    ]
    T = [mulk(ti) for ti in t]
    dt = [mpz(0) for _ in range(Nt)]
    w = [
        mpz(random.randint(0, upper_range_limit - lower_range_limit)) for _ in range(Nt)
    ]
    W = [add_points(W0, mulk(wk)) for wk in w]
    dw = [mpz(0) for _ in range(Nw)]

    Hops, Hops_old = 0, 0

    oldtime = time.time()
    starttime = oldtime

    while True:
        for k in range(Nt):
            Hops += 1
            pw = T[k].x % hop_modulo
            dt[k] = powers_of_two[pw]
            solved = check(T[k], t[k], DP_rarity, T, t, W, w)
            if solved:
                STOP_EVENT.set()
                break
            t[k] = mpz(t[k]) + dt[k]  # Use mpz here
            T[k] = add_points(POINTS_TABLE[pw], T[k])

        for k in range(Nw):
            Hops += 1
            pw = W[k].x % hop_modulo
            dw[k] = powers_of_two[pw]
            solved = check(W[k], w[k], DP_rarity, W, w, T, t)
            if solved:
                STOP_EVENT.set()
                break
            w[k] = mpz(w[k]) + dw[k]  # Use mpz here
            W[k] = add_points(POINTS_TABLE[pw], W[k])

        if STOP_EVENT.is_set():
            break

# Main script
if __name__ == "__main__":
    os.system("clear")
    t = time.ctime()
    sys.stdout.write("\033[01;33m")
    sys.stdout.write(f"[+] [Kangaroo]: {t}" + "\n")
    sys.stdout.flush()

    # Configuration for the puzzle
    puzzle = 130
    compressed_public_key = "03633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852"  # Puzzle 130  
    lower_range_limit = 2 ** (puzzle - 1)
    upper_range_limit = (2 ** puzzle) - 1  
    kangaroo_power = puzzle // 8
    Nt = Nw = (2 ** kangaroo_power // puzzle) * puzzle + 8
    DP_rarity = 8 * puzzle
    hop_modulo = (puzzle // 2) + 8

    # Precompute powers of two for faster access
    powers_of_two = generate_powers_of_two(hop_modulo)

    T, t, dt = [], [], []
    W, w, dw = [], [], []

    if len(compressed_public_key) == 66:
        X = mpz(compressed_public_key[2:66], 16)
        Y = x_to_y(X, mpz(compressed_public_key[:2]) - 2)
    else:
        print("[error] pubkey len(66/130) invalid!")

    print(f"[+] [Puzzle]: {puzzle}")
    print(f"[+] [Lower range limit]: {lower_range_limit}")
    print(f"[+] [Upper range limit]: {upper_range_limit}")
    print("[+] [Xcoordinate]: %064x" % X)
    print("[+] [Ycoordinate]: %064x" % Y)

    W0 = Point(X, Y)
    starttime = oldtime = time.time()

    Hops = 0

    process_count = cpu_count()
    print(f"[+] [Using  {process_count} CPU cores for parallel search]:")

    # Create a pool of worker processes
    pool = Pool(process_count)
    results = pool.starmap(
        search_worker,
        [
            (
                Nt,
                Nw,
                puzzle,
                kangaroo_power,
                starttime,
                lower_range_limit,
                upper_range_limit,
            )
        ]
        * process_count,
    )
    pool.close()
    pool.join()

I put only 2 bytes as a constant - the rest will be randomized through all CPU cores, since we don't know what the seed for 130 is. . .
constant_prefix = b'\xbc\x9b'
constant_prefix = b'' is all random

ON the smaller puzzles it is easy to guess what the seed is. You need to restart and restart app and you will find out which is the fastest seed by repetition. The script will show exactly which seed and which core hit the WIF. You can experiment with different ones as you like.

FileNotFoundError: [Errno 2] No such file or directory: '/dev/urandom'

I am getting error like this:

C:\Users\abc\Desktop>py 4.py
'clear' is not recognized as an internal or external command,
operable program or batch file.

• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Using  8 CPU cores for parallel search]:

'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.

• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Puzzle]: 130
• [Puzzle]: 130
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Puzzle]: 130
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Lower range limit]: 680564733841876926926749214863536422912
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3

multiprocessing.pool.RemoteTraceback:
"""
Traceback (most recent call last):
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 125, in worker
    result = (True, func(*args, **kwds))
                    ^^^^^^^^^^^^^^^^^^^
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 51, in starmapstar
    return list(itertools.starmap(args[0], args[1]))
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Users\abc\Desktop\4.py", line 219, in search_worker
    with open("/dev/urandom", "rb") as urandom_file:
         ^^^^^^^^^^^^^^^^^^^^^^^^^^
FileNotFoundError: [Errno 2] No such file or directory: '/dev/urandom'
"""

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "C:\Users\abc\Desktop\4.py", line 277, in <module>
    results = pool.starmap(
              ^^^^^^^^^^^^^
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 375, in starmap
    return self._map_async(func, iterable, starmapstar, chunksize).get()
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 774, in get
    raise self._value
FileNotFoundError: [Errno 2] No such file or directory: '/dev/urandom'

C:\Users\abc\Desktop>



help me bro

This is not my code but it looks like you are using windows and '/dev/urandom' is a linux function that is also available in Windows Subsystem Ubuntu so I think you are using a linux program.in windows.  I think a few pages back the creator of this program posted a version that does not use  '/dev/urandom' that should work in windows.

[hari1987]

can anyone kindly provide an example of public key subtraction code in python ?

[Ovixx]

it does not work under windows, if you do not use the WSL subsystem

[digaran]

can anyone kindly provide an example of public key subtraction code in python ?

Try this one.

Code:

import secp256k1 as ice

target_public_key = "032f3342152eff6aca5e7314db6d3301a28d6a90ddcfd189f96babadc2a053d392"
target = ice.pub2upub(target_public_key)
num = 1000  # number of times.
subtract = 1  # amount to subtract each time.

# Define the new generator point coordinates
new_generator = (new_x_coordinate, new_y_coordinate)  # Replace with actual coordinates

sustract_pub_new = ice.scalar_multiplication(subtract, new_generator)
res = ice.point_loop_subtraction(num, target, subtract_pub_new)

for t in range(num + 1):
    h = (res[t * 65:t * 65 + 65]).hex()
    hc = ice.to_cpub(h)
    data = open("data-base.txt", "a")
    data.write(str(hc) + "\n")
    data.close()

This will subtract 1G 1000 times from target, meaning if target is 2000, it will give you 1999, 1998, 1997... etc.

[nomachine]

@nomachine - for another puzzle, do I need to change anything in the script other than keyrange and pubkey? Why am I asking you? Because, in order to test, I put the public key from #64 and a very small keyrange, between f7051f26b09112d4 and f7051f2ab09112d4 (17799667353283269332:17799667370463138516) and it is obvious that the search is done outside the keyrange, in decimal, from 10000000000000000000 to 29999999999999999999 or even greater.

Pindex is essentially an identifier for the points being processed and helps keep track of the progress of the search and identify points that could potentially solve the cryptographic puzzle. It's used to match points from different sets and determine if they share the same x-coordinate. Since these values are generated randomly, they may not always fall within the specified range, especially if the random number generation is not constrained.
The script employs a kangaroo twins hopping strategy to search for solutions. The hopping strategy involves adding a certain value to the x-coordinate of a point and then computing the next point in the sequence. Depending on the hopping value, it is possible for the point to move outside the defined range.

I am getting error like this:

C:\Users\abc\Desktop>py 4.py
'clear' is not recognized as an internal or external command,
operable program or batch file.

• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Using  8 CPU cores for parallel search]:

'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.

• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Puzzle]: 130
• [Puzzle]: 130
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Puzzle]: 130
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Lower range limit]: 680564733841876926926749214863536422912
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3

multiprocessing.pool.RemoteTraceback:
"""
Traceback (most recent call last):
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 125, in worker
    result = (True, func(*args, **kwds))
                    ^^^^^^^^^^^^^^^^^^^
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 51, in starmapstar
    return list(itertools.starmap(args[0], args[1]))
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Users\abc\Desktop\4.py", line 219, in search_worker
    with open("/dev/urandom", "rb") as urandom_file:
         ^^^^^^^^^^^^^^^^^^^^^^^^^^
FileNotFoundError: [Errno 2] No such file or directory: '/dev/urandom'
"""

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "C:\Users\abc\Desktop\4.py", line 277, in <module>
    results = pool.starmap(
              ^^^^^^^^^^^^^
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 375, in starmap
    return self._map_async(func, iterable, starmapstar, chunksize).get()
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 774, in get
    raise self._value
FileNotFoundError: [Errno 2] No such file or directory: '/dev/urandom'

C:\Users\abc\Desktop>



help me bro

Go again there and copy/paste script - it is updated several times. The new version has a Core list for each seed.

https://bitcointalk.org/index.php?topic=1306983.msg62978550#msg62978550

Use "cls" instead of  "clear" in Windows  

p.s.
If someone has time (i'm sold out right now) , it wouldn't be a bad idea to make the same program in C++ with the same seed capabilities and to work above Puzzle 125 . . . It would work incomparably faster.

[MoreForUs]

I am searching for all 3 addresses from 1 hex range. please, if anyone can help.. we can do this for all addresses.
https://www.talkimg.com/images/2023/10/16/Rcs4o.gif

[albert0bsd]

if you have a True randomness in your PC you will have possibility to have consciousness in your computer.

Not just me, every body with a moderm CPU and a good RNG algorithm in its OS (So every linux/windows)

Did you bothered in read what i quote from that page?

From: https://www.intel.com/content/www/us/en/developer/articles/guide/intel-digital-random-number-generator-drng-software-implementation-guide.html

The ES runs asynchronously on a self-timed circuit and uses thermal noise within the silicon to output a random stream of bits at the rate of 3 GHz

@nomachin WTF? You just ignore what i write and started to talking about something that is not related.

Artificial Intelligence, singularity, simulations? WTF?? What is the relationship between that and this TOPIC?

[digaran]

Guys/gals, don't waste your time with random search, random mode etc, there is no such a thing as "random" all events follow a pattern,  we as humans have to interfere and change these patterns, by following logic and the power of our minds.
Instead of "hoping" for a "lucky" hit in a random search, start working on ways to find a stride for public key brute force.
Example:
Target = 127654 (unknown) we only know it's between 100,000 and 200,000.
So we subtract it from 200,000 - 127654 = 72,346.  Now we are certain our result is 100% smaller than 100,000 (start range), but since we don't know how much smaller, we'd just subtract it from half of start range, 50,000 - 72,346 = 22,346. And now we are 100% certain the result is smaller than 50,000 but we don't know how much, again we subtract it from 1/4 of start range 25,000 - 22,346 = 2,654.

Now tell me what do you see?
127654
2654
127654 - 2654 = 125000
What you need to work on is figuring out a stride to add to 125,000 till we reach our target, whether we add 13 at each step, 14 or 15, what happens when we reach 127698? Can we save the keys between 127654 and 127700 so when we are adding stride and land on one of the saved keys, we know right away and easily solve the key or not?

These things should be your priority, enough of running this tool/script and that tool/script, come up with an algorithm which doesn't require "random" and "luck" but requires math equations and numbers.

[Ovixx]

Guys/gals, don't waste your time with random search, random mode etc, there is no such a thing as "random" all events follow a pattern,  we as humans have to interfere and change these patterns, by following logic and the power of our minds.
.................

I still believe that the random mode is more effective than the subtraction that you have been mentioning for a while and you are only looking for a solution where there is none, but I wish you success. Everyone applies their own way. Let's see who can do it first, shall we?
...by the way, you do some stupid calculations in which only you see something....Do you somehow see the Eiffel Tower on the left side?

[nomachine]

@nomachin WTF? You just ignore what i write and started to talking about something that is not related.

Artificial Intelligence, singularity, simulations? WTF?? What is the relationship between that and this TOPIC?

You keep insisting that the RNG must be safe and by some (security) rules.. .I assume written by the NSA itself?
You need slow and safe/secure (unpredictable) when you create and protect BTC,  not when you hack it.
The rule is that when you hacking there are no rules.

Is all this a robbery/steal/theft attempt?

It is definitely a hacker attempt/attack.  Tell the truth and . . .run  

[Baskentliia]

@nomachine - for another puzzle, do I need to change anything in the script other than keyrange and pubkey? Why am I asking you? Because, in order to test, I put the public key from #64 and a very small keyrange, between f7051f26b09112d4 and f7051f2ab09112d4 (17799667353283269332:17799667370463138516) and it is obvious that the search is done outside the keyrange, in decimal, from 10000000000000000000 to 29999999999999999999 or even greater.

Pindex is essentially an identifier for the points being processed and helps keep track of the progress of the search and identify points that could potentially solve the cryptographic puzzle. It's used to match points from different sets and determine if they share the same x-coordinate. Since these values are generated randomly, they may not always fall within the specified range, especially if the random number generation is not constrained.
The script employs a kangaroo twins hopping strategy to search for solutions. The hopping strategy involves adding a certain value to the x-coordinate of a point and then computing the next point in the sequence. Depending on the hopping value, it is possible for the point to move outside the defined range.

I am getting error like this:

C:\Users\abc\Desktop>py 4.py
'clear' is not recognized as an internal or external command,
operable program or batch file.

• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Using  8 CPU cores for parallel search]:

'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.
'clear' is not recognized as an internal or external command,
operable program or batch file.

• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Puzzle]: 130
• [Puzzle]: 130
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Puzzle]: 130
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Lower range limit]: 680564733841876926926749214863536422912
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Kangaroo]: Mon Oct 16 15:48:30 2023
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3
• [Puzzle]: 130
• [Lower range limit]: 680564733841876926926749214863536422912
• [Upper range limit]: 1361129467683753853853498429727072845823
• [Xcoordinate]: 633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
• [Ycoordinate]: b078a17cc1558a9a4fa0b406f194c9a2b71d9a61424b533ceefe27408b3191e3

multiprocessing.pool.RemoteTraceback:
"""
Traceback (most recent call last):
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 125, in worker
    result = (True, func(*args, **kwds))
                    ^^^^^^^^^^^^^^^^^^^
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 51, in starmapstar
    return list(itertools.starmap(args[0], args[1]))
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Users\abc\Desktop\4.py", line 219, in search_worker
    with open("/dev/urandom", "rb") as urandom_file:
         ^^^^^^^^^^^^^^^^^^^^^^^^^^
FileNotFoundError: [Errno 2] No such file or directory: '/dev/urandom'
"""

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "C:\Users\abc\Desktop\4.py", line 277, in <module>
    results = pool.starmap(
              ^^^^^^^^^^^^^
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 375, in starmap
    return self._map_async(func, iterable, starmapstar, chunksize).get()
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\Program Files\Python311\Lib\multiprocessing\pool.py", line 774, in get
    raise self._value
FileNotFoundError: [Errno 2] No such file or directory: '/dev/urandom'

C:\Users\abc\Desktop>



help me bro

Go again there and copy/paste script - it is updated several times. The new version has a Core list for each seed.

https://bitcointalk.org/index.php?topic=1306983.msg62978550#msg62978550

Use "cls" instead of  "clear" in Windows  

p.s.
If someone has time (i'm sold out right now) , it wouldn't be a bad idea to make the same program in C++ with the same seed capabilities and to work above Puzzle 125 . . . It would work incomparably faster.

I tried to run it using Python on my brother's Windows, but it didn't work. I request a new update for Windows because the program is quite nice.

[digaran]

I still believe that the random mode is more effective than the subtraction that you have been mentioning for a while and you are only looking for a solution where there is none

We keep looking until we find one, if there was an easy to spot solution then we wouldn't be here at all, and my solution is not based on subtraction, it also includes division, however I'm working on a new method to multiply and divide 2 points, I know something impossible, right? At least I'm delusional by relying on mathematics, whilst you and a few others are delusional relying on "random" search without even realizing the probabilities of successfully landing on a target in a big range like 130 is beyond your comprehension.  You insist on a "luck" which doesn't exist, if you input 1 address and generate a random key and land on that 1 address, it's not called luck, God wanted it.

by the way, you do some stupid calculations in which only you see something....Do you somehow see the Eiffel Tower on the left side?

Yet I haven't seen you slapping me with these stupid calculations, proving me wrong and embarrassing me for everyone to see. ( wait there is a unicorn asking for directions for Champs-Élysées, let me give him an equation to solve for the address.) 😉🤣

Please learn how to quote and trim the unnecessary previous quotes, @everyone. Thanks

[nomachine]

I'm delusional by relying on mathematics, whilst you and a few others are delusional relying on "random" search

It doesn't matter what method did you use if you succeed in your intention. And no matter how crazy the way may seem,
this isn't conceptually different from picking up someone's safe and finding its lock combination, then claiming the safe's contents for the sake of science.  

[Legends_Never_Die]

this isn't conceptually different from picking up someone's safe and finding its lock combination, then claiming the safe's contents for the sake of science.  

Except these safes are publicly reachable unlike private safes inside houses. Consider yourself a security team member working on security issues, your payment is in puzzle addresses, find a hole and grab your payment, if the designer was a professional programmer, he wouldn't have made this puzzle, he is a good scientist but not a good programmer, as early bitcoin clients were full of bugs/code related issues, but the concept was perfect and it is to this day.  Scientists act based on science, puzzle hunters act based on monetary incentive.

"They asked someone, imagine you are in the middle of the ocean and sharks are approaching, what will you do?"
"He said I will climb a tree"
-They said but there are no trees in the middle of the ocean-
"He said I know, but I don't have any other choice"
🤣

[nomachine]

Except these safes are publicly reachable unlike private safes inside houses.

ATMs are publicly reachable. Try to hack them.  I'm kidding...  
🤣
I understand the whole story.    

[Baskentliia]

Code:

import sys
import os
import time
import random
import hashlib
import gmpy2
from gmpy2 import mpz
from functools import lru_cache
import multiprocessing
from multiprocessing import Pool, cpu_count

os.system("cls")

# Constants
MODULO = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
ORDER = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141)
GX = gmpy2.mpz(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
GY = gmpy2.mpz(0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)

# Define Point class
class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

PG = Point(GX, GY)
ZERO_POINT = Point(0, 0)

# Function to multiply a point by 2
def multiply_by_2(P, p=MODULO):
    c = gmpy2.f_mod(3 * P.x * P.x * gmpy2.powmod(2 * P.y, -1, p), p)
    R = Point()
    R.x = gmpy2.f_mod(c * c - 2 * P.x, p)
    R.y = gmpy2.f_mod(c * (P.x - R.x) - P.y, p)
    return R

# Function to add two points
def add_points(P, Q, p=MODULO):
    dx = Q.x - P.x
    dy = Q.y - P.y
    c = gmpy2.f_mod(dy * gmpy2.invert(dx, p), p)
    R = Point()
    R.x = gmpy2.f_mod(c * c - P.x - Q.x, p)
    R.y = gmpy2.f_mod(c * (P.x - R.x) - P.y, p)
    return R

# Function to calculate Y-coordinate from X-coordinate
@lru_cache(maxsize=None)
def x_to_y(X, y_parity, p=MODULO):
    Y = gmpy2.mpz(3)
    tmp = gmpy2.mpz(1)

    while Y > 0:
        if Y % 2 == 1:
            tmp = gmpy2.f_mod(tmp * X, p)
        Y >>= 1
        X = gmpy2.f_mod(X * X, p)

    X = gmpy2.f_mod(tmp + 7, p)

    Y = gmpy2.f_div(gmpy2.add(p, 1), 4)
    tmp = gmpy2.mpz(1)

    while Y > 0:
        if Y % 2 == 1:
            tmp = gmpy2.f_mod(tmp * X, p)
        Y >>= 1
        X = gmpy2.f_mod(X * X, p)

    Y = tmp

    if Y % 2 != y_parity:
        Y = gmpy2.f_mod(-Y, p)

    return Y

# Function to compute a table of points
def compute_point_table():
    points = [PG]
    for k in range(255):
        points.append(multiply_by_2(points[k]))
    return points

POINTS_TABLE = compute_point_table()

# Global event to signal all processes to stop
STOP_EVENT = multiprocessing.Event()

# Function to check and compare points for potential solutions
def check(P, Pindex, DP_rarity, A, Ak, B, Bk):
    check = gmpy2.f_mod(P.x, DP_rarity)
    if check == 0:
        message = f"\r[+] [Pindex]: {mpz(Pindex)}"
        messages = []
        messages.append(message)
        output = "\033[01;33m" + ''.join(messages) + "\r"
        sys.stdout.write(output)
        sys.stdout.flush()
        A.append(mpz(P.x))
        Ak.append(mpz(Pindex))
        return comparator(A, Ak, B, Bk)
    else:
        return False

# Function to compare two sets of points and find a common point
def comparator(A, Ak, B, Bk):
    global STOP_EVENT
    result = set(A).intersection(set(B))

    if result:
        sol_kt = A.index(next(iter(result)))
        sol_kw = B.index(next(iter(result)))
        difference = Ak[sol_kt] - Bk[sol_kw]
        HEX = "%064x" % difference
        t = time.ctime()
        pid = os.getpid()  # Get the process ID
        core_number = pid % cpu_count()  # Calculate the CPU core number
        total_time = time.time() - starttime
        print(f"\033[32m[+] PUZZLE SOLVED: {t}, total time: {total_time:.2f} sec, Core: {core_number+1:02} \033[0m")
        print(f"\033[32m[+] WIF: \033[32m {HEX} \033[0m")
        with open("KEYFOUNDKEYFOUND.txt", "a") as file:
            file.write("\n\nSOLVED " + t)
            file.write(f"\nTotal Time: {total_time:.2f} sec")
            file.write("\nPrivate Key (decimal): " + str(difference))
            file.write("\nPrivate Key (hex): " + HEX)
            file.write(
                "\n-------------------------------------------------------------------------------------------------------------------------------------\n"
            )

        STOP_EVENT.set()  # Set the stop event to signal all processes

# Memoization for point multiplication
ECMULTIPLY_MEMO = {}

# Function to multiply a point by a scalar
def ecmultiply(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        if k in ECMULTIPLY_MEMO:
            return ECMULTIPLY_MEMO[k]
        else:
            result = ecmultiply(k // 2, multiply_by_2(P, p), p)
            ECMULTIPLY_MEMO[k] = result
            return result
    else:
        return add_points(P, ecmultiply((k - 1) // 2, multiply_by_2(P, p), p))

# Recursive function to multiply a point by a scalar
def mulk(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        return mulk(k // 2, multiply_by_2(P, p), p)
    else:
        return add_points(P, mulk((k - 1) // 2, multiply_by_2(P, p), p))

# Generate a list of powers of two for faster access
@lru_cache(maxsize=None)
def generate_powers_of_two(hop_modulo):
    return [mpz(1 << pw) for pw in range(hop_modulo)]

t = time.ctime()
sys.stdout.write("\033[01;33m")
sys.stdout.write(f"[+] [Kangaroo]: {t}" + "\n")
sys.stdout.flush()

# Configuration for the puzzle
puzzle = 70
compressed_public_key = "0290e6900a58d33393bc1097b5aed31f2e4e7cbd3e5466af958665bc0121248483"  # Puzzle 70
lower_range_limit = 2 ** (puzzle - 1)
upper_range_limit = (2 ** puzzle) - 1
kangaroo_power = puzzle // 8
Nt = Nw = (2 ** kangaroo_power // puzzle) * puzzle + 8
DP_rarity = 8 * puzzle
hop_modulo = (puzzle // 2) + 8

# Precompute powers of two for faster access
powers_of_two = generate_powers_of_two(hop_modulo)

T, t, dt = [], [], []
W, w, dw = [], [], []

if len(compressed_public_key) == 66:
    X = mpz(compressed_public_key[2:66], 16)
    Y = x_to_y(X, mpz(compressed_public_key[:2]) - 2)
else:
    print("[error] pubkey len(66/130) invalid!")

print(f"[+] [Puzzle]: {puzzle}")
print(f"[+] [Lower range limit]: {lower_range_limit}")
print(f"[+] [Upper range limit]: {upper_range_limit}")
print("[+] [Xcoordinate]: %064x" % X)
print("[+] [Ycoordinate]: %064x" % Y)

W0 = Point(X, Y)
starttime = oldtime = time.time()

Hops = 0

# Worker function for point search
def search_worker(
    Nt, Nw, puzzle, kangaroo_power, starttime, lower_range_limit, upper_range_limit
):
    global STOP_EVENT
    pid = os.getpid()
    core_number = pid % cpu_count()
    #Random seed Config
    #constant_prefix = b''  #back to no constant
    #constant_prefix = b'\xbc\x9b\x8cd\xfc\xa1?\xcf' #Puzzle 50 seed - 10-18s
    constant_prefix = b'\xbc\x9b\x8cd'
    prefix_length = len(constant_prefix)
    length = 8
    ending_length = length - prefix_length
    ending_bytes = os.urandom(ending_length)
    random_bytes = constant_prefix + ending_bytes
    print(f"[+] [Core]: {core_number+1:02}, [Random seed]: {random_bytes}")
    random.seed(random_bytes)
    t = [
        mpz(
            lower_range_limit
            + mpz(random.randint(0, upper_range_limit - lower_range_limit))
        )
        for _ in range(Nt)
    ]
    T = [mulk(ti) for ti in t]
    dt = [mpz(0) for _ in range(Nt)]
    w = [
        mpz(random.randint(0, upper_range_limit - lower_range_limit)) for _ in range(Nt)
    ]
    W = [add_points(W0, mulk(wk)) for wk in w]
    dw = [mpz(0) for _ in range(Nw)]

    Hops, Hops_old = 0, 0

    oldtime = time.time()
    starttime = oldtime

    while True:
        for k in range(Nt):
            Hops += 1
            pw = T[k].x % hop_modulo
            dt[k] = powers_of_two[pw]
            solved = check(T[k], t[k], DP_rarity, T, t, W, w)
            if solved:
                STOP_EVENT.set()
                break
            t[k] = mpz(t[k]) + dt[k]  # Use mpz here
            T[k] = add_points(POINTS_TABLE[pw], T[k])

        for k in range(Nw):
            Hops += 1
            pw = W[k].x % hop_modulo
            dw[k] = powers_of_two[pw]
            solved = check(W[k], w[k], DP_rarity, W, w, T, t)
            if solved:
                STOP_EVENT.set()
                break
            w[k] = mpz(w[k]) + dw[k]  # Use mpz here
            W[k] = add_points(POINTS_TABLE[pw], W[k])

        if STOP_EVENT.is_set():
            break

# Main script
if __name__ == "__main__":
    process_count = 2
    print(f"[+] [Using  {process_count} CPU cores for parallel search]:")

    # Create a pool of worker processes
    pool = Pool(process_count)
    results = pool.starmap(
        search_worker,
        [
            (
                Nt,
                Nw,
                puzzle,
                kangaroo_power,
                starttime,
                lower_range_limit,
                upper_range_limit,
            )
        ]
        * process_count,
    )
    pool.close()
    pool.join()

Try this, it works for me on windows.

Thank you brother I tried this and it worked

[WanderingPhilospher]

Guys/gals, don't waste your time with random search, random mode etc, there is no such a thing as "random" all events follow a pattern,  we as humans have to interfere and change these patterns, by following logic and the power of our minds.
Instead of "hoping" for a "lucky" hit in a random search, start working on ways to find a stride for public key brute force.
Example:
Target = 127654 (unknown) we only know it's between 100,000 and 200,000.
So we subtract it from 200,000 - 127654 = 72,346.  Now we are certain our result is 100% smaller than 100,000 (start range), but since we don't know how much smaller, we'd just subtract it from half of start range, 50,000 - 72,346 = 22,346. And now we are 100% certain the result is smaller than 50,000 but we don't know how much, again we subtract it from 1/4 of start range 25,000 - 22,346 = 2,654.

Now tell me what do you see?
127654
2654
127654 - 2654 = 125000
What you need to work on is figuring out a stride to add to 125,000 till we reach our target, whether we add 13 at each step, 14 or 15, what happens when we reach 127698? Can we save the keys between 127654 and 127700 so when we are adding stride and land on one of the saved keys, we know right away and easily solve the key or not?

These things should be your priority, enough of running this tool/script and that tool/script, come up with an algorithm which doesn't require "random" and "luck" but requires math equations and numbers.

Sorry man, this either will not work because you went around the curve, or you will have trillions^trillions of strides to go through/take.

Your example:
Target = 127654
range = 100,000 - 200,000

Like you said, we do not know the target, only the range.
So let's say the target's key is 199,999
Watch the math:
200,000 - 199,999 = 1
1 - 50,000 = -49,999
-49,999 - 25,000 = -74,999

You have now went backwards around the curve. So now, you can't even start your program to start striding from 0 or 1.

But let's deal with your math above and talk about the strides.

It's ok when a range is only 200,000 but now imagine a much larger range, say 2^130. If you have a stride of 13, 14, 15, etc., it will take you more than a lifetime to still get through that range.

[nomachine]

Here is new script....
Bytea HASH160 Search.
Bitcoin addresses and hashes are typically represented as byte sequences. When you work with bytes, you can directly perform binary operations and comparisons, which is faster and more efficient than dealing with hexadecimal or string representations.
In this context, the script generates private keys as integers and converts them into bytes to derive Bitcoin addresses. It then calculates the Hash160 of these addresses and compares it to the target Hash160.
Script uses puzzle creator method - the b'\x00' * 32 line creates a 32-byte value composed entirely of zero bytes. This is just an initial placeholder value, and as the script progresses, it replaces parts of these zeros with the random bytes generated to create a valid private key for Bitcoin.
You can also play with patterns and random seed values at the same time.

Code:

import sys
import os
import time
import random
import binascii
import base58
import hashlib
import ecdsa
from multiprocessing import cpu_count
import threading

# Set the Hash 160 address you want to check for
target_hex = "20d45a6a762535700ce9e0b216e31994335db8a5"
add_set = bytes.fromhex(target_hex)

puzzle = 66
min_number = 2 ** (puzzle - 1)
max_number = (2 ** puzzle) - 1

# Clear the terminal screen
if os.name == 'nt':
    os.system('cls')
else:
    os.system('clear')

# Print information about the program
t = time.ctime()
sys.stdout.write("\033[01;33m")
sys.stdout.write("\033[?25l")
sys.stdout.write(f"[+] [Bytea HASH160 Search] {t}" + "\n")
sys.stdout.write(f"[+] [Puzzle]: {puzzle}" + "\n")
sys.stdout.write(f"[+] [Lower range limit]: {min_number}" + "\n")
sys.stdout.write(f"[+] [Upper range limit]: {max_number}" + "\n")
sys.stdout.flush()

# Define the check_private_key function
def check_private_key(add_set):
    while True:
        constant_prefix = b''  #Can be b'\xbc\x9b' or any random_bytes
        prefix_length = len(constant_prefix)
        length = 8
        ending_length = length - prefix_length
        ending_bytes = os.urandom(ending_length)
        random_bytes = constant_prefix + ending_bytes
        random.seed(random_bytes)
        dec = random.randint(min_number, max_number)
        dec_bytes = dec.to_bytes((dec.bit_length() + 7) // 8, 'big')
        private_key_bytes = b'\x00' * 32
        private_key_bytes = private_key_bytes[:-len(dec_bytes)] + dec_bytes
        signing_key = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
        compressed_public_key = signing_key.get_verifying_key().to_string("compressed")
        sha256_hash = hashlib.sha256(compressed_public_key).digest()
        HASH160 = hashlib.new('ripemd160', sha256_hash).digest()
        extended_private_key = b'\x80' + private_key_bytes + b'\x01'
        extended_ripe160_hash = b'\x00' + HASH160
        checksum = hashlib.sha256(hashlib.sha256(extended_private_key).digest()).digest()[:4]
        checksum_ripe160 = hashlib.sha256(hashlib.sha256(extended_ripe160_hash).digest()).digest()[:4]
        private_key_with_checksum = extended_private_key + checksum
        HASH160_wif = base58.b58encode(private_key_with_checksum).decode()
        address_bytes = extended_ripe160_hash + checksum_ripe160
        bitcoin_address = base58.b58encode(address_bytes).decode()
        message = "\r[+] Public Key Hash (Hash 160): {}             ".format(HASH160.hex())
        messages = []
        messages.append(message)
        output = "\033[01;33m" + ''.join(messages) + "\r"
        sys.stdout.write(output)
        sys.stdout.flush()
        if bitcoin_address.startswith("13zb1h"):
            sys.stdout.write(f"\n[+]\033[32m Pattern Found: {bitcoin_address}, {dec}, {random_bytes}              \033[0m")
            sys.stdout.write(f"\n[+] continue...\n")
        if HASH160 == add_set:
            dec_to_hex = hex(dec).split('x')[-1]
            t = time.ctime()
            sys.stdout.write(f"\033[0m\n\n")
            sys.stdout.write(f"[+] SOLVED:    |\033[32m{t}                                                                 \033[0m\n")
            sys.stdout.write(f"[+] Key Found: |\033[32m {dec_to_hex}                                               \033[0m\n"
                                        f"[+] WIF:       |\033[32m {HASH160_wif}                                                 \033[0m\n"
                                        f"[+] Address:   |\033[32m {bitcoin_address}                                          \033[0m\n"
                                        f"[+] Seed:      |\033[32m {random_bytes}                                               \033[0m\n\n")
            sys.stdout.flush()
            with open("KEYFOUNDKEYFOUND.txt", "a") as f:
                f.write("SOLVED: " + str(t) + '\n' + "HEX: " + str(dec_to_hex) + '\n' + "Address: " + str(bitcoin_address) + '\n' + "Private Key:  " + str(HASH160_wif)+ '\n' + "Random Seed:  " + str(random_bytes) + '\n\n')
                f.flush()
                f.close()
            sys.stdout.write("\033[?25h")
            sys.stdout.flush()
            return

# Create multiple threads for generating addresses
num_threads = cpu_count()
threads = []

for _ in range(num_threads):
    thread = threading.Thread(target=check_private_key, args=(add_set,))
    thread.start()
    threads.append(thread)

# Wait for all threads to finish
for thread in threads:
    thread.join()