LOL, what is this? you really believe #71  starts with 71

UNTESTED!! but surely we can automate Mara withdrawal:

# pip install ecdsa base58 requests selenium webdriver-manager bit
# need bitcrack.exe in same folder
import ecdsa
import hashlib
import base58
import requests
import time
import random
import subprocess
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
from bit import PrivateKey

# =========================== #
#    STEP 0: GENERATE SEED & RUN BITCRACK     #
# =========================== #

def generate_random_seed():
    # Generate a truly random 10-digit number (not starting with 0)
    return random.randint(2113081981, 2113081983)   # default range (1000000000, 9999999999) test#67 (2113081981, 2113081983)

def find_private_key():
    while True:
        # Generate a new random seed for each iteration
        seed_value = generate_random_seed()
        print(f'\nUsing Seed: {seed_value}')

        # Set the random seed
        random.seed(seed_value)

        # Generate a random range for the command
        #67range a = random.randrange(2**30, 2**31) #68range a = random.randrange(2**31, 2**32)
        a = random.randrange(2**30, 2**31)
        random_start = "%00x" % a
        random_range = (random_start + "000000000:" + random_start + "fffffffff")

        # Print the generated seed and range
        print(f'Seed: {seed_value} KHex: {random_start}\n')

        # Run the BitCrack command with the generated range #67 1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9  #68 1MVDYgVaSN6iKKEsbzRUAYFrYJadLYZvvZ
        cmd_command = f'BitCrack.exe -b 128 -t 256 -p 512 -o foundkey.txt --keyspace {random_range} 1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9\n'
        subprocess.call(cmd_command, shell=True)

        # Check if 'foundkey.txt' contains any private key, and if so, exit the loop
        try:
            with open('foundkey.txt', 'r') as f:
                found_data = f.read().strip()
                if found_data:
                    print(f"Private key found: {found_data.split()[1]}")
                    private_key_hex = found_data.split()[1]  # The private key is in the second position
                    return private_key_hex  # Return the private key to proceed to Steps 1-8
        except FileNotFoundError:
            print("Found key file not yet generated.")
       
        # Optional: Add a delay before retrying
        time.sleep(2)

# =========================== #
#    STEP 1: CREATE WALLET    #
# =========================== #

# Get private key from Step 0
private_key_hex = find_private_key()

# Private key in hex format
private_key = PrivateKey.from_hex(private_key_hex)  # Use `bit` library to handle key

btc_address = private_key.address
print(f"Bitcoin Address: {btc_address}")

# =========================== #
#   STEP 2: FETCH BALANCE     #
# =========================== #

api_url = f'https://blockchain.info/rawaddr/{btc_address}'
response = requests.get(api_url)
data = response.json()

balance = data.get('final_balance', 0) / 10**8  # Convert satoshis to BTC
print(f"Balance: {balance:.8f} BTC")

if balance == 0:
    print("No funds available in the address.")

# =========================== #
#   STEP 3: LAST TXs       #
# =========================== #

if "txs" not in data or not data["txs"]:
    print("No transactions found for this address.")
else:
    print("\nLast Transactions:")
    transactions = data["txs"][:1]  # Get the last numberof transactions

    for tx in transactions:
        tx_id = tx["hash"][:10]  # Shorten transaction ID for readability
        print(f"\nTransaction ID: {tx_id}...")

        # SENT Transactions
        sent_any = False
        for output in tx["out"]:
            if output.get("addr") and output["addr"] != btc_address:
                sent_any = True
                print(f"  → Sent to: {output['addr']} | Amount: {output['value'] / 10**8:.8f} BTC")

        if not sent_any:
            print("  → No outgoing transactions in this TX.")

        # RECEIVED Transactions
        received_any = False
        for input_tx in tx["inputs"]:
            if "prev_out" in input_tx and input_tx["prev_out"].get("addr") == btc_address:
                received_any = True
                amount_received = input_tx["prev_out"]["value"] / 10**8  # Convert satoshis to BTC
                print(f"  ← Received from: {input_tx['prev_out']['addr']} | Amount: {amount_received:.8f} BTC")

        if not received_any:
            print("  ← No incoming transactions in this TX.")

# =========================== #
#   STEP 4: FETCH UTXOs       #
# =========================== #

utxos = []
for tx in data["txs"]:
    for output in tx["out"]:
        if output.get("addr") == btc_address and not output.get("spent"):
            utxos.append({"txid": tx["hash"], "vout": output["n"], "value": output["value"]})

if not utxos:
    print("No available UTXOs. Exiting...")
    exit()

# =========================== #
#   STEP 5: SET TARGET & FEES #
# =========================== #

fee_url = 'https://mempool.space/api/v1/fees/recommended'
fee_response = requests.get(fee_url)
fee_data = fee_response.json()
high_fee_rate = fee_data['fastestFee']  # sat/byte
print(f"Using a fee rate of {high_fee_rate} sat/byte")

