(install all import needed (pip install os , pip install codecs , pip install hashlib , pip install base58 , pip install ecdsa )

1.first create file find.txt in new folder
2.create new file named decode.py
3.in decode.py tag this code python
4.go on code and remplace the line taged private key hex here dont dont errase ("")
5.at the end of your private key hex add ***** for preset your 5 chars loss
6.run the code with ( python decode.py ) and just wait the end of your try
7.for succes find pay me at this addresse   bc1qzk2xnjrf2h87h3p2cn344wfc92l0jz7seq886w
8.thanck you at the next time

import os
import codecs
import hashlib
import base58
import ecdsa

def generer_sequences():
    caracteres = "0123456789ABCDEF"
    sequences = [c1 + c2 + c3 + c4 + c5 for c1 in caracteres for c2 in caracteres for c3 in caracteres for c4 in caracteres for c5 in caracteres]
    return sequences

def remplacer_caracteres(chaine_originale, sequence):
    nouvelle_chaine = ""
    index_sequence = 0

    for caractere in chaine_originale:
        if caractere == '*':
            nouvelle_chaine += sequence[index_sequence]
            index_sequence = (index_sequence + 1) % len(sequence)
        else:
            nouvelle_chaine += caractere

    return nouvelle_chaine

def private_key_to_wif(private_key_hex: str) -> str:
    extended_key = "80" + private_key_hex
    first_sha256 = hashlib.sha256(codecs.decode(extended_key, 'hex')).hexdigest()
    second_sha256 = hashlib.sha256(codecs.decode(first_sha256, 'hex')).hexdigest()
    final_key = codecs.decode(extended_key + second_sha256[:8], 'hex')
    return base58.b58encode(final_key).decode('utf-8')

def private_key_to_address(private_key_hex: str) -> str:
    sk = ecdsa.SigningKey.from_string(codecs.decode(private_key_hex, 'hex'), curve=ecdsa.SECP256k1)
    vk = sk.get_verifying_key()
    public_key = b'\x04' + vk.to_string()
    hash160 = hashlib.new('ripemd160')
    hash160.update(hashlib.sha256(public_key).digest())
    hash160 = hash160.digest()
    return base58.b58encode_check(b"\x00" + hash160).decode('utf-8')

# Génération des séquences
sequences = generer_sequences()

# Chaîne d'origine
chaine_originale = "private key hex here"

# Itération sur les séquences
for i, sequence in enumerate(sequences, start=1):
    # Chaîne modifiée
    chaine_modifiee = remplacer_caracteres(chaine_originale, sequence)

    # Vérifier la longueur de la chaîne modifiée
    if len(chaine_modifiee) != 64:
        print(f"Erreur : La chaîne modifiée a une longueur incorrecte ({len(chaine_modifiee)} caractères).")
        break

    # Conversion de la chaîne modifiée en clé privée WIF
    cle_privee_wif = private_key_to_wif(chaine_modifiee)

    # Conversion de la clé privée en adresse Bitcoin
    try:
        adresse_bitcoin = private_key_to_address(chaine_modifiee)

        # Adresse Bitcoin fournie
        adresse_fournie = "1KDUcZh5Z6H1of4Pwoy5ojJtkQxcQBHhnH"

        # Vérification si les adresses sont identiques
        if adresse_bitcoin == adresse_fournie:
            # Enregistrement dans le fichier find.txt
            with open("find.txt", "w") as fichier:
                fichier.write(f"Clé privée WIF   : {cle_privee_wif}\n")
                fichier.write(f"Adresse Bitcoin  : {adresse_bitcoin}\n")
            print("Clé privée WIF et adresse enregistrées dans find.txt")
            break  # Arrête la boucle après avoir trouvé une correspondance
        else:
            print(f"Les adresses ne sont pas identiques pour la séquence {sequence}. (Essai {i})")
    except ecdsa.errors.MalformedPointError as e:
        print(f"Erreur : {e}")