(target * k) % N + N - 57896044618658097711785492504343953926418782139537452191302581570759080747169 ) % N

#!/usr/bin/python3
import hashlib, sys

# Constants as regular integers
Gx = int("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798", 16)
Gy = int("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8", 16)
p = int('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f', 16)
n = int('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141', 16)

def private_key_to_public_key(private_key):
    Q = point_multiply(Gx, Gy, private_key, p)
    return Q

def point_multiply(x, y, k, p):
    result = (0, 0)
    addend = (x, y)

    while k > 0:
        if k & 1:
            result = point_add(result, addend, p)
        addend = point_double(addend, p)
        k >>= 1

    return result

def point_double(point, p):
    x, y = point
    lmbda = (3 * x * x * pow(2 * y, -1, p)) % p
    x3 = (lmbda * lmbda - 2 * x) % p
    y3 = (lmbda * (x - x3) - y) % p
    return x3, y3

def point_add(point1, point2, p):
    x1, y1 = point1
    x2, y2 = point2

    if point1 == (0, 0):
        return point2
    if point2 == (0, 0):
        return point1

    if point1 != point2:
        lmbda = ((y2 - y1) * pow(x2 - x1, -1, p)) % p
    else:
        lmbda = ((3 * x1 * x1) * pow(2 * y1, -1, p)) % p

    x3 = (lmbda * lmbda - x1 - x2) % p
    y3 = (lmbda * (x1 - x3) - y1) % p
    return x3, y3

def encode_base58(byte_str):
    __b58chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
    __b58base = len(__b58chars)
    long_value = int.from_bytes(byte_str, byteorder='big')
    result = ''
    while long_value >= __b58base:
        div, mod = divmod(long_value, __b58base)
        result = __b58chars[mod] + result
        long_value = div
    result = __b58chars[long_value] + result

    # Add leading '1's for zero bytes
    nPad = 0
    for byte in byte_str:
        if byte == 0:
            nPad += 1
        else:
            break

    return __b58chars[0] * nPad + result

def public_key_to_hex(public_key, compressed=True):
    x_hex = format(public_key[0], '064x')[2:]  # Remove '0x' prefix
    if compressed:
        # Use '02' prefix if Y coordinate is even, '03' if odd
        prefix = '02' if public_key[1] % 2 == 0 else '03'
        return prefix + x_hex
    else:
        return '04' + x_hex + format(public_key[1], '064x')[2:]

def public_key_to_rmd160_hash(public_key, compressed=True):
    public_key_hex = ('02' if compressed else '04') + format(public_key[0], '064x')
    sha256_hash = hashlib.sha256(bytes.fromhex(public_key_hex)).digest()
    ripemd160_hash = hashlib.new('ripemd160', sha256_hash).digest()
    return ripemd160_hash.hex()

# Define the range
start_range = int("1")
end_range = int("1000000")

target_rmd160_hash = "20d45a6a762535700ce9e0b216e31994335db8a5"
while True:
    for i in range(start_range, end_range + 1):
        public_key = private_key_to_public_key(i)
        rmd160_hash = public_key_to_rmd160_hash(public_key, compressed=True)

        if rmd160_hash == target_rmd160_hash:
            with open('winnerSSS.txt', 'a') as file:
                file.write(f"Private Key (dec): {i}\nRMD160 Hash: {rmd160_hash}\nPublic Key: {public_key}\n\n")
            break

        sys.stdout.write("\033c")
        sys.stdout.write("\033[01;33m")
        sys.stdout.write(f"\r[+] Private Key (dec): {i}\n[+] RMD160 Hash: {rmd160_hash}")
        sys.stdout.flush()

    start_range += 1