Bitcoin puzzle transaction ~32 BTC prize to who solves it

[mcdouglasx]

What the creator should do is send 1 btc to me🤣...

Seriously speaking, the creator must reveal the solved puzzles that were emptied, because what do we know if, for example, the puzzles are not in the range we believe? If he had a mistake when creating 256 puzzles (he corrected it, years later), he could having made the mistake of putting some keys in other ranges, or worse still it could be a big joke and he himself has emptied the last unrevealed puzzles to buy a Ferrari🤪.

hahaha two bad jokes in a single post, bravo.

A few words about the puzzle.  There is no pattern.  It is just consecutive keys from a deterministic wallet (masked with leading 000...0001 to set difficulty).

• 1st method very close to creator hints -- probability of errors zero

https://bitcointalk.org/index.php?topic=1306983.msg61993228#msg61993228

• 2nd method -- probability of errors zero

https://bitcointalk.org/index.php?topic=1306983.msg62163538#msg62163538

there are many more.. But still, I would like to request the creator to please reveal all the keys from puzzle 161 to puzzle 256, to make this challenge a bit more interesting.

I could create hundreds of scripts that match the puzzle, but the creator most likely edited the keys manually, otherwise random would be used instead of pre-generated HD wallets.

[1714241972]

1714241972

[1714241972]

1714241972

[1714241972]

1714241972

[1714241972]

1714241972

[albert0bsd]

I could create hundreds of scripts that match the puzzle, but the creator most likely edited the keys manually, otherwise random would be used instead of pre-generated HD wallets.

haven't you learned to quote properly?

It is not manually it is with some script, errors = ZERO

[mcdouglasx]

I could create hundreds of scripts that match the puzzle, but the creator most likely edited the keys manually, otherwise random would be used instead of pre-generated HD wallets.

haven't you learned to quote properly?

It is not manually it is with some script, errors = ZERO

Don't you think you are assuming too much, with the little we know about the creator? We really don't even know if he knows how to program or not.
you just want to justify your answer against all possibilities.
He simply said that he used an HD wallet and modified the keys with zeros and ones, that is, he removed part of the keys to establish the difficulty.
If it were done through a script, it would be used randomly and not a pre-generated HD wallet because it would save lines and lines of code because each puzzle is different.
Besides, you always do the same thing. You say that there is no mathematical solution other than brute force because you tried and you didn't succeed. You are supposed to be the god of everything and we have to believe you? At what point did science stop being based on questioning the rest?.
The fact that you have created software by mixing all the findings of other people does not make you a wise scholar, just another programmer.

[albert0bsd]

Don't you think you are assuming too much, with the little we know about the creator?

The same if for you, Don't you think that you are assuming too much?

Bump!!

You said the he did it manually I said that it was made with and script or program.

WE DON'T HAVE WAY TO KNOW IT.

So we can finished all of our posts with the next sentence.

All that I write here is my personal opinion or speculation there is no proof of anything and all other users are also speculating

[bestie1549]

Don't you think you are assuming too much, with the little we know about the creator?

The same if for you, Don't you think that you are assuming too much?

Bump!!

You said the he did it manually I said that it was made with and script or program.

WE DON'T HAVE WAY TO KNOW IT.

So we can finished all of our posts with the next sentence.

All that I write here is my personal opinion or speculation there is no proof of anything and all other users are also speculating

I am about to let it all go...
I have tried so may ways to get this to work
maybe we have been looking at the wrong direction the whole time
I need to ask a question, maybe the whole RMD160 or bas58 bruteforce is too slow
but 1 thing is also certain, there is no way to know the public key of number 66 if we dont have to compare the private key with the RMD160 or base58 I could have suggestedfor us to try bruteforcing for the public key maybe it could save us so much time and also boost the speed too.

can we sequentially generate public keys within the range of 66 bit without having anything to do with the private key?

[mcdouglasx]

Don't you think you are assuming too much, with the little we know about the creator?

The same if for you, Don't you think that you are assuming too much?

Bump!!

You said the he did it manually I said that it was made with and script or program.

WE DON'T HAVE WAY TO KNOW IT.

So we can finished all of our posts with the next sentence.

All that I write here is my personal opinion or speculation there is no proof of anything and all other users are also speculating

First I did not give certainty about anything, I only said words like “the most logical”, “the most probable”, “and we assume”.
There is a big difference between my opinion and yours because you say it as if it were an irrefutable fact and I say it with assumptions, as it should be.