target_address = "bc1qxfj9gsqpjduvfqyq58rkj6cgngrr672x6nm98f"

# =========================== #
#   STEP 6: CREATE TX         #
# =========================== #

# Calculate total input amount from UTXOs
total_input = sum(utxo["value"] for utxo in utxos)
estimated_size = 10 + (len(utxos) * 180) + (1 * 34) + 10  # Approximate transaction size in bytes
fee = estimated_size * high_fee_rate  # Total fee in satoshis

if total_input <= fee:
    print("Not enough funds to cover transaction fees. Exiting...")
    exit()

send_amount = total_input - fee  # Amount to send after deducting fees

print(f"Total input: {total_input / 10**8:.8f} BTC")
print(f"Transaction fee: {fee / 10**8:.8f} BTC")
print(f"Sending: {send_amount / 10**8:.8f} BTC to {target_address}")

# =========================== #
#   STEP 7: SIGN TRANSACTION  #
# =========================== #

# Create transaction using `bit` library
outputs = [(target_address, send_amount, 'btc')]
signed_tx_hex = private_key.create_transaction(outputs, fee=fee / 10**8, absolute_fee=True)

print("\nRaw Signed Transaction Hex:")
print(signed_tx_hex)

# =========================== #
#   STEP 8: SUBMIT TO SLIPSTREAM #
# =========================== #

service = Service(ChromeDriverManager().install())  # Auto-download latest ChromeDriver
driver = webdriver.Chrome(service=service)
driver.get('https://slipstream.mara.com/')
time.sleep(5)

textarea = driver.find_element("xpath", '//textarea[@placeholder="Paste your raw transaction here"]')
submit_button = driver.find_element("xpath", '//button[text()="Activate Slipstream"]')

textarea.send_keys(signed_tx_hex)
submit_button.click()

time.sleep(5)

print("Transaction submitted successfully to Mara Slipstream. It is not yet broadcasted to the network.")
driver.quit()

Cause I think #68 is inside that range, may not be!

useless_shenanigans part 2:

import hashlib
import time
import sympy
import ecdsa
import base58
import random

# Given constants
var_hash160dec = 1282931445580409769159733555522242769745473092945
min_range = 242965459430942930354
max_range = 276313659744993920795
addr = '1MVDYgVaSN6iKKEsbzRUAYFrYJadLYZvvZ'

def match(pk):
    pub_key = ecdsa.SigningKey.from_string(
        pk.to_bytes(32, 'big'), curve=ecdsa.SECP256k1
    ).verifying_key.to_string('compressed')

    return h160 == hashlib.new(
        'ripemd160', hashlib.sha256(pub_key).digest()).digest()

def gen_subproducts(factors, seen: set, idx=0, prod=1):
    if idx == len(factors):
        if prod > 1 and prod not in seen:
            seen.add(prod)
            if match(prod):
                print(f'Key found: {hex(prod)}')
                with open("foundkey.txt", "w") as f:
                    f.write(f"Private key: {hex(prod)}")
                exit()
        return

    factor, exp = factors[idx]
    for i in range(exp + 1):
        if gen_subproducts(factors, seen, idx + 1, prod * (factor ** i)):
            return True

