Bitcoin Forum

Bi: 13806, Pp: 010101010101010, Tb: 13821

Bi: 10889, Pp: 101010101010101, Tb: 24725

Bi: 10637, Pp: 101010101010101, Tb: 35377

Bi: 186843, Pp: 010101010101010, Tb: 222235

#@mcdouglasx
import secp256k1 as ice
import random
import regex as re
from bitarray import bitarray
import sys

target_public_key = "0339d69444e47df9bd7bb7df2d234185293635a41f0b0c7a4c37da8db5a74e9f21"

num_keys = 120000000
subtract = 1
low_m = num_keys // 1000000
lm = num_keys // low_m

db_name = "patt_db.txt"

patternx = re.compile(r'((10)+1|(01)+0)')

def process_res(res, lm, prev_bits=None):
    binary = bitarray()
    if prev_bits:
        binary.extend(prev_bits)
    
    for t in range(lm):
        segment = res[t*65:t*65+65]
        bit = '0' if int(segment.hex()[2:], 16) % 2 == 0 else '1'
        binary.append(bit == '1')
    
    return binary

def count_patterns(binary_bits, total_bits):
    matches = patternx.finditer(binary_bits.to01())
    last_end = 0
    for match in matches:
        pattern = match.group()
        if len(pattern) >= 15:
            bits_between = match.start() - last_end
            total_bits += bits_between + len(pattern)
            last_end = match.end()
            with open(db_name, 'a') as f:
                f.write(f"Bi: {bits_between}, Pp: {pattern}, Tb: {total_bits}\n")
    
    remaining_bits = len(binary_bits) - last_end
    next_prev_bits = binary_bits[-remaining_bits:]
    
    return total_bits, next_prev_bits

print("Making DataBase")

target = ice.pub2upub(target_public_key)
subtract_pub = ice.scalar_multiplication(subtract)
prev_bits = None
total_bits = 0  

for i in range(low_m):
    sys.stdout.write(f"\rprogress: {i + 1}/{low_m}")
    sys.stdout.flush()
    lm_i = lm * i
    lm_upub = ice.scalar_multiplication(lm_i)
    A1 = ice.point_subtraction(target, lm_upub)
    res = ice.point_loop_subtraction(lm, A1, subtract_pub)
    binary_bits = process_res(res, lm, prev_bits)
    total_bits, prev_bits = count_patterns(binary_bits, total_bits)

print("\nDone!")

#@mcdouglasx
import secp256k1 as ice
import random
import regex as re
from bitarray import bitarray
import time

print("Searching Binary Patterns")

#Pk: 10056435896
#0339d69444e47df9bd7bb7df2d234185293635a41f0b0c7a4c37da8db5a74e9f21

Target_pub ="0339d69444e47df9bd7bb7df2d234185293635a41f0b0c7a4c37da8db5a74e9f21"
#range 
start = 10000000000                                                                                
end =  12000000000                                      


with open('patt_db.txt', 'r') as Db:
    target = Db.readlines()

patternx = re.compile(r'((10)+1|(01)+0)')

def process_res(res, low_m):
    binary = bitarray()
    
    for t in range(low_m):
        segment = res[t*65:t*65+65]
        bit = '0' if int(segment.hex()[2:], 16) % 2 == 0 else '1'
        binary.append(bit == '1')
    
    return binary

def count_patterns(binary_bits, Rand, start_time):
    matches = patternx.finditer(binary_bits.to01())
    last_end = 0
    last_match_info = None
    
    for match in matches:
        pattern = match.group()
        if len(pattern) >= 15:
            bits_between = match.start() - last_end
            total_bits = match.start()  
            
            last_end = match.end()
            
            X = f"Bi: {bits_between}, Pp: {pattern}"
            for t in target:
                if X in t:
                    Tb_in_t = int(t.split(", Tb: ")[1].split(",")[0])
                    pk = (Rand - total_bits + Tb_in_t)-len(pattern)
                    pk_f = ice.scalar_multiplication(pk).hex()
                    cpub = ice.to_cpub(pk_f)
                    if cpub in Target_pub:
                        last_match_info = f"Rand: {Rand} Bi: {bits_between}, Pp: {pattern}, Tb: {total_bits}, T: {t.strip()}, pk: {pk}"
                  
    
    if last_match_info:
        pk_f = ice.scalar_multiplication(pk).hex()
        cpub = ice.to_cpub(pk_f) 
        elapsed_time = time.time() - start_time
        print("pk:", pk)
        print("cpub:", cpub)
        print("Elapsed time:", elapsed_time, "seconds")
        
        with open('found.txt', 'a') as f:
            f.write(f"pk: {pk}\n")
            f.write(f"cpub: {cpub}\n")
            f.write(f"Elapsed time: {elapsed_time} seconds\n")       
        exit()

