Bitcoin puzzle transaction ~32 BTC prize to who solves it

[Bram24732]

you should already be rich enough to participate in this puzzle.

So, honestly speaking, this puzzle was made by a rich person for rich people—the rich will get richer, and the poor will get poorer. Right?   

Yep... Or maybe you manage to use vast.ai for free by hacking their system—exploiting 3,000 GPUs, stolen credit cards, or even the puzzle creator himself, as you’ve already written somewhere. The problem is, you could end up in prison. It’s better to just go fishing.

Do you really think these puzzles are solved fairly? With savings? Who even has that much in savings? Come on! 

Or you know, you crowdfund money with people and split the reward. You use the money you collect to make deals with GPU farms and benefit from economies of scale.
Just an idea, it might just work.

[nomachine]

Alternatively, you can borrow the full amount from the bank. However, they will require your house and property as collateral. 

[Bram24732]

Alternatively, you can borrow the full amount from the bank. However, they will require your house and property as collateral. 

Better make sure there's no bug in your code

[Akito S. M. Hosana]

you can borrow plenty of money from the mafia. The problem is, if you don't pay it back, you'll end up missing some body parts or family members.

Alternatively, you can borrow the full amount from the bank. However, they will require your house and property as collateral.  

There's no big difference here. If you screw up, you can just hang yourself. And all that For 3000 GPUs - no chance.  

Or you know, you crowdfund money with people and split the reward. You use the money you collect to make deals with GPU farms and benefit from economies of scale.
Just an idea, it might just work.

This sounds reasonable.

[kTimesG]

I'm not a programmer at all — the AI writes all the code for me. But it still couldn't give me a clear answer to my question: is it possible to iterate through private keys within a given range while instantly filtering out "unreliable" keys, without affecting the speed of the iteration itself?

Here's the non-AI (correct) answer.
Once you filter out a single key, then computing the very next key would require one of these 2 options:

1. Multiplication with G.
2. Addition with a precomputed delta*G public key.

2 is faster, but you need to know how many precomputed deltas you'll ever need, or come up with a complicated strategy to optimize the "jump" using your precomputed delta keys, without resorting to option #1.

Also, the CUDA kernel would need to know what private key is computing, which, without filtering concept, is totally not needed at all. The fastest kernels simply go from pubKey A to pubkey B without ever caring what the private key is associated with each result. The CPU handles this association (and also maybe the initial starting point multiplications, as its only needed one time only), freeing up computational time on the GPU.

Oh, and also it's a fallacy to ever think some whatever pattern can't result in the solution. There are multiple puzzles where we had sequences of long 1s or 0s in a row, which would have been skipped if this pattern filtering thing would have been used.


LE: there's also option #3:

3. Compute the public key as usual, but skip the hashing part if you don't like how the private key looks like. However, because of the need to do this check, I don't think it will result in a higher speed than the usual way. Needs checking, I cannot be certain about this.

[Desyationer]

kTimesG
nomachine
Bram24732
AlanJohnson
Thanks for the clarification. It's now clear that if the CUDA algorithm achieves its high speed by computing the delta from the previous key, then applying a filter would likely be ineffective. Even a 30% reduction in the range probably wouldn't offset the performance loss caused by filtering—assuming it's even possible to implement it. On standard CPUs, filtering might be slightly more reasonable, but their speed is vastly inferior compared to GPUs. Overall, even if filtering could be perfectly implemented on a GPU without any performance drop, a 30% reduction in the key space wouldn't make much of a difference for anyone without access to thousands of GPUs. The real benefit would come not from a 30% reduction, but from reducing the range by several orders of magnitude.

[alexxino]

I have developed a prediction model based on the @HomelessPhD model for alpha values:

https://github.com/HomelessPhD/BTC32

It targets puzzle private keys with a deviation of 0.0000000001 %.

Code:

import numpy as np
from mpmath import mp
import argparse

# Set very high precision
mp.dps = 300

# Target numbers (ordinal, value)
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),
    (66, 46346217550346335726), (67, 132656943602386256302),
    (68, 219898266213316039825), (70, 970436974005023690481)
]