[albert0bsd]

can we sequentially generate public keys within the range of 66 bit without having anything to do with the private key?

Hi, yes it is actually what most program do. They select a star key and it is convert to public key after that it only perfome point addition operations sequentially

This is fater because it avoid the scalar multiplication operation.

Also there is a lot shortcuts to perform the point addition faster, this is doing some group operation where you can save hundreds of steps.

First I did not give certainty about anything, I only said words like “the most logical”, “the most probable”, “and we assume”.
There is a big difference between my opinion and yours because you say it as if it were an irrefutable fact and I say it with assumptions, as it should be.

Well I already said it, all that I said and you said is based on our opinions and assumptions. We can settle this discussion now?

By the way I never said that that I am a god in anything.
 
I write this in another post:

I am just an average programmer,

[citb0in]

ok gentleman, so back to bussiness ... 

[nomachine]

I assume the script is too. I also assume the author set the clock back or forward (from 2015) on the computer this script was running on.

[zahid888]

I could create hundreds of scripts that match the puzzle, but the creator most likely edited the keys manually, otherwise random would be used instead of pre-generated HD wallets.

haven't you learned to quote properly?

It is not manually it is with some script, errors = ZERO

Don't you think you are assuming too much, with the little we know about the creator? We really don't even know if he knows how to program or not.
you just want to justify your answer against all possibilities.
He simply said that he used an HD wallet and modified the keys with zeros and ones, that is, he removed part of the keys to establish the difficulty.
If it were done through a script, it would be used randomly and not a pre-generated HD wallet because it would save lines and lines of code because each puzzle is different.
Besides, you always do the same thing. You say that there is no mathematical solution other than brute force because you tried and you didn't succeed. You are supposed to be the god of everything and we have to believe you? At what point did science stop being based on questioning the rest?.
The fact that you have created software by mixing all the findings of other people does not make you a wise scholar, just another programmer.

What do you think, someone who can create such a big puzzle cannot write a 4-line code?

Code:

key = '910ed3ab5775b97da1a33e38b72eba94f90addff7051f276c9d6c538c369632b'
last_index = 0
while last_index <= 255:
    mask = 1 << last_index
    mask_hex = mask + int(key, 16) % mask
    last_index += 1
    hexa = "%064x" % mask_hex
    print (hexa)

It's hard to believe that they would manually write each puzzle after extracting 256 keys from HD wallet.. At first, I thought you were saying all this as a joke, but you're actually defending your point seriously, still... who knows  can't be denied that it might have been done manually

[nomachine]

Who knows. Maybe it's just paper and pencil.

[zahid888]

Who knows. Maybe it's just paper and pencil.

No we have to believe at least his one and only hint

A few words about the puzzle.  There is no pattern.  It is just consecutive keys from a deterministic wallet (masked with leading 000...0001 to set difficulty).

[mcdouglasx]

I could create hundreds of scripts that match the puzzle, but the creator most likely edited the keys manually, otherwise random would be used instead of pre-generated HD wallets.

haven't you learned to quote properly?

It is not manually it is with some script, errors = ZERO

Don't you think you are assuming too much, with the little we know about the creator? We really don't even know if he knows how to program or not.
you just want to justify your answer against all possibilities.
He simply said that he used an HD wallet and modified the keys with zeros and ones, that is, he removed part of the keys to establish the difficulty.
If it were done through a script, it would be used randomly and not a pre-generated HD wallet because it would save lines and lines of code because each puzzle is different.
Besides, you always do the same thing. You say that there is no mathematical solution other than brute force because you tried and you didn't succeed. You are supposed to be the god of everything and we have to believe you? At what point did science stop being based on questioning the rest?.
The fact that you have created software by mixing all the findings of other people does not make you a wise scholar, just another programmer.

What do you think, someone who can create such a big puzzle cannot write a 4-line code?

Code:

key = '910ed3ab5775b97da1a33e38b72eba94f90addff7051f276c9d6c538c369632b'
last_index = 0
while last_index <= 255:
    mask = 1 << last_index
    mask_hex = mask + int(key, 16) % mask
    last_index += 1
    hexa = "%064x" % mask_hex
    print (hexa)