low_m = 100000
sustract = 1
sustract_pub = ice.scalar_multiplication(sustract)        
start_time = time.time()

while True:
    
    Rand = random.randint(start, end)
    pk = ice.scalar_multiplication(Rand)
    res = ice.point_loop_subtraction(low_m, pk, sustract_pub)
    binary_bits = process_res(res, low_m)
    count_patterns(binary_bits, Rand, start_time)
    

0111000101100000000110100010100111111111111111010011111101100101 (from key 1 Left to key 64 right    ITEM 1)
1011100010010000011110001100000100001010110011100111101011111110 (from key 65 left to key 128 right  ITEM 2)
1001000001111101101101111001000001101111010010000101000001011010 (from key 129 left to key 192 right ITEM 3)
...
etc up to some Gigabytes of data   (ITEM N)

1110001011000000001101000101001111111111111110100111111011001011 from 2 to 65 (Bloom filter query: false)
1100010110000000011010001010011111111111111101001111110110010110 from 3 to 66 (Bloom filter query: false)
1000101100000000110100010100111111111111111010011111101100101101 from 4 to 67 (Bloom filter query: false)
0001011000000001101000101001111111111111110100111111011001011011 from 5 to 68 (Bloom filter query: false)
...
1011100010010000011110001100000100001010110011100111101011111110 from 65 to 128 (Bloom filter query: True -> HIT!!)

Bi: 10, Pp: 010101010101010, Tb: 25
Bi: 149,975, Pp: 01010101010101010, Tb: 150,017

import random

target = "11234567890987654321"

start = 10000000
end =   20000000

start_b =10
end_b =  20
count_original= 0
count_light= 0
for i in range(10):
    
    for i in range (10):

        for i in range(1000000):
            a =(str(random.randint(start, end))+"890987654321")
            if a == target:
                
                count_original += 1
        for i in range(5):
            a =(str(random.randint(start_b, end_b))+"234567890987654321")
            if a == target:
                
                count_light += 1
                
    print("db original:", count_original)
    print("db light:", count_light)

import math
import time
import sys
import os
import pickle
import subprocess
import gc
from gmpy2 import mpz, powmod, invert, jacobi
import xxhash
from sortedcontainers import SortedDict

# Clear screen and initialize
os.system("cls||clear")
t = time.ctime()
sys.stdout.write(f"\033[?25l\033[01;33m[+] BSGS: {t}\n")
sys.stdout.flush()