# Provided alpha values
alpha_values = {
    20: -5.509999999999367, 21: -4.8099999999993575, 22: 6.690000000000806, 23: 4.309999999879222,
    24: -5.109999999999362, 25: -2.4933006701008145, 26: 23.19000000000104, 27: 50.01000000165623,
    28: 50.01000000165623, 29: 4.490000000000775, 30: -4.30999999999935, 31: -4.8036514600379405,
    32: 2.7900000000007505, 33: 10.110000011655663, 34: 8.496609620547714, 35: 1.6905278399975268,
    36: 2.2900000000007434, 37: 6.506918969897979, 38: 1.8912248499932935, 39: 2.9099999998792025,
    40: -2.809999999999329, 41: 5.2945524899731184, 42: 5.690000000000792, 43: -4.691035100114615,
    44: -3.9099999999993447, 45: 2.5900000000007477, 46: 50.01000000165623, 47: -4.50218804004683,
    48: 6.909999999879259, 49: 28.510000011655915, 50: 2.495913989964804, 51: -2.5900000001208756,
    52: -2.5099999999993248, 53: 50.01000000165623, 54: 2.4900000000007463, 55: -5.00999999999936,
    56: 3.8099999998792153, 57: -2.1943843400942242, 58: 8.890000000000837, 59: -3.009999999999332,
    60: -2.2099999999993205, 61: 3.1099999998792054, 62: -6.000280060058447, 63: -2.490000000120874,
    64: -2.809999999999329, 65: -19.689999988344763, 66: 2.7931615399815364, 67: -4.709999999999356,
    68: 8.692996380248756, 70: -24.301635149307526
}

def calculate_prediction(puzzle_number, alpha):
    # Get all previous data points
    ordinals = np.array([x[0] for x in target_numbers if x[0] < puzzle_number], dtype=float)
    values = np.array([x[1] for x in target_numbers if x[0] < puzzle_number], dtype=float)
    
    if len(ordinals) < 2:
        print(f"Not enough data points to make a prediction for puzzle {puzzle_number}")
        return None, None, None
    
    log_values = np.array([float(mp.log(val)) for val in values], dtype=float)
    weights = np.linspace(0.5, 1, len(ordinals))
    coefficients = np.polyfit(ordinals, log_values, 1, w=weights)
    
    a = mp.exp(coefficients[1])
    b = mp.exp(coefficients[0])
    
    correction = (((2 ** puzzle_number) - 1) - (2 ** (puzzle_number - 1))) / alpha
    predicted_value = (a * mp.power(b, puzzle_number)) - correction
    
    return predicted_value, a, b

def interpolate_alpha(puzzle_number):
    """Interpolate alpha for missing puzzle numbers"""
    known_puzzles = sorted(alpha_values.keys())
    
    if puzzle_number < min(known_puzzles) or puzzle_number > max(known_puzzles):
        return 0.0  # Default value if outside known range
    
    # Find closest lower and higher puzzle numbers
    lower = max([p for p in known_puzzles if p < puzzle_number])
    higher = min([p for p in known_puzzles if p > puzzle_number])
    
    # Linear interpolation
    alpha_range = alpha_values[higher] - alpha_values[lower]
    position = (puzzle_number - lower) / (higher - lower)
    return alpha_values[lower] + (alpha_range * position)

def format_mp(value, decimals=None):
    """Format mpmath value with specified decimal places"""
    if decimals is not None:
        return f"{float(value):,.{decimals}f}".replace(',', '')
    return mp.nstr(value, mp.dps)

def main(puzzle_number):
    if puzzle_number == 69:
        # Special case for puzzle 69 - use interpolated alpha
        alpha = interpolate_alpha(69)
        predicted_value, a, b = calculate_prediction(69, alpha)
        
        print("\nPuzzle 69 Prediction:")
        print(f"Using interpolated alpha: {alpha:.6f}")
        print(f"Base exponential model: {format_mp(a)} * {format_mp(b)}^n")
        print(f"Predicted Value: {format_mp(predicted_value, 2)}")
        
        # Compare with n=70
        n70_value = next(x[1] for x in target_numbers if x[0] == 70)
        growth_rate = n70_value / predicted_value
        print(f"Growth to n=70: {float(growth_rate):.6f}x")
        print(f"Actual n=70 value: {format_mp(n70_value)}")
        return
    
    if puzzle_number not in alpha_values:
        print(f"No alpha value available for puzzle {puzzle_number}")
        return
    
    alpha = alpha_values[puzzle_number]
    predicted_value, a, b = calculate_prediction(puzzle_number, alpha)
    
    if predicted_value is None:
        return
    
    real_value = next((x[1] for x in target_numbers if x[0] == puzzle_number), None)
    
    print(f"\nPuzzle {puzzle_number} Calculation:")
    print(f"Using alpha: {alpha}")
    print(f"Base exponential model: {format_mp(a)} * {format_mp(b)}^n")
    
    if real_value is not None:
        print(f"Real Value: {format_mp(real_value)}")
    print(f"Predicted Value: {format_mp(predicted_value, 2)}")
    
    if real_value is not None:
        error_percentage = abs((predicted_value - real_value) / real_value) * 100
        print(f"Percentage error: {format_mp(error_percentage, 10)}%")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Calculate puzzle values using provided alpha values.")
    parser.add_argument("puzzle_number", type=int, help="Puzzle number to calculate")
    args = parser.parse_args()
    main(args.puzzle_number) 

