Which means, that not only we can use 02 and 03 as a prefix, but the number "three" can be used, to get three different x-values, leading to the same y-value. However, things doesn't stop there: by factoring n-1, we can use these numbers to explore smaller circles, where the biggest one has only 341948486974166000522343609283189 elements.

Wanted to ask, given the latest puzzle and last couple of solved puzzles are unprofitable to crack by renting from, say vast.ai or clore.ai, what do you guys think these people who cracked last couple of puzzles rented those 1000s of GPUs?

Current prices say they should spend around 1.5 million usd to crack 6.9 btc puzzle which is not at all profitable. So, how are they doing it? Stolen/hacked GPU compute?

lost because he used the mempool instead of Mara. Big mistake when it's already been discussed here on how to avoid losing those funds.

Did it, really ?
IMO just a dude copy pasting stuff from his favorite LLM for whatever reason.

@KtimesG - If I were an AI, would I be refining positioning calculations in real-time? is that NON AI for you ?

BTW: WTF has windows 95 anymore

Bad news : you’re delusional.
Good news : you’ll make a lot of friends here.

I get where you're coming from. It's definitely tough to get everyone on the same page, especially when each person has their own theory and approach.

But I'm not trying to enforce centralized control or reach some global agreement.

What I'm suggesting is more like an open infrastructure with a few basic principles. Not rules, just a framework. Some people have idle GPUs, others are strong coders, and some have solid heuristics. If we can bring those strengths together in a flexible system, everyone benefits.

Even if some prefer to work solo, that's completely fine. This doesn't interfere with that. It's simply an option for those who want to collaborate more efficiently.

If even a small group of three to five people are willing to try a structured approach, that's already enough to form a working foundation. From there, it can grow naturally if it proves useful.

import time
import hashlib
from coincurve import PrivateKey
from Crypto.Hash import RIPEMD160
import psutil
import os
import signal
import sys
import multiprocessing as mp
from bloom_filter2 import BloomFilter
from google.colab import drive

# Mount Google Drive
drive.mount('/content/drive')

# Config
File_NAME = "Puzzle 71.013.000.csv"
DRIVE_FOLDER = "/content/drive/MyDrive/Puzzle71"
file_path = f"{DRIVE_FOLDER}/{File_NAME}"
SCAN_RANGE = 100_000
TARGET_PREFIX = "f6f543"
BLOOM_CAPACITY = 1_000_000
BLOOM_ERROR_RATE = 0.001

# Load known H160 hashes into Bloom filter
KNOWN_H160S = [
    "f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8",
]
bloom = BloomFilter(max_elements=BLOOM_CAPACITY, error_rate=BLOOM_ERROR_RATE)
for h in KNOWN_H160S:
    bloom.add(h)

# Read decimal numbers from CSV
with open(file_path, 'r') as f:
    lines = [line.strip() for line in f if line.strip()]
if lines[0].lower().startswith('value'):
    lines = lines[1:]
Decimal_numbers = [int(line) for line in lines]

def privatekey_to_h160(priv_key_int):
    try:
        priv = PrivateKey.from_int(priv_key_int)
        pubkey = priv.public_key.format(compressed=True)
        sha256 = hashlib.sha256(pubkey).digest()
        ripemd160 = RIPEMD160.new(sha256).digest()
        return ripemd160.hex()
    except Exception:
        return None

def optimize_performance():
    try:
        p = psutil.Process()
        if hasattr(p, "cpu_affinity"):
            p.cpu_affinity(list(range(os.cpu_count())))
        if hasattr(psutil, "REALTIME_PRIORITY_CLASS"):
            p.nice(psutil.REALTIME_PRIORITY_CLASS)
        else:
            p.nice(-20)
    except Exception as e:
        print(f"[!] Optimization warning: {e}")

def signal_handler(sig, frame):
    print("\n[!] Interrupted. Exiting.")
    sys.exit(0)

def check_key(k):
    h160 = privatekey_to_h160(k)
    if h160 and (h160.startswith(TARGET_PREFIX) or h160 in bloom):
        return ('match', k, h160)
    return ('progress', k, h160)

def process_decimal(decimal):
    start = max(1, decimal - SCAN_RANGE)
    end = decimal + SCAN_RANGE
    keys = list(range(start, end + 1))

    processed = 0
    start_time = time.time()
    last_key = None
    last_h160 = None

    ctx = mp.get_context("fork")
    with ctx.Pool(processes=os.cpu_count()) as pool:
        result_iter = pool.imap_unordered(check_key, keys, chunksize=1000)

        for result in result_iter:
            if result[0] == 'match':
                _, key, h160 = result
                print(f"\n**PREFIX MATCH FOUND!** Private key {hex(key)} produces Hash160: {h160}\n")
            elif result[0] == 'progress':
                _, key, h160 = result
                processed += 1
                last_key = key
                last_h160 = h160

    elapsed = time.time() - start_time
    speed = processed / elapsed if elapsed > 0 else 0
    print(f"\nHash160 of the last processed key {hex(last_key)} -> {last_h160}")
    print(f"[✓] Completed Decimal: {Decimal} - Processed {processed} keys in {elapsed:.2f}s (Speed: {speed:.2f} keys/sec)")

def main():
    signal.signal(signal.SIGINT, signal_handler)
    optimize_performance()

    print(f"\nLoaded {len(Decimal_numbers)} Decimal numbers.")
    print(f"Scanning ±{SCAN_RANGE} around each.\nTarget prefix: {TARGET_PREFIX}")
    print(f"Bloom filter contains {len(KNOWN_H160S)} known H160 hashes.\n")

    for decimal in decimal_numbers:
        process_decimal(decimal)

if __name__ == '__main__':
    main()


Help me out to use rotor cuda gpu modules able run on colab
Private key to hash 160