# Elliptic Curve Parameters (secp256k1)
modulo = mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
order = mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141)
Gx = mpz(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
Gy = mpz(0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)
PG = (Gx, Gy)

# Point Addition on Elliptic Curve
def add(P, Q):
    if P == (0, 0):
        return Q
    if Q == (0, 0):
        return P
    Px, Py = P
    Qx, Qy = Q
    if Px == Qx:
        if Py == Qy:
            inv_2Py = invert((Py << 1) % modulo, modulo)
            m = (3 * Px * Px * inv_2Py) % modulo
        else:
            return (0, 0)
    else:
        inv_diff_x = invert(Qx - Px, modulo)
        m = ((Qy - Py) * inv_diff_x) % modulo
    x = (m * m - Px - Qx) % modulo
    y = (m * (Px - x) - Py) % modulo
    return (x, y)

# Scalar Multiplication using Montgomery Ladder
def mul(k, P=PG):
    R0, R1 = (0, 0), P
    for i in reversed(range(k.bit_length())):
        if (k >> i) & 1:
            R0, R1 = add(R0, R1), add(R1, R1)
        else:
            R1, R0 = add(R0, R1), add(R0, R0)
    return R0

# Point Subtraction
def point_subtraction(P, Q):
    Q_neg = (Q[0], (-Q[1]) % modulo)
    return add(P, Q_neg)

# Compute Y from X using curve equation
def X2Y(X, y_parity, p=modulo):
    X3_7 = (pow(X, 3, p) + 7) % p
    if jacobi(X3_7, p) != 1:
        return None
    Y = powmod(X3_7, (p + 1) >> 2, p)
    return Y if (Y & 1) == y_parity else (p - Y)

# Convert point to compressed public key
def point_to_cpub(point):
    x, y = point
    y_parity = y & 1
    prefix = '02' if y_parity == 0 else '03'
    compressed_pubkey = prefix + format(x, '064x')
    return compressed_pubkey

# Hash a compressed public key using xxhash and store only the first 8 characters
def hash_cpub(cpub):
    return xxhash.xxh64(cpub.encode()).hexdigest()[:8]

# Optimized function to pack the hash into bits using segments
def pack_hash_into_bits(cpub, segment_size=8):
    # Hash the compressed public key
    hash_result = hash_cpub(cpub)
    
    # Convert the hash result to bytes
    hash_bytes = bytes.fromhex(hash_result)
    
    # Initialize an empty list to store the bits
    binary = []
    
    # Iterate over the hash bytes in chunks of segment_size
    for i in range(0, len(hash_bytes), segment_size):
        segment = hash_bytes[i:i + segment_size]
        
        # Convert the segment to a single integer
        segment_int = int.from_bytes(segment, byteorder='big')
        
        # Extract the least significant bit (LSB) and append to the list
        binary.append((segment_int & 1) == 1)
    
    return binary

# Save baby table to a file compressed with pigz at compression level 7 and custom block size
def save_baby_table(baby_table, filename='baby_table.pgz', block_size=128):
    serialized_data = pickle.dumps(baby_table, protocol=pickle.HIGHEST_PROTOCOL)
    with subprocess.Popen(['pigz', '-7', '-b', str(block_size), '-c'], stdin=subprocess.PIPE, stdout=open(filename, 'wb')) as proc:
        proc.communicate(input=serialized_data)
    print(f"[+] Baby table saved")

# Load baby table from a compressed file
def load_baby_table(filename='baby_table.pgz'):
    print(f"[+] Loading baby table...")
    try:
        with subprocess.Popen(['pigz', '-d', '-c', filename], stdout=subprocess.PIPE) as proc:
            serialized_data = proc.stdout.read()
        baby_table = pickle.loads(serialized_data)
        print(f"[+] Baby table loaded successfully with {len(baby_table)} entries")
        return baby_table
    except Exception as e:
        print(f"[error] Failed to load baby table: {e}")
        return None

# Delete existing baby table if it exists
def delete_existing_table(filename='baby_table.pgz'):
    if os.path.exists(filename):
        os.remove(filename)

# Main Script
if __name__ == "__main__":
    # Puzzle Parameters
    puzzle = 40
    start_range = 2**(puzzle-1)
    end_range = (2**puzzle) - 1
    puzzle_pubkey = '03a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4'

    # Parse Public Key
    if len(puzzle_pubkey) != 66:
        print("[error] Public key length invalid!")
        sys.exit(1)
    prefix = puzzle_pubkey[:2]
    X = mpz(int(puzzle_pubkey[2:], 16))
    y_parity = int(prefix) - 2
    Y = X2Y(X, y_parity)
    if Y is None:
        print("[error] Invalid compressed public key!")
        sys.exit(1)
    P = (X, Y)  # Uncompressed public key

    # Precompute m and mP for BSGS
    m = int(math.floor(math.sqrt(end_range - start_range)))
    m_P = mul(m)

    # Delete existing baby table if it exists
    delete_existing_table('baby_table.pgz')

    # Create Baby Table with SortedDict
    print('[+] Creating babyTable...')
    baby_table = SortedDict()
    Ps = (0, 0)  # Start with the point at infinity
    for i in range(m + 1):
        cpub = point_to_cpub(Ps)
        cpub_hash = hash_cpub(cpub)
        binary_bits = pack_hash_into_bits(cpub)
        baby_table[cpub_hash] = (i, binary_bits)
        Ps = add(Ps, PG)

    # Save the baby table to a file
    save_baby_table(baby_table, 'baby_table.pgz', block_size=128)

    # Force reload from file by deleting the in-memory table and freeing memory
    del baby_table
    gc.collect()

    # Load the baby table from the file
    baby_table = load_baby_table('baby_table.pgz')
    if baby_table is None:
        print("[error] Failed to load baby table. Exiting...")
        sys.exit(1)

    # BSGS Search
    print('[+] BSGS Search in progress')
    S = point_subtraction(P, mul(start_range))
    step = 0
    st = time.time()
    while step < (end_range - start_range):
        cpub = point_to_cpub(S)
        cpub_hash = hash_cpub(cpub)
        if cpub_hash in baby_table:
            b, binary_bits = baby_table[cpub_hash]
            k = start_range + step + b
            if point_to_cpub(mul(k)) == puzzle_pubkey:
                print(f'[+] m={m} step={step} b={b}')
                print(f'[+] Key found: {k}')
                print("[+] Time Spent : {0:.2f} seconds".format(time.time() - st))
                sys.exit()
        S = point_subtraction(S, m_P)
        step += m

    print('[+] Key not found')
    print("[+] Time Spent : {0:.2f} seconds".format(time.time() - st))

import math
import time
import os
import secp256k1 as ice


# Main Script
if __name__ == "__main__":
    # Puzzle Parameters
    puzzle = 45
    start_range = 2**(puzzle-1)
    end_range = (2**puzzle) - 1
    puzzle_pubkey = '026ecabd2d22fdb737be21975ce9a694e108eb94f3649c586cc7461c8abf5da71a'

    P = ice.pub2upub(puzzle_pubkey)

    # Precompute m and mP for BSGS
    m = int(math.floor(math.sqrt(end_range - start_range)))
    m = m * 20  # for use in bsgs_2nd
    m_P = ice.scalar_multiplication(m)
    m_Pn = ice.point_negation(m_P)
    m2 = math.ceil((end_range - start_range)/m)
    print(f'[+] m={m} m2={m2} Puzzle={puzzle}')
    
    if os.path.isfile('baby_table.2nd') == False:
        print(f'[+] Preparing for BSGS Table with {m} elements in RAM')
        ice.bsgs_2nd_check_prepare(m)
        ice.dump_bsgs_2nd('baby_table.2nd', True)
    else:
        ice.load_bsgs_2nd('baby_table.2nd', True)
        


    # BSGS Search
    print('[+] BSGS Search in progress')
    st = time.time()
    S = ice.point_subtraction(P, ice.scalar_multiplication(start_range))
    found, pvk = ice.bsgs_2nd_check(S, 1)
    if found == True:
        k = start_range + int.from_bytes(pvk, 'big')
        print(f'FOUND PrivateKey: {k:064x}')
        print(f"[+] Time Spent : {time.time() - st:.2f} seconds")
        exit()
        
    ice.init_P2_Group(m_Pn) # Negative for P2_mcpu
    SL = ice.point_sequential_increment_P2_mcpu(m2, S) # succesive decrement
    found, pvk = ice.bsgs_2nd_check_mcpu(SL, 1)
    if int.from_bytes(found, 'big') > 0:
        elapsed = time.time() - st
        for i in range(m2):
            if found[i] == 1:
                print(f'start=[0x{start_range:0x}] [i={i}] idx=0x{int.from_bytes(pvk[i*32:(i+1)*32], "big"):0x} ')
                k = start_range + (i+1) * m + int.from_bytes(pvk[i*32:(i+1)*32], 'big')
                print(f'FOUND PrivateKey: {k:064x}')
                print(f"[+] Time Spent : {elapsed:.2f} seconds")
                exit()

    print('[+] Key not found')
    print(f"[+] Time Spent : {time.time() - st:.2f} seconds")

python ULWD_bsgs.py
[+] m=83886060 m2=209716 Puzzle=45
[+] Preparing for BSGS Table with 83886060 elements in RAM
Calculating      : 100 %
[+] [N2:4194500, N3:209725, N4:10486]  Vec4th Size    : 10486
[+] [bloom2nd (14 MB)] [bloom3rd (0 MB)] [bloom4th (0 MB)]
[+] BSGS Search in progress
start=[0x100000000000] [i=28660] idx=0x11cfb29
FOUND PrivateKey: 0000000000000000000000000000000000000000000000000000122fca143c05
[+] Time Spent : 2.80 seconds

#include <iostream>
#include <fstream>
#include <vector>
#include <unordered_map>
#include <cmath>
#include <gmpxx.h>
#include <chrono>
#include <cassert>
#include <cstdio>
#include <sys/stat.h>
#include <xxhash.h>

using namespace std;

typedef array<mpz_class, 2> Point;

const mpz_class modulo("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16);
const mpz_class order("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16);
const mpz_class Gx("79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", 16);
const mpz_class Gy("483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8", 16);
const Point PG = {Gx, Gy};
const Point Z = {0, 0};

auto starttime = chrono::high_resolution_clock::now();

inline Point add(const Point& P, const Point& Q, const mpz_class& p = modulo) {
    if (P == Z) return Q;
    if (Q == Z) return P;
    const mpz_class& P0 = P[0];
    const mpz_class& P1 = P[1];
    const mpz_class& Q0 = Q[0];
    const mpz_class& Q1 = Q[1];
    mpz_class lmbda, num, denom, inv;
    if (P != Q) {
        num = Q1 - P1;
        denom = Q0 - P0;
    } else {
        if (P1 == 0) return Z;
        num = 3 * P0 * P0;
        denom = 2 * P1;
    }
    mpz_invert(inv.get_mpz_t(), denom.get_mpz_t(), p.get_mpz_t());
    lmbda = (num * inv) % p;
    mpz_class x = (lmbda * lmbda - P0 - Q0) % p;
    if (x < 0) x += p;
    mpz_class y = (lmbda * (P0 - x) - P1) % p;
    if (y < 0) y += p;
    return {x, y};
}

inline Point mul(const mpz_class& k, const Point& P = PG, const mpz_class& p = modulo) {
    Point R0 = Z, R1 = P;
    unsigned long bit_length = mpz_sizeinbase(k.get_mpz_t(), 2);
    for (unsigned long i = bit_length - 1; i < bit_length; --i) {
        if (mpz_tstbit(k.get_mpz_t(), i)) {
            R0 = add(R0, R1, p);
            R1 = add(R1, R1, p);
        } else {
            R1 = add(R0, R1, p);
            R0 = add(R0, R0, p);
        }
    }
    return R0;
}

inline Point point_subtraction(const Point& P, const Point& Q) {
    Point Q_neg = {Q[0], (-Q[1]) % modulo};
    return add(P, Q_neg);
}

inline mpz_class X2Y(const mpz_class& X, int y_parity, const mpz_class& p = modulo) {
    mpz_class X_cubed = (X * X * X) % p;
    mpz_class tmp = (X_cubed + mpz_class(7)) % p;
    mpz_class Y;
    mpz_class exp = (p + mpz_class(1)) / mpz_class(4);
    mpz_powm(Y.get_mpz_t(), tmp.get_mpz_t(), exp.get_mpz_t(), p.get_mpz_t());
    if ((Y % 2) != y_parity) {
        Y = p - Y;
    }
    return Y;
}

inline std::string point_to_cpub(const Point& point) {
    mpz_class x = point[0], y = point[1];
    int y_parity = y.get_ui() & 1;
    std::string prefix = y_parity == 0 ? "02" : "03";
    char buffer[65];
    mpz_get_str(buffer, 16, x.get_mpz_t());
    return prefix + std::string(buffer);
}

inline std::string hash_cpub(const std::string& cpub) {
    XXH64_hash_t hash = XXH64(cpub.c_str(), cpub.size(), 0);
    char buffer[17];
    snprintf(buffer, sizeof(buffer), "%016lx", hash);
    return std::string(buffer, 8);
}

void save_baby_table(const std::unordered_map<std::string, int>& baby_table, const std::string& filename = "baby_table") {
    std::ofstream outfile(filename, std::ios::binary);
    if (!outfile) {
        std::cerr << "[error] Failed to open file for writing." << std::endl;
        return;
    }
    for (const auto& entry : baby_table) {
        outfile.write(entry.first.c_str(), 8);
        int index = entry.second;
        outfile.write(reinterpret_cast<const char*>(&index), sizeof(index));
    }
    std::cout << "[+] Baby table saved" << std::endl;
    std::string command = "pigz -7 -b 128 -f " + filename;
    FILE* pipe = popen(command.c_str(), "r");
    if (!pipe) {
        std::cerr << "[error] Failed to compress file." << std::endl;
        return;
    }
    pclose(pipe);
    std::cout << "[+] File compressed: " << filename << ".gz" << std::endl;
}

std::unordered_map<std::string, int> load_baby_table(const std::string& filename = "baby_table") {
    std::string command = "pigz -d -c " + filename + ".gz";
    FILE* pipe = popen(command.c_str(), "r");
    if (!pipe) {
        std::cerr << "[error] Failed to decompress file." << std::endl;
        return {};
    }
    std::unordered_map<std::string, int> baby_table;
    char key_buffer[9];
    int index;
    while (fread(key_buffer, 8, 1, pipe) == 1) {
        key_buffer[8] = '\0';
        fread(&index, sizeof(index), 1, pipe);
        baby_table[key_buffer] = index;
    }
    pclose(pipe);
    std::cout << "[+] Baby table loaded successfully with " << baby_table.size() << " entries" << std::endl;
    return baby_table;
}

void delete_existing_table(const std::string& filename = "baby_table") {
    struct stat buffer;
    if (stat(filename.c_str(), &buffer) == 0) {
        if (std::remove(filename.c_str()) != 0) {
            std::cerr << "[error] Failed to delete existing table." << std::endl;
        }
    }
    std::string compressed_filename = filename + ".gz";
    if (stat(compressed_filename.c_str(), &buffer) == 0) {
        if (std::remove(compressed_filename.c_str()) != 0) {
            std::cerr << "[error] Failed to delete compressed table." << std::endl;
        }
    }
}

int main() {
    int puzzle = 40;
    mpz_class start_range = mpz_class(1) << (puzzle - 1);
    mpz_class end_range = (mpz_class(1) << puzzle) - 1;
    std::string puzzle_pubkey = "03a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4";
   
    time_t currentTime = time(nullptr);
    cout << "\r\033[01;33m[+]\033[32m BSGS: \033[01;33m" << ctime(&currentTime) << "\033[0m" << "\r";
    cout << "[+] [Puzzle]: " << puzzle << endl;
   
    if (puzzle_pubkey.length() != 66) {
        std::cerr << "[error] Public key length invalid!" << std::endl;
        return 1;
    }
    std::string prefix = puzzle_pubkey.substr(0, 2);
    mpz_class X(puzzle_pubkey.substr(2), 16);
    int y_parity = std::stoi(prefix) - 2;
    mpz_class Y = X2Y(X, y_parity);
    if (Y == 0) {
        std::cerr << "[error] Invalid compressed public key!" << std::endl;
        return 1;
    }
    Point P = {X, Y};

    mpz_class m = sqrt(end_range - start_range);
    Point m_P = mul(m);

    delete_existing_table("baby_table");

    std::cout << "[+] Creating babyTable..." << std::endl;
    std::unordered_map<std::string, int> baby_table;
    Point Ps = Z;
    for (unsigned long i = 0; i <= m.get_ui(); ++i) {
        std::string cpub = point_to_cpub(Ps);
        std::string cpub_hash = hash_cpub(cpub);
        baby_table[cpub_hash] = i;
        Ps = add(Ps, PG);
    }

    save_baby_table(baby_table, "baby_table");

    baby_table.clear();

    baby_table = load_baby_table("baby_table");
    if (baby_table.empty()) {
        std::cerr << "[error] Failed to load baby table. Exiting..." << std::endl;
        return 1;
    }

    std::cout << "[+] BSGS Search in progress" << std::endl;
    Point S = point_subtraction(P, mul(start_range));
    mpz_class step = 0;
    auto st = std::chrono::high_resolution_clock::now();
    while (step < (end_range - start_range)) {
        std::string cpub = point_to_cpub(S);
        std::string cpub_hash = hash_cpub(cpub);
        auto it = baby_table.find(cpub_hash);
        if (it != baby_table.end()) {
            int b = it->second;
            mpz_class k = start_range + step + b;
            if (point_to_cpub(mul(k)) == puzzle_pubkey) {
                std::cout << "[+] m=" << m << " step=" << step << " b=" << b << std::endl;
                std::cout << "[+] Key found: " << k << std::endl;
                auto et = std::chrono::high_resolution_clock::now();
                std::chrono::duration<double> elapsed = et - st;
                std::cout << "[+] Time Spent : " << elapsed.count() << " seconds" << std::endl;
                return 0;
            }
        }
        S = point_subtraction(S, m_P);
        step += m;
    }

    std::cout << "[+] Key not found" << std::endl;
    auto et = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> elapsed = et - st;
    std::cout << "[+] Time Spent : " << elapsed.count() << " seconds" << std::endl;
    return 0;
}

sudo apt install build-essential

sudo apt install libgmp-dev

sudo apt install libxxhash-dev

sudo apt install pigz

g++ -o bsgs bsgs.cpp -m64 -march=native -mtune=native -Wall -ftree-vectorize -flto -O3 -funroll-loops -fomit-frame-pointer -fno-rtti -lgmp -lgmpxx -lxxhash

    mpz_class m = sqrt(end_range - start_range);
    m = m * 4;
    Point m_P = mul(m);