It's hard to believe that they would manually write each puzzle after extracting 256 keys from HD wallet.. At first, I thought you were saying all this as a joke, but you're actually defending your point seriously, still... who knows   can't be denied that it might have been done manually

First it's a big puzzle, why? only money makes it popular, it's not that he invented the wheel, it's a simple increment of numbers, the reason why I think He don't use a script is because anyone who has sufficient knowledge of bitcoin understands the limits of ecc and the associated hashes to bitcoin.
so to begin with it made no sense at all to put 256 keys from the beginning.
And if he used a script  could have used random, I don't see a logical position in using an HD wallet.
Based on that, he could have done anything crazy from then on.
It's like believing that the matches in 160 hashes have some relationship with the distribution of public keys in ECC, absurd.

But until the creator says anything, neither you nor I are right for sure.

[albert0bsd]

I don't see a logical position in using an HD wallet.

Maybe because it more easy only save a single seed than 256 keys first or 160 later

Just my two satoshis

[mcdouglasx]

Maybe because it more easy only save a single seed than 256 keys first or 160 later

Just my two satoshis

I don't see any point in using an HD to make a script when you could use random, it doesn't represent an improvement in security (as you say, it's less secure than random), in storage, or in complexity.
and since you assume he knows how to program, I'll assume he must have thought of that.

[citb0in]

a seed makes it easier to manage sensitive data like the private keys and addresses he generated but at the same time represents a SPOF (Single Point of Failure). However that's not a big deal. he must take care of safe storage either way. Whether he stores only one seed or several seeds safely, what role does that play in this application. Be it random or hierarchical deterministic, we're still stuck 

[digaran]

As the "master math guru" of this community 🤥😂  I have always wondered, can God make it so when 2+2 you get 5, I mean he can do anything right? So how could we believe all of the rules of physics, mathematics? If it's possible to change the rules like that? It would be like saying since God can do anything, he should be able to clone himself infinitely, or more importantly, can God kill himself? These questions are taunting and impossible to know the answer for sure, but logic says he shouldn't be able to make 2+2=5, or create clones of himself or self destruct, that means logically even God has limits to his power.

But is that really the case?  Did he create the rules out of nothing or were these rules always there along side him?


I believe we are only one of the versions of infinite possible versions, so yes it is possible to see 2+2=5 under different governing rules of different universes, while it doesn't make any sense to us because we only know of 2+2=4, governing  principles of our universe does not allow us to figure out how it is possible to have two plus two equal five, this is our limit, we can't go beyond this limit.


Now what is my point? There is a solution to solve these keys, also there is a relation between rmd160 and ecc keys, just because we can't think what they are doesn't mean they don't exist. If you seek knowledge, ask the source of knowledge.  But if you quit trying midway, you will get nothing, so chop chop and God bless you.😉

Edit : this is my achievement after working on elliptic curve cryptography for more than 8 months.

I set it to print the result of subtraction, if you want to see the result for scalar_1 remove "print" from the third line and add "print" to first line, so result_1 is the result of scalar_2 division, this happens when I work by myself and a world dominating AI. 😂

Code:

import gmpy2 as mpz
from gmpy2 import powmod

# Define the ec_operations function
def ec_operations(start_range, end_range, scalar_1, scalar_2, n, divide_1_by_odd=True, divide_1_by_even=True, divide_2_by_odd=True, divide_2_by_even=True):
    for i in range(start_range + (start_range%2), end_range, 1):
        # divide scalar 1 by odd or even numbers
        if i%2 == 0 and not divide_1_by_even:
            continue
        elif i%2 == 1 and not divide_1_by_odd:
            continue
        try:
            # calculate inverse modulo of i
            i_inv = powmod(i, n-2, n)

            # multiply the scalar targets by i modulo n
            result_1 = scalar_2 * i_inv % n
            result_2 = scalar_1 * i_inv % n

            # divide scalar 2 by odd or even numbers
            if i%2 == 0 and not divide_2_by_even:
                continue
            elif i%2 == 1 and not divide_2_by_odd:
                continue

            # subtract the results
            sub_result = (result_2 - result_1) % n

            # print results separately
            (f"{i}-{hex(result_1)[2:]}")
            (f"{i}-{hex(result_2)[2:]}")
            print(f"{i}-{hex(sub_result)[2:]}")

        except ZeroDivisionError:
            pass


if __name__ == "__main__":
    # Set the targets and range for the operations
    scalar_1 = 0x0000000000000000000000000000000ff9450a667168a48762abcbe86653a6a1
    scalar_2 = 0x0000000000000000000000000000000000000000000000000000000000000001

    n = mpz.mpz("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141")

    start_range = 2
    end_range = 65

    ec_operations(start_range, end_range, scalar_1, scalar_2, n)

Note, you can also change "1" in the following line to divide by odd or even,

Code:

for i in range(start_range + (start_range%2), end_range, 1):

Replace 1 with 2 and print subtraction result to see it divides by 2, 4, 6 etc, replacing it with 3, will divide by 2, 5, 8, 11 etc, since our start range is 2 it will start from 2 and adds 3 each step.

Even though I have already posted the script for point calculations, to make it easier for you to havd both scripts in one place, here goes the same script operating with public keys:

Code:

import gmpy2 as mpz
from gmpy2 import powmod

# Define the EllipticCurve class
class EllipticCurve:
    def __init__(self, a, b, p):
        self.a = mpz.mpz(a)
        self.b = mpz.mpz(b)
        self.p = mpz.mpz(p)

    def contains(self, point):
        x, y = point.x, point.y
        return (y * y) % self.p == (x * x * x + self.a * x + self.b) % self.p

    def __str__(self):
        return f"y^2 = x^3 + {self.a}x + {self.b} mod {self.p}"

# Define the Point class
class Point:
    def __init__(self, x, y, curve):
        self.x = mpz.mpz(x)
        self.y = mpz.mpz(y)
        self.curve = curve

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y and self.curve == other.curve

    def __ne__(self, other):
        return not self == other

    def __add__(self, other):
        if self.curve != other.curve:
            raise ValueError("Cannot add points on different curves")

        # Case when one point is zero
        if self == Point.infinity(self.curve):
            return other
        if other == Point.infinity(self.curve):
            return self

        if self.x == other.x and self.y != other.y:
            return Point.infinity(self.curve)

        p = self.curve.p
        s = 0
        if self == other:
            s = ((3 * self.x * self.x + self.curve.a) * powmod(2 * self.y, -1, p)) % p
        else:
            s = ((other.y - self.y) * powmod(other.x - self.x, -1, p)) % p

        x = (s * s - self.x - other.x) % p
        y = (s * (self.x - x) - self.y) % p

        return Point(x, y, self.curve)

    def __sub__(self, other):
        if self.curve != other.curve:
            raise ValueError("Cannot subtract points on different curves")

        # Case when one point is zero
        if self == Point.infinity(self.curve):
            return other
        if other == Point.infinity(self.curve):
            return self

        return self + Point(other.x, (-other.y) % self.curve.p, self.curve)

    def __mul__(self, n):
        if not isinstance(n, int):
            raise ValueError("Multiplication is defined for integers only")

        n = n % (self.curve.p - 1)
        res = Point.infinity(self.curve)
        addend = self

        while n:
            if n & 1:
                res += addend

            addend += addend
            n >>= 1

        return res

    def __str__(self):
        return f"({self.x}, {self.y}) on {self.curve}"

    @staticmethod
    def from_hex(s, curve):
        if len(s) == 66 and s.startswith("02") or s.startswith("03"):
            compressed = True
        elif len(s) == 130 and s.startswith("04"):
            compressed = False
        else:
            raise ValueError("Hex string is not a valid compressed or uncompressed point")

        if compressed:
            is_odd = s.startswith("03")
            x = mpz.mpz(s[2:], 16)

            # Calculate y-coordinate from x and parity bit
            y_square = (x * x * x + curve.a * x + curve.b) % curve.p
            y = powmod(y_square, (curve.p + 1) // 4, curve.p)
            if is_odd != (y & 1):
                y = -y % curve.p

            return Point(x, y, curve)
        else:
            s_bytes = bytes.fromhex(s)
            uncompressed = s_bytes[0] == 4
            if not uncompressed:
                raise ValueError("Only uncompressed or compressed points are supported")

            num_bytes = len(s_bytes) // 2
            x_bytes = s_bytes[1 : num_bytes + 1]
            y_bytes = s_bytes[num_bytes + 1 :]

            x = mpz.mpz(int.from_bytes(x_bytes, byteorder="big"))
            y = mpz.mpz(int.from_bytes(y_bytes, byteorder="big"))

            return Point(x, y, curve)

    def to_hex(self, compressed=True):
        if self.x is None and self.y is None:
            return "00"
        elif compressed:
            prefix = "03" if self.y & 1 else "02"
            return prefix + hex(self.x)[2:].zfill(64)
        else:
            x_hex = hex(self.x)[2:].zfill(64)
            y_hex = hex(self.y)[2:].zfill(64)
            return "04" + x_hex + y_hex

    @staticmethod
    def infinity(curve):
        return Point(-1, -1, curve)

# Define the ec_mul function
def ec_mul(point, scalar, base_point):
    result = Point.infinity(point.curve)
    addend = point

    while scalar:
        if scalar & 1:
            result += addend

        addend += addend
        scalar >>= 1

    return result

# Define the ec_operations function
def ec_operations(start_range, end_range, target_1, target_2, curve, divide_1_by_odd=True, divide_1_by_even=True, divide_2_by_odd=True, divide_2_by_even=True):
    # Define parameters for secp256k1 curve
    n = mpz.mpz("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141")
    G = Point(
        mpz.mpz("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
        mpz.mpz("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"),
        curve
    )

    for i in range(start_range + ( start_range%2), end_range, 1 ):
        # divide target 1 by odd or even numbers
        if i%2 == 0 and not divide_1_by_even:
            continue
        elif i%2 == 1 and not divide_1_by_odd:
            continue
        try:
            # calculate inverse modulo of i
            i_inv = powmod(i, n-2, n)

            # divide the targets by i modulo n
            result_1 = ec_mul(target_1, i_inv, G)
            result_2 = ec_mul(target_2, i_inv, G)

            # divide target 2 by odd or even numbers
            if i%2 == 0 and not divide_2_by_even:
                continue
            elif i%2 == 1 and not divide_2_by_odd:
                continue

            # subtract the results
            sub_result = result_1 - result_2

            # print the results  separately 
            (f"{i}-{result_1.to_hex()}")
            (f"{i}-{result_2.to_hex()}")
            print(f"{i}-{sub_result.to_hex()}")

        except ZeroDivisionError:
            pass


if __name__ == "__main__":
    # Set the targets and range for the operations
    curve = EllipticCurve(
        mpz.mpz(0),
        mpz.mpz(7),
        mpz.mpz("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F")
    )

    target_1 = Point.from_hex("03db8705a402eabb367c23a611249d01f4c631c0a449093ca97ff5d19a5cbce7aa", curve)

    target_2 = Point.from_hex("0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798", curve)
    
    start_range = 1
    end_range = 65
    
    ec_operations(start_range, end_range, target_2, target_1, curve)

Special thanks to @mcdouglasx for dividing by range code, and to @nomachine for gympy2 and mpz introduction.

Ps, I'm not working to solve these puzzles, I am just studying elliptic curve, I haven't tested my methods on puzzle keys.

[bestie1549]

As the "master math guru" of this community 🤥😂  I have always wondered, can God make it so when 2+2 you get 5, I mean he can do anything right? So how could we believe all of the rules of physics, mathematics? If it's possible to change the rules like that? It would be like saying since God can do anything, he should be able to clone himself infinitely, or more importantly, can God kill himself? These questions are taunting and impossible to know the answer for sure, but logic says he shouldn't be able to make 2+2=5, or create clones of himself or self destruct, that means logically even God has limits to his power.

@digaran
So I ran the code and I got 63 pubkeys
I need to ask what would be the target 1 and target 2
and how can I further divide the pubkey of 130 to as low as 100 or 90 or 80 bit range
after hitting a target from the public key results, how would I further calculate the private key to get my target private key

[digaran]

@digaran
So I ran the code and I got 63 pubkeys
I need to ask what would be the target 1 and target 2
and how can I further divide the pubkey of 130 to as low as 100 or 90 or 80 bit range
after hitting a target from the public key results, how would I further calculate the private key to get my target private key

You should try to put 130 pub on target 1 and put G on target 2, and then calculate the range like this:

Suppose we have a key in 130 bit range, dividing it by 64 gives us what? Lets try 2^130/64= 2^124, so you would need to have 2^124 public keys saved to compare the results of subtraction with, now if you divide 2^130/2^124= 64, now you only need to store 64 public keys starting from 1 to 64 for comparison, but you don't need to generate 2^124 divisions, just a few millions which would take a few days with my slow script, so first you need to boost the speed.

I have already discussed about the possibility of finding a solution to solve private keys, and this is it, I won't be guiding anyone step by step on how to do it, if Satoshi or anyone who really cares about bitcoin and actually is an expert, they will figure it out soon enough, I have promised God not to reveal the final steps to anyone, let's hope nobody figures it out.

Note, it's not an easy task, because solving each key requires a lot of steps, so many tries, so many errors but it can be done.

[nomachine]

 There is no pattern here. But there is a time when a puzzle was created. I even went back in time and generating numbers from 2015. Every second of that year.

https://bitcointalk.org/index.php?topic=1306983.msg62144570#msg62144570

Almost six months ago, I undertook various tasks of a similar stuffs..

Code:

import random
from datetime import datetime, timedelta

# List of target Puzzle, each corresponding to a range
target_numbers = [
    (1, 1), (2, 3), (3, 7), (4, 8), (5, 21), (6, 49), (7, 76), (8, 224), (9, 467), (10, 514),
    (11, 1155), (12, 2683), (13, 5216), (14, 10544), (15, 26867), (16, 51510),
    (17, 95823), (18, 198669), (19, 357535), (20, 863317), (21, 1811764),
    (22, 3007503), (23, 5598802), (24, 14428676), (25, 33185509),
    (26, 54538862), (27, 111949941), (28, 227634408), (29, 400708894),
    (30, 1033162084), (31, 2102388551), (32, 3093472814), (33, 7137437912),
    (34, 14133072157), (35, 20112871792), (36, 42387769980), (37, 100251560595),
    (38, 146971536592), (39, 323724968937), (40, 1003651412950),
    (41, 1458252205147), (42, 2895374552463), (43, 7409811047825),
    (44, 15404761757071), (45, 19996463086597), (46, 51408670348612),
    (47, 119666659114170), (48, 191206974700443), (49, 409118905032525),
    (50, 611140496167764), (51, 2058769515153876), (52, 4216495639600700),
    (53, 6763683971478124), (54, 9974455244496707), (55, 30045390491869460),
    (56, 44218742292676575), (57, 138245758910846492), (58, 199976667976342049),
    (59, 525070384258266191), (60, 1135041350219496382), (61, 1425787542618654982),
    (62, 3908372542507822062), (63, 8993229949524469768),
    (64, 17799667357578236628), (65, 30568377312064202855)
]

# Sort the target_numbers list by the first element of each tuple (the range start)
target_numbers.sort(key=lambda x: x[0])

# Specify the start and end date and times for the search
start_datetime_pre = datetime(2014, 11, 1, 0, 0, 0)
end_datetime_pre = datetime(2015, 1, 15, 19, 7, 14)
current_datetime = start_datetime_pre
time_step = timedelta(seconds=1)

# Initialize a set to keep track of found target numbers
found_targets = set()

# Function to find the seed for a single target number
def find_seed_for_target(target_num, current_time):
    num, target_number = target_num
    min_number = 2 ** (num - 1)
    max_number = (2 ** num) - 1

    low_seed = int(current_time.timestamp())
    high_seed = int(end_datetime_pre.timestamp())

    found_seed = None

    while low_seed <= high_seed:
        mid_seed = (low_seed + high_seed) // 2

        random.seed(mid_seed)
        generated_number = random.randint(min_number, max_number)

        if generated_number == target_number:
            found_seed = mid_seed
            break
        elif generated_number < target_number:
            low_seed = mid_seed + 1
        else:
            high_seed = mid_seed - 1

    return found_seed

# Iterate through the time range
while current_datetime <= end_datetime_pre:
    # Find seeds for all target numbers
    found_seeds = [find_seed_for_target(target, current_datetime) for target in target_numbers]

    # Print the results for each target number if found and not already printed
    for i, (num, target_number) in enumerate(target_numbers, start=1):
        if found_seeds[i - 1] is not None and target_number not in found_targets:
            linuxtime = found_seeds[i - 1]
            timestamp = datetime.fromtimestamp(linuxtime)
            formatted_time = timestamp.strftime('%Y-%m-%d %H:%M:%S')
            print(f"Puzzle {i} : Private Key : {target_number} | Timestamp: {formatted_time}")
            found_targets.add(target_number)

    # Move to the next second
    current_datetime += time_step

You'd be surprised what this finds. You just need to guess the year and date range.
It takes a long time to find Puzzle timestamps above 20...