If anyone knows what to do next with this - here you go.

python3 test.py 68

Puzzle 68 Calculation:
Using alpha: 8.692996380248756
Base exponential model: 0.68972090704257297155081468833675824716161023623689914791953650562051467261304 4419972598777231639024182489182413058156841483121232343334326952277688035030318 1311309574260048040167879840662353500733521425500975021869380914054885130184442 40544507079388243203845236809052465256422016436329883051889524096 * 2.00446149587820417640494244738360788449393817055989304597589376020405549833178 4239005365118701510143617670147330576209009738631394722016490414926974514298110 3364613583395133560524755600665108274702675918184495985595413655135405238097981 4864413726673117061462450025066948963321434607944444810622903302^n
Real Value: 219898266213316039825
Predicted Value: 219898266215462633472.00
Percentage error: 0.00000000%


python3 test.py 69

Puzzle 69 Prediction:
Using interpolated alpha: -7.804319

According to this, puzzle 69 starts with 1ba45e.....


I don't have the nerves to improve this for the better.  

I'm trying to redo your work here!
I have tried to get the alphas using Octave but it gives me super different values, none of them negative! Did you make changes in the analysis.m file? I have modified the 'btc32_keys_dec.csv file setting only from 20# to 70# but alphas are way too different than yours. Any clue what I'm doing wrong?

[wizard872]

I have developed a prediction model based on the @HomelessPhD model for alpha values:

https://github.com/HomelessPhD/BTC32

It targets puzzle private keys with a deviation of 0.0000000001 %.

Code:

import numpy as np
from mpmath import mp
import argparse

# Set very high precision
mp.dps = 300

# Target numbers (ordinal, value)
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),
    (66, 46346217550346335726), (67, 132656943602386256302),
    (68, 219898266213316039825), (70, 970436974005023690481)
]

# Provided alpha values
alpha_values = {
    20: -5.509999999999367, 21: -4.8099999999993575, 22: 6.690000000000806, 23: 4.309999999879222,
    24: -5.109999999999362, 25: -2.4933006701008145, 26: 23.19000000000104, 27: 50.01000000165623,
    28: 50.01000000165623, 29: 4.490000000000775, 30: -4.30999999999935, 31: -4.8036514600379405,
    32: 2.7900000000007505, 33: 10.110000011655663, 34: 8.496609620547714, 35: 1.6905278399975268,
    36: 2.2900000000007434, 37: 6.506918969897979, 38: 1.8912248499932935, 39: 2.9099999998792025,
    40: -2.809999999999329, 41: 5.2945524899731184, 42: 5.690000000000792, 43: -4.691035100114615,
    44: -3.9099999999993447, 45: 2.5900000000007477, 46: 50.01000000165623, 47: -4.50218804004683,
    48: 6.909999999879259, 49: 28.510000011655915, 50: 2.495913989964804, 51: -2.5900000001208756,
    52: -2.5099999999993248, 53: 50.01000000165623, 54: 2.4900000000007463, 55: -5.00999999999936,
    56: 3.8099999998792153, 57: -2.1943843400942242, 58: 8.890000000000837, 59: -3.009999999999332,
    60: -2.2099999999993205, 61: 3.1099999998792054, 62: -6.000280060058447, 63: -2.490000000120874,
    64: -2.809999999999329, 65: -19.689999988344763, 66: 2.7931615399815364, 67: -4.709999999999356,
    68: 8.692996380248756, 70: -24.301635149307526
}