def generate_n():
    rand_divisor = random.randint(min_range, max_range)
    return (var_hash160dec // rand_divisor) * rand_divisor

# Decode target H160
h160 = base58.b58decode_check(addr)[1:]
print(f'Target H160: {h160.hex():>040s}')

while True:
    n = generate_n()
    print(f'Trying n = {n}')
   
    factors = list(sympy.factorint(n).items())
    seen = set()
   
    if gen_subproducts(factors, seen):
        break

@Zahid888  multiple seeds between (1000000000, 9999999999) will manage to get the same correct privkey!

Do you have any idea how many seeds there are that would be able to get the same privkey if looking for #67 ?

@zahid888

I dont understand how you get your seeds are you just randomizing them? I update your code for multiple GPUs:

import random
import subprocess

while True:
    x = input('seed integer : ')
    seed_value = int(x)
    random.seed(seed_value)
    seed = str(seed_value)
    a = random.randrange(2**31, 2**32)
    random_start = "%00x" % a
    random_range = (random_start+"000000000:"+random_start+"fffffffff")
    print('\nSeed : ' + str(x) + ' KHex : ' + str(random_start) + '\n')
    cmd_command =('VanitySearch-1.15.4_bitcrack_th512gr -stop -t 0 -gpu -gpuId 0,1,2,3,4,5,6,7 --keyspace '+random_range+' 1MVDYgVaSN6iKKEsbzRUAYFrYJadLYZvvZ\n')
    subprocess.call(cmd_command, shell=True)

Hey I like Magic-based methods , I still have the wheel of fortune!

I see, one more question how many GPUs did you use to find it?

@Bram24732  Are you truely the finder of #67 , if so may I ask how long did it take to search and what app did you use to search?

Someone sent those amounts to #66 about 5 days ago https://www.blockchain.com/explorer/addresses/btc/13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
That person thought it was a clue to #67 but just looked like nonsense to me, Maybe it was a clue cause now #67 is solved! who knows?!

I thought maybe finder was just testing Mara slipstream but was not cause checked mempool Foundry USA and Antpool.

Lol, creator is thinking???
#68
147573952589676412928
295147905179352825855
8+5=D  so does #68 start with D ?

#67 1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9
00000000000000000000000000000000000000000000000730fc235c1942c1ae
KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qbP2K5cm35XKMND1X1KW

Well done, I think he must have insane amount of GPUs! unlike #66 I was close to #67 solution was searching just a bit too high

Ok I see what you did but for #67 why color 7 , 6+9=f ,  6+1=7 ?

Could you share more details of what this is?
I don't understand what you are trying to show with #100 all I can see is that you think #67 privkey starts with a 7 according to this?

#67 range is  73.79 quintillion
#68 range is 147.57 quintillion
#69 range is 295.15 quintillion

73.79 quintillion = 73790000000000000000

your new houshold Pc can prob do 8 Mkeys/s without high end GPU!

so about 292,277 years or  148,639 years for 50% of the range in #67 to answer your question!

Could you explain more how you were doing this?

Deepseek how do you know bc1qgp48hjxp9uctzysq458dtlhk7ewtf9k4xpjpjj is the creator, their reason for sending 184USD TO #66 is not clear, but you are assuming it is a clue to #67?

Also if it was a clue why ignore the zeros, 0.00189717 = 0.007C553B1ADE27BE0A11   and 0.00010392  =  0.0006CF7D005BC5789A9B

I think you stretching cause as far as I know nobody ever correctly guessed #66 started with 283 , how could they guess #67 but not #66

What do you all think #67 hex starts with?

#66 I don't believe in randomization, no one can be that lucky! also brute force from the start would of required around 700 billion keys per sec to find in 2years
I think the finder knew exactly the hex started with 2832 or had some mathematical way of working out a starting point of 283 for 000000000000000000000000000000000000000000000002832ed74f2b5e35ee
How do you think they found it?

I wish I had, it was Shelby0901 who said he could access 900x RTX4090!

No 4billion per second is slow but that is the best a GPU can do for brute force as far as I know.

900x RTX4090 if you had honest access to that:
I could provide this data it would take 32hours to search each iteration using 900 x RTX4090 at 4billion keys per second each
#66:2832ED74F2B5E35EE
66 time: 37182835143040325629 (Hex: 20403f78f3ad457fd) (Max Hex: 209b6db1432852513)
...
80 time: 44727178505396333728 (Hex: 26cb6dbe03ba2aca0) (Max Hex: 27269bf65335379b6)
81 time: 45266060174136048592 (Hex: 2743159e604d5fbd0) (Max Hex: 279e43d6afc86c8e6)
82 time: 45804941842875763457 (Hex: 27babd7ebce094b01) (Max Hex: 2815ebb70c5ba1817)
83 time: 46343823511615478321 (Hex: 2832655f1973c9a31) (Max Hex: 288d939768eed6747)
84 time: 46882705180355193185 (Hex: 28aa0d3f7606fe961) (Max Hex: 29053b77c5820b677)
85 time: 47421586849094908049 (Hex: 2921b51fd29a33891) (Max Hex: 297ce3582215405a7)
86 time: 47960468517834622913 (Hex: 29995d002f2d687c1) (Max Hex: 29f48b387ea8754d7)
87 time: 48499350186574337778 (Hex: 2a1104e08bc09d6f2) (Max Hex: 2a6c3318db3baa408)
88 time: 49038231855314052642 (Hex: 2a88acc0e853d2622) (Max Hex: 2ae3daf937cedf338)
89 time: 49577113524053767506 (Hex: 2b0054a144e707552) (Max Hex: 2b5b82d9946214268)
90 time: 50115995192793482370 (Hex: 2b77fc81a17a3c482) (Max Hex: 2bd32ab9f0f549198)
...
133 time: 73287906948601221531 (Hex: 3f912f312e342119b) (Max Hex: 3fec5d697daf2deb1)

#66 has 68 iterations would of been a 2176 hours without pubkey for all but it would of been found after 544 hours
#67 has 60 iterations 1920 hours
#68 has 62 iterations 1984 hours
#69 has 73 iterations 2336 hours
so Im saying max 6240 hours or 260 days to find #67 ,#68 and #69 if I had 900x RTX4090s

#70:349B84B6431A6C4EF1  has 98 iterations 3136 hours without pubkey but it would of been found at 2048hours
158 time: 970026333328748806619 (Hex: 3495d1d2be22bb81db) (Max Hex: 349b84b6431a6c4ef1)
Currently it would take me 2970days just to search 1 iteration so 900x RTX4090 is insane amount