def calculate_prediction(puzzle_number, alpha):
    # Get all previous data points
    ordinals = np.array([x[0] for x in target_numbers if x[0] < puzzle_number], dtype=float)
    values = np.array([x[1] for x in target_numbers if x[0] < puzzle_number], dtype=float)
    
    if len(ordinals) < 2:
        print(f"Not enough data points to make a prediction for puzzle {puzzle_number}")
        return None, None, None
    
    log_values = np.array([float(mp.log(val)) for val in values], dtype=float)
    weights = np.linspace(0.5, 1, len(ordinals))
    coefficients = np.polyfit(ordinals, log_values, 1, w=weights)
    
    a = mp.exp(coefficients[1])
    b = mp.exp(coefficients[0])
    
    correction = (((2 ** puzzle_number) - 1) - (2 ** (puzzle_number - 1))) / alpha
    predicted_value = (a * mp.power(b, puzzle_number)) - correction
    
    return predicted_value, a, b

def interpolate_alpha(puzzle_number):
    """Interpolate alpha for missing puzzle numbers"""
    known_puzzles = sorted(alpha_values.keys())
    
    if puzzle_number < min(known_puzzles) or puzzle_number > max(known_puzzles):
        return 0.0  # Default value if outside known range
    
    # Find closest lower and higher puzzle numbers
    lower = max([p for p in known_puzzles if p < puzzle_number])
    higher = min([p for p in known_puzzles if p > puzzle_number])
    
    # Linear interpolation
    alpha_range = alpha_values[higher] - alpha_values[lower]
    position = (puzzle_number - lower) / (higher - lower)
    return alpha_values[lower] + (alpha_range * position)

def format_mp(value, decimals=None):
    """Format mpmath value with specified decimal places"""
    if decimals is not None:
        return f"{float(value):,.{decimals}f}".replace(',', '')
    return mp.nstr(value, mp.dps)

def main(puzzle_number):
    if puzzle_number == 69:
        # Special case for puzzle 69 - use interpolated alpha
        alpha = interpolate_alpha(69)
        predicted_value, a, b = calculate_prediction(69, alpha)
        
        print("\nPuzzle 69 Prediction:")
        print(f"Using interpolated alpha: {alpha:.6f}")
        print(f"Base exponential model: {format_mp(a)} * {format_mp(b)}^n")
        print(f"Predicted Value: {format_mp(predicted_value, 2)}")
        
        # Compare with n=70
        n70_value = next(x[1] for x in target_numbers if x[0] == 70)
        growth_rate = n70_value / predicted_value
        print(f"Growth to n=70: {float(growth_rate):.6f}x")
        print(f"Actual n=70 value: {format_mp(n70_value)}")
        return
    
    if puzzle_number not in alpha_values:
        print(f"No alpha value available for puzzle {puzzle_number}")
        return
    
    alpha = alpha_values[puzzle_number]
    predicted_value, a, b = calculate_prediction(puzzle_number, alpha)
    
    if predicted_value is None:
        return
    
    real_value = next((x[1] for x in target_numbers if x[0] == puzzle_number), None)
    
    print(f"\nPuzzle {puzzle_number} Calculation:")
    print(f"Using alpha: {alpha}")
    print(f"Base exponential model: {format_mp(a)} * {format_mp(b)}^n")
    
    if real_value is not None:
        print(f"Real Value: {format_mp(real_value)}")
    print(f"Predicted Value: {format_mp(predicted_value, 2)}")
    
    if real_value is not None:
        error_percentage = abs((predicted_value - real_value) / real_value) * 100
        print(f"Percentage error: {format_mp(error_percentage, 10)}%")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Calculate puzzle values using provided alpha values.")
    parser.add_argument("puzzle_number", type=int, help="Puzzle number to calculate")
    args = parser.parse_args()
    main(args.puzzle_number) 

If anyone knows what to do next with this - here you go.

python3 test.py 68

Puzzle 68 Calculation:
Using alpha: 8.692996380248756
Base exponential model: 0.68972090704257297155081468833675824716161023623689914791953650562051467261304 4419972598777231639024182489182413058156841483121232343334326952277688035030318 1311309574260048040167879840662353500733521425500975021869380914054885130184442 40544507079388243203845236809052465256422016436329883051889524096 * 2.00446149587820417640494244738360788449393817055989304597589376020405549833178 4239005365118701510143617670147330576209009738631394722016490414926974514298110 3364613583395133560524755600665108274702675918184495985595413655135405238097981 4864413726673117061462450025066948963321434607944444810622903302^n
Real Value: 219898266213316039825
Predicted Value: 219898266215462633472.00
Percentage error: 0.00000000%


python3 test.py 69

Puzzle 69 Prediction:
Using interpolated alpha: -7.804319

According to this, puzzle 69 starts with 1ba45e.....


I don't have the nerves to improve this for the better.  

i tried found key in range [ 1ba45e000000000000 ~ 1ba45effffffffffff ],
but not match key.

fail

[AlanJohnson]

you should already be rich enough to participate in this puzzle.

So, honestly speaking, this puzzle was made by a rich person for rich people—the rich will get richer, and the poor will get poorer. Right?   

Yep... Or maybe you manage to use vast.ai for free by hacking their system—exploiting 3,000 GPUs, stolen credit cards, or even the puzzle creator himself, as you’ve already written somewhere. The problem is, you could end up in prison. It’s better to just go fishing.

Do you really think these puzzles are solved fairly? With savings? Who even has that much in savings? Come on! 

Let's clear few things up:

1) This whole thing isn't any form of lottery or puzzle or any other "play" for fun

2) This whole thing isn't meant to make someone happy or make someone poor rich

3) Nobody has the obligation to do anything with it

4) This whole thing is made as an indicator of how safe bitcoin is at current time (some sort of measurement tool for how much cracking power is available out there to attack bitcoin cryptograhy)



You are here long enough to know that i think...

Yes, it's frustrating to see "free" money sitting there but we can't grab them but the bitter truth is ... it's over for small players.

I will still be watchinge the progress but it's better to do something else than wasting energy and time on this at this point of difficulty.

[kTimesG]

I have developed a prediction model based on the @HomelessPhD model for alpha values:

According to this, puzzle 69 starts with 1ba45e.....

i tried found key in range [ 1ba45e000000000000 ~ 1ba45effffffffffff ],
but not match key.

fail

What did you expect? I hope it wasn't an expensive lesson to learn.

Only thing here that should be clearly stated is that a model you are using for prognosis should have a number of parameters less than a number of observations - simple polynomial approximation with an order of n will ideally fit the dataset of n points (it will have exactly n roots) just memorizing the data instead of retrieving the logic behind the data - same correct for complex models like SVM or neural networks - they could just memorize (overfit) the data but in a less obvious way - so be carefull using them or you will lose your precious time for mathematical madness.

[farou9]

i tried found key in range [ 1ba45e000000000000 ~ 1ba45effffffffffff ],
but not match key.

fail

   silly question but you made shore to check the compressed addresses

[denyAKA BLACKANGEL]

i hoppe this help,if  you have a succes you can write 

                                                  1f3010a2b8793d347f      19vkiEaebeLmrjJkuoYtLetpobkjWLcv9D
                                                  177590b696ee793041      19vkiEah776mXf2m8nXRBFSyKeffPDiwpL 
                                                  1f4eb0b57715269183      19vkiEaJV6PWrWTGhqBhfVvZqJ1Fo9NFTD
                                                  16833c184839cc383a      19vkiEaNn9TRKZ4Y7gyNNob4WTEnc5D5FU
                                                  1ae324e2c108b33737      19vkiEakZw2EengwkWRBikpXAbL2TzFJHW
                                                  17716a73fe1e9f233b      19vkiEatqjCiA4qzVYmVTTgvZVm1499Yqg
                                                  1873f9c83bdd2ddc5b      19vkiEaq6wcVd9VzxGu3wPLcqPVmAY44b2
                                                  17ecea3fd10f9309a1      19vkiEa49TuRsfmk5gokx2uQQFzmyDH3sN
                                                  17ecea3fd123280cdc      19vkiEaWGUW6Phcnr6KLGbKNN3q2P9PwjW
                                                  1e5b4754a58d3fc59d      19vkiEaSFApUaWLea6NCtUWwYZkyD9vGM8
                                                  19b0b29424564ba65e      19vkiEaBi5VkRbADHVH3gNSJTrynNwEjZS
                                                  1e857a4c954bc9896a      19vkiEaBGF19bq7nhKUAM91WR7p5LQL68
                                                  1f171b6772f3daf7b3      19vkiEafXjcmpggNZijSULAZ6XT9M8j6MX
                                                  1f1568dbd4f8378a26      19vkiEaGNcbwBf8QVPh5cy3LmyENBYcuuM
                                                  177590b696dc4dedc2      19vkiEaXNynCbJteXbTPdsE9x9cDcd88bq
                                                  13871339bbcf9f2539      19vkiEaZmk6Jwf7Ep4oYviwht3brThkaE1
                                                  15f74cc42bac0c9077      19vkiE1v5PagT8TPkP3JWN9MGiH5ooQiQ

[papiro08]

I found this haha ​​it's a joke 
Hash160: 61eb8a50c8673cd3fd9d73ee90c733ff24b6e64f
BTC Address: 19vkiEajf1jD23km6G6DdSQXH2VhWP3kHG

[denyAKA BLACKANGEL]

ahhahha you need more not one and when you have luck you have a match

[pbies]

Since few weeks ago I know for now that we won't hit puzzle 69 without broader talk about maths in this case.

[GoldTiger69]

I found this haha ​​it's a joke 
Hash160: 61eb8a50c8673cd3fd9d73ee90c733ff24b6e64f
BTC Address: 19vkiEajf1jD23km6G6DdSQXH2VhWP3kHG

I found this one:
PK:   19665F6056877D8B5B
Public Key    : 02502C2518C06231BDDACA06491E0B790DB9478B56B8DCD2E255CA7E7380E97267
Found Hash160 : 61eb8a50c8673c376c4bdb96d179afecaadbd140

I'm very curious about the distance between the 2 addresses.

[denyAKA BLACKANGEL]

i can provide more address with 16 exact caracter but not today 

[nightdreams]

i hoppe this help,if  you have a succes you can write 

                                                  1f3010a2b8793d347f      19vkiEaebeLmrjJkuoYtLetpobkjWLcv9D
                                                  177590b696ee793041      19vkiEah776mXf2m8nXRBFSyKeffPDiwpL 
                                                  1f4eb0b57715269183      19vkiEaJV6PWrWTGhqBhfVvZqJ1Fo9NFTD
                                                  16833c184839cc383a      19vkiEaNn9TRKZ4Y7gyNNob4WTEnc5D5FU
                                                  1ae324e2c108b33737      19vkiEakZw2EengwkWRBikpXAbL2TzFJHW
                                                  17716a73fe1e9f233b      19vkiEatqjCiA4qzVYmVTTgvZVm1499Yqg
                                                  1873f9c83bdd2ddc5b      19vkiEaq6wcVd9VzxGu3wPLcqPVmAY44b2
                                                  17ecea3fd10f9309a1      19vkiEa49TuRsfmk5gokx2uQQFzmyDH3sN
                                                  17ecea3fd123280cdc      19vkiEaWGUW6Phcnr6KLGbKNN3q2P9PwjW
                                                  1e5b4754a58d3fc59d      19vkiEaSFApUaWLea6NCtUWwYZkyD9vGM8
                                                  19b0b29424564ba65e      19vkiEaBi5VkRbADHVH3gNSJTrynNwEjZS
                                                  1e857a4c954bc9896a      19vkiEaBGF19bq7nhKUAM91WR7p5LQL68
                                                  1f171b6772f3daf7b3      19vkiEafXjcmpggNZijSULAZ6XT9M8j6MX
                                                  1f1568dbd4f8378a26      19vkiEaGNcbwBf8QVPh5cy3LmyENBYcuuM
                                                  177590b696dc4dedc2      19vkiEaXNynCbJteXbTPdsE9x9cDcd88bq
                                                  13871339bbcf9f2539      19vkiEaZmk6Jwf7Ep4oYviwht3brThkaE1
                                                  15f74cc42bac0c9077      19vkiE1v5PagT8TPkP3JWN9MGiH5ooQiQ

What program you used to find the prefix
new to here

[bitcoinpuzzles621]

Oh wow, alot has happened since I stopped checking the forum posts for almost 2 months again.   So is there really no sense in trying to solve any of the remaining puzzles now because bram has a superior method thats fast enough to solve all of them?   Can anyone tell me as just confirmation?   Or maybe I understood some of the previous discussions wrong.   I might still keep trying though if anyone thinks  that the higher numbered puzzles will still take a very long time to solve no matter what.   My method is slow though and I dont have too many GPUs,  thats why im asking here again to make sure its even worth the time to keep trying to do any of the remaining unsolved puzzles.

[E36cat]

Oh wow, alot has happened since I stopped checking the forum posts for almost 2 months again.   So is there really no sense in trying to solve any of the remaining puzzles now because bram has a superior method thats fast enough to solve all of them?   Can anyone tell me as just confirmation?   Or maybe I understood some of the previous discussions wrong.   I might still keep trying though if anyone thinks  that the higher numbered puzzles will still take a very long time to solve no matter what.   My method is slow though and I dont have too many GPUs,  thats why im asking here again to make sure its even worth the time to keep trying to do any of the remaining unsolved puzzles.

go fishing