Search content
Sort by

Showing 20 of 36 results by tmar777
Post
Topic
Board Bitcoin Discussion
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
by
tmar777
on 01/06/2025, 15:16:01 UTC
In the end, any valid point has a unique 7-dimensional scalar. I think a trial and error search of common coefficients on lower dimensions (same orbit, or finding the distance between orbits) may simplify the ECDLP (with some sort of pollard rho). It might also be nothin'.
Can you elaborate more on this? Send me a DM. I am working on this idea.

Let's drill through the ECC torus hyper-dimensions and crack open the orbitals faster than a MIT graduate can re-engineer a cat's laser toy to emit 256-bit math in a 16x16 dots grid light in real-time!

The trick is easy: let's say we have some valid k as a private key. It's gonna have this form because of the n - 1 upper bound:

k = c1 * a + c2 * b + c3 * c + c4 *d + c5 * e + c6 * f + c7

c1 to c7 are the unknown ranks of each "digit". Every digit has an upper bound (product of the lower-level  rank factors).

Mission? Find k somehow, given all the properties we can take advantage of (endomorphisms for the 3-orbital, symmetry for the 2-orbital, lambda products and zero-sum of orbit points... you get the point).

Build it up as a lattice or some sort of HNP. Use heuristics to search for k + delta to optimize your equations system (e.g. move around the public key, maybe in a really smart way!).

I ain't got time for this though. Some screws didn't fit back anymore, and my cat is angry that I broke its laser again. BTW never try to solder 256 diodes by hand.

You can mention me in the thank you notes inside the first page's footer of your breakthrough paper, though.

How can this be done without any side-channel info?
What degree do you hold?
Post
Topic
Board Bitcoin Discussion
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
by
tmar777
on 31/05/2025, 15:44:44 UTC
If I understood your question right, maybe one possible way to simplify the check is to first verify whether both points are n-torsion points (nP = O and nQ = O). If not, you can already rule out that they belong to the same n-order subgroup. If they both are, i think you have to build up the entire subgroup as you said, i don't think there is a direct way to check. But at least the n-torsion check can help "quickly" exclude cases that definitely don’t match, or at least use less computation. Could this make sense?

I used the wrong terminology. I meant quick-checking whether two points belong to the same orbit. Since n - 1 divides by 2, 3, 149, 631, .... So all points on the curve can be grouped in orbits of size 2, 3, 149, 631. The sum of all points (and scalars) of each distinct orbit is O (0).

In the end, any valid point has a unique 7-dimensional scalar. I think a trial and error search of common coefficients on lower dimensions (same orbit, or finding the distance between orbits) may simplify the ECDLP (with some sort of pollard rho). It might also be nothin'.

Can you elaborate more on this? Send me a DM. I am working on this idea.
Post
Topic
Board Bitcoin Discussion
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
by
tmar777
on 11/05/2025, 09:27:56 UTC
the prefix method is always the better choice

You're right! I finally cracked the puzzle (of what's happening here and why this is my last post indeed).

- I know why McD is pushing fwd with the magic theory, even after being debated and refuted for 50 pages
- I know why nomachine publishes dozens of scripts from his code folder.
- I know why Akito is too bored and sees conspiracies everywhere (remember when you PM'ed me when 130 was snitched to tell me that RC is the creator dude? bad day indeed)
- I know why real facts are refuted so intensely in this thread.

It's dead simple: considering that what happens here would make zero sense in the real world, my best guess is that at least part of you are straight-up mass manipulators (not even trolls). And I know why you do it, it's not at all hard to guess. After all, what's the best way of increasing your own chances than to convince everyone else of using some better methods, that actually are the worst ones imaginable?

GG to the guy(s) pulling the strings. You won. Since this thread is the go-to destination of anyone new to the puzzle, your mission will continue successfully. Others, like me, gave up fighting the disinformation wave. It's simply not worth it.

Can someone explain in a cohesive and easy to understand way why the prefix method is superior and how does it work?
There is no conspiracy. If you treat everyone the way you do, sooner or later, you end up getting what you deserve.


Do not distort, cut, or misrepresent my words.

Quote
Something I had forgotten to mention: while the prefix method does not represent a global improvement over the sequential method, this only applies in cases where 100% of the ranges are being scanned. However, if one is testing luck rather than exhaustive searching, the prefix method is always the better choice. If we exclude the option of scanning omitted ranges in extreme cases, the prefix method will achieve the objective faster, with fewer checks, and a 90% success rate.

There is no statistical advantage between the methods if the goal is to scan the entire range and global metrics are analyzed. Although the success rate is lower, it remains high and is superior to the sequential method for our specific need, which will never be to scan the entire range. If we avoid exploring omitted ranges, the probability of failure stays between 10% and 20%.

Code:
import hashlib
import random
import time
import math
import statistics
import scipy.stats as st
from math import ceil

# Configuration
TOTAL_SIZE = 100_000
RANGE_SIZE = 4_096
PREFIX_LENGTH = 3
SIMULATIONS = 1000
SECP256K1_ORDER = int("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16)

print(f"""
=== Configuration ===
Total numbers: {TOTAL_SIZE:,}
Block size: {RANGE_SIZE:,}
Total blocks needed: {ceil(TOTAL_SIZE/RANGE_SIZE)}
Prefix: {PREFIX_LENGTH} characters (16^{PREFIX_LENGTH} = {16**PREFIX_LENGTH:,} combinations)
Simulations: {SIMULATIONS}
secp256k1 order: {SECP256K1_ORDER}
""")

def generate_h160(data):
    h = hashlib.new('ripemd160', str(data).encode('utf-8'))
    return h.hexdigest()

def shuffled_block_order(total_blocks):
    blocks = list(range(total_blocks))
    random.shuffle(blocks)
    return blocks

def sequential_search(dataset, block_size, target_hash, block_order):
    checks = 0
    for block_idx in block_order:
        start = block_idx * block_size
        end = min(start + block_size, len(dataset))
        for i in range(start, end):
            checks += 1
            if generate_h160(dataset[i]) == target_hash:
                return {"checks": checks, "found": True, "index": i}
    return {"checks": checks, "found": False}

def prefix_search(dataset, block_size, prefix_len, target_hash, block_order):
    prefix_hash = target_hash[:prefix_len]
    checks = 0
    ranges_to_scan = []
    skip_counter = 0
    scan_increment = 1

    for block_idx in block_order:
        start = block_idx * block_size
        end = min(start + block_size, len(dataset))  # Límite seguro
        found_prefix = False

        for i in range(start, end):
            checks += 1
            h = generate_h160(dataset[i])
            if h == target_hash:
                return {"checks": checks, "found": True, "index": i}
            if not found_prefix and h.startswith(prefix_hash):
                found_prefix = True
                ranges_to_scan.append({"start": i + 1, "end": end})
                skip_counter += 1
                break

        if skip_counter >= 4 and ranges_to_scan:
            for _ in range(min(scan_increment, len(ranges_to_scan))):
                r = ranges_to_scan.pop(0)
                for i in range(r["start"], r["end"]):
                    checks += 1
                    if generate_h160(dataset[i]) == target_hash:
                        return {"checks": checks, "found": True, "index": i}
            skip_counter = 0
            scan_increment += 1

    ###for r in ranges_to_scan:
        ###for i in range(r["start"], r["end"]):
            ###checks += 1
            ###if generate_h160(dataset[i]) == target_hash:
                ###return {"checks": checks, "found": True, "index": i}

    return {"checks": checks, "found": False}

def compute_cohens_d(list1, list2):
    if len(list1) < 2 or len(list2) < 2:
        return float('nan')
    n1, n2 = len(list1), len(list2)
    m1, m2 = statistics.mean(list1), statistics.mean(list2)
    s1, s2 = statistics.stdev(list1), statistics.stdev(list2)
   
    pooled_std = math.sqrt(((n1-1)*s1**2 + (n2-1)*s2**2) / (n1+n2-2))
    if pooled_std == 0:
        return float('nan')
    return (m1 - m2) / pooled_std

def correct_coefficient_of_variation(data):
    if not data or statistics.mean(data) == 0:
        return float('nan')
    return (statistics.stdev(data) / statistics.mean(data)) * 100

def longest_streak(outcomes, letter):
    max_streak = current = 0
    for o in outcomes:
        current = current + 1 if o == letter else 0
        max_streak = max(max_streak, current)
    return max_streak

def ascii_bar(label, value, max_value, bar_length=50):
    bar_count = int((value / max_value) * bar_length) if max_value > 0 else 0
    return f"{label:12}: {'#' * bar_count} ({value})"

def compare_methods():
    results = {
        "sequential": {"wins": 0, "success": 0, "checks": [], "times": []},
        "prefix": {"wins": 0, "success": 0, "checks": [], "times": []},
        "ties": 0
    }
    outcome_history = []
    total_blocks = ceil(TOTAL_SIZE / RANGE_SIZE)

    for _ in range(SIMULATIONS):
        max_offset = SECP256K1_ORDER - TOTAL_SIZE - 1
        offset = random.randint(0, max_offset)
        dataset = [offset + i for i in range(TOTAL_SIZE)]
        target_num = random.choice(dataset)
        target_hash = generate_h160(target_num)
        block_order = shuffled_block_order(total_blocks)

        start = time.perf_counter()
        seq_res = sequential_search(dataset, RANGE_SIZE, target_hash, block_order)
        seq_time = time.perf_counter() - start

        start = time.perf_counter()
        pre_res = prefix_search(dataset, RANGE_SIZE, PREFIX_LENGTH, target_hash, block_order)
        pre_time = time.perf_counter() - start

        for method, res, t in [("sequential", seq_res, seq_time), ("prefix", pre_res, pre_time)]:
            if res["found"]:
                results[method]["success"] += 1
                results[method]["checks"].append(res["checks"])
                results[method]["times"].append(t)

        if seq_res["found"] and pre_res["found"]:
            if seq_res["checks"] < pre_res["checks"]:
                results["sequential"]["wins"] += 1
                outcome_history.append("S")
            elif pre_res["checks"] < seq_res["checks"]:
                results["prefix"]["wins"] += 1
                outcome_history.append("P")
            else:
                results["ties"] += 1
                outcome_history.append("T")

    def get_stats(data):
        if not data:
            return {"mean": 0, "min": 0, "max": 0, "median": 0, "stdev": 0}
        return {
            "mean": statistics.mean(data),
            "min": min(data),
            "max": max(data),
            "median": statistics.median(data),
            "stdev": statistics.stdev(data) if len(data) > 1 else 0
        }

    seq_stats = get_stats(results["sequential"]["checks"])
    pre_stats = get_stats(results["prefix"]["checks"])
    seq_time_stats = get_stats(results["sequential"]["times"])
    pre_time_stats = get_stats(results["prefix"]["times"])

    seq_success_rate = results["sequential"]["success"] / SIMULATIONS
    pre_success_rate = results["prefix"]["success"] / SIMULATIONS

    total_comparisons = results["sequential"]["wins"] + results["prefix"]["wins"] + results["ties"]
    seq_win_rate = results["sequential"]["wins"] / total_comparisons if total_comparisons > 0 else 0
    pre_win_rate = results["prefix"]["wins"] / total_comparisons if total_comparisons > 0 else 0

    cv_seq = correct_coefficient_of_variation(results["sequential"]["checks"])
    cv_pre = correct_coefficient_of_variation(results["prefix"]["checks"])

    effect_size = compute_cohens_d(results["sequential"]["checks"], results["prefix"]["checks"])
    if len(results["sequential"]["checks"]) > 1 and len(results["prefix"]["checks"]) > 1:
        t_test = st.ttest_ind(results["sequential"]["checks"], results["prefix"]["checks"], equal_var=False)
    else:
        t_test = None

    print(f"""
=== FINAL ANALYSIS ===

[Success Rates]
Sequential: {seq_success_rate:.1%} ({results['sequential']['success']}/{SIMULATIONS})
Prefix:    {pre_success_rate:.1%} ({results['prefix']['success']}/{SIMULATIONS})

[Performance Metrics]
               | Sequential          | Prefix
---------------+---------------------+--------------------
Checks (mean)  | {seq_stats['mean']:>12,.1f} ± {seq_stats['stdev']:,.1f} | {pre_stats['mean']:>12,.1f} ± {pre_stats['stdev']:,.1f}
Time (mean ms) | {seq_time_stats['mean']*1000:>12.2f} ± {seq_time_stats['stdev']*1000:.2f} | {pre_time_stats['mean']*1000:>12.2f} ± {pre_time_stats['stdev']*1000:.2f}
Min checks     | {seq_stats['min']:>12,} | {pre_stats['min']:>12,}
Max checks     | {seq_stats['max']:>12,} | {pre_stats['max']:>12,}
Coef. Variation| {cv_seq:>11.1f}% | {cv_pre:>11.1f}%

[Comparison When Both Succeed]
Sequential wins: {results['sequential']['wins']} ({seq_win_rate:.1%})
Prefix wins:    {results['prefix']['wins']} ({pre_win_rate:.1%})
Ties:          {results['ties']}

[Statistical Significance]
Cohen's d: {effect_size:.3f}
Welch's t-test: {'t = %.3f, p = %.4f' % (t_test.statistic, t_test.pvalue) if t_test else 'Insufficient data'}
""")

    non_tie_outcomes = [o for o in outcome_history if o != "T"]
    streak_analysis = f"""
=== STREAK ANALYSIS ===
Longest Sequential streak: {longest_streak(outcome_history, 'S')}
Longest Prefix streak:    {longest_streak(outcome_history, 'P')}
Expected max streak:      {math.log(len(non_tie_outcomes), 2):.1f} (for {len(non_tie_outcomes)} trials)
"""
    print(streak_analysis)

    max_wins = max(results["sequential"]["wins"], results["prefix"]["wins"], results["ties"])
    print("=== WIN DISTRIBUTION ===")
    print(ascii_bar("Sequential", results["sequential"]["wins"], max_wins))
    print(ascii_bar("Prefix", results["prefix"]["wins"], max_wins))
    print(ascii_bar("Ties", results["ties"], max_wins))

if __name__ == '__main__':
    compare_methods()

test #1

Code:
=== Configuration ===
Total numbers: 100,000
Block size: 4,096
Total blocks needed: 25
Prefix: 3 characters (16^3 = 4,096 combinations)
Simulations: 1000
secp256k1 order: 115792089237316195423570985008687907852837564279074904382605163141518161494337


=== FINAL ANALYSIS ===

[Success Rates]
Sequential: 100.0% (1000/1000)
Prefix:    85.1% (851/1000)

[Performance Metrics]
               | Sequential          | Prefix
---------------+---------------------+--------------------
Checks (mean)  |     49,871.6 ± 28,366.8 |     42,476.4 ± 23,538.4
Time (mean ms) |       124.07 ± 71.32 |       107.76 ± 60.40
Min checks     |          106 |          106
Max checks     |       99,737 |       89,445
Coef. Variation|        56.9% |        55.4%

[Comparison When Both Succeed]
Sequential wins: 214 (25.1%)
Prefix wins:    603 (70.9%)
Ties:          34

[Statistical Significance]
Cohen's d: 0.282
Welch's t-test: t = 6.129, p = 0.0000


=== STREAK ANALYSIS ===
Longest Sequential streak: 6
Longest Prefix streak:    12
Expected max streak:      9.7 (for 817 trials)

=== WIN DISTRIBUTION ===
Sequential  : ################# (214)
Prefix      : ################################################## (603)
Ties        : ## (34)

Each block has 4096 hashes. If the hash we are trying to find is located in a block that doesn't start with this prefix, then we have missed it, right?
Post
Topic
Board Bitcoin Discussion
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
by
tmar777
on 11/05/2025, 08:30:42 UTC
the prefix method is always the better choice

You're right! I finally cracked the puzzle (of what's happening here and why this is my last post indeed).

- I know why McD is pushing fwd with the magic theory, even after being debated and refuted for 50 pages
- I know why nomachine publishes dozens of scripts from his code folder.
- I know why Akito is too bored and sees conspiracies everywhere (remember when you PM'ed me when 130 was snitched to tell me that RC is the creator dude? bad day indeed)
- I know why real facts are refuted so intensely in this thread.

It's dead simple: considering that what happens here would make zero sense in the real world, my best guess is that at least part of you are straight-up mass manipulators (not even trolls). And I know why you do it, it's not at all hard to guess. After all, what's the best way of increasing your own chances than to convince everyone else of using some better methods, that actually are the worst ones imaginable?

GG to the guy(s) pulling the strings. You won. Since this thread is the go-to destination of anyone new to the puzzle, your mission will continue successfully. Others, like me, gave up fighting the disinformation wave. It's simply not worth it.

Can someone explain in a cohesive and easy to understand way why the prefix method is superior and how does it work?
There is no conspiracy. If you treat everyone the way you do, sooner or later, you end up getting what you deserve.


Do not distort, cut, or misrepresent my words.

Quote
Something I had forgotten to mention: while the prefix method does not represent a global improvement over the sequential method, this only applies in cases where 100% of the ranges are being scanned. However, if one is testing luck rather than exhaustive searching, the prefix method is always the better choice. If we exclude the option of scanning omitted ranges in extreme cases, the prefix method will achieve the objective faster, with fewer checks, and a 90% success rate.

There is no statistical advantage between the methods if the goal is to scan the entire range and global metrics are analyzed. Although the success rate is lower, it remains high and is superior to the sequential method for our specific need, which will never be to scan the entire range. If we avoid exploring omitted ranges, the probability of failure stays between 10% and 20%.

Code:
import hashlib
import random
import time
import math
import statistics
import scipy.stats as st
from math import ceil

# Configuration
TOTAL_SIZE = 100_000
RANGE_SIZE = 4_096
PREFIX_LENGTH = 3
SIMULATIONS = 1000
SECP256K1_ORDER = int("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16)

print(f"""
=== Configuration ===
Total numbers: {TOTAL_SIZE:,}
Block size: {RANGE_SIZE:,}
Total blocks needed: {ceil(TOTAL_SIZE/RANGE_SIZE)}
Prefix: {PREFIX_LENGTH} characters (16^{PREFIX_LENGTH} = {16**PREFIX_LENGTH:,} combinations)
Simulations: {SIMULATIONS}
secp256k1 order: {SECP256K1_ORDER}
""")

def generate_h160(data):
    h = hashlib.new('ripemd160', str(data).encode('utf-8'))
    return h.hexdigest()

def shuffled_block_order(total_blocks):
    blocks = list(range(total_blocks))
    random.shuffle(blocks)
    return blocks

def sequential_search(dataset, block_size, target_hash, block_order):
    checks = 0
    for block_idx in block_order:
        start = block_idx * block_size
        end = min(start + block_size, len(dataset))
        for i in range(start, end):
            checks += 1
            if generate_h160(dataset[i]) == target_hash:
                return {"checks": checks, "found": True, "index": i}
    return {"checks": checks, "found": False}

def prefix_search(dataset, block_size, prefix_len, target_hash, block_order):
    prefix_hash = target_hash[:prefix_len]
    checks = 0
    ranges_to_scan = []
    skip_counter = 0
    scan_increment = 1

    for block_idx in block_order:
        start = block_idx * block_size
        end = min(start + block_size, len(dataset))  # Límite seguro
        found_prefix = False

        for i in range(start, end):
            checks += 1
            h = generate_h160(dataset[i])
            if h == target_hash:
                return {"checks": checks, "found": True, "index": i}
            if not found_prefix and h.startswith(prefix_hash):
                found_prefix = True
                ranges_to_scan.append({"start": i + 1, "end": end})
                skip_counter += 1
                break

        if skip_counter >= 4 and ranges_to_scan:
            for _ in range(min(scan_increment, len(ranges_to_scan))):
                r = ranges_to_scan.pop(0)
                for i in range(r["start"], r["end"]):
                    checks += 1
                    if generate_h160(dataset[i]) == target_hash:
                        return {"checks": checks, "found": True, "index": i}
            skip_counter = 0
            scan_increment += 1

    ###for r in ranges_to_scan:
        ###for i in range(r["start"], r["end"]):
            ###checks += 1
            ###if generate_h160(dataset[i]) == target_hash:
                ###return {"checks": checks, "found": True, "index": i}

    return {"checks": checks, "found": False}

def compute_cohens_d(list1, list2):
    if len(list1) < 2 or len(list2) < 2:
        return float('nan')
    n1, n2 = len(list1), len(list2)
    m1, m2 = statistics.mean(list1), statistics.mean(list2)
    s1, s2 = statistics.stdev(list1), statistics.stdev(list2)
   
    pooled_std = math.sqrt(((n1-1)*s1**2 + (n2-1)*s2**2) / (n1+n2-2))
    if pooled_std == 0:
        return float('nan')
    return (m1 - m2) / pooled_std

def correct_coefficient_of_variation(data):
    if not data or statistics.mean(data) == 0:
        return float('nan')
    return (statistics.stdev(data) / statistics.mean(data)) * 100

def longest_streak(outcomes, letter):
    max_streak = current = 0
    for o in outcomes:
        current = current + 1 if o == letter else 0
        max_streak = max(max_streak, current)
    return max_streak

def ascii_bar(label, value, max_value, bar_length=50):
    bar_count = int((value / max_value) * bar_length) if max_value > 0 else 0
    return f"{label:12}: {'#' * bar_count} ({value})"

def compare_methods():
    results = {
        "sequential": {"wins": 0, "success": 0, "checks": [], "times": []},
        "prefix": {"wins": 0, "success": 0, "checks": [], "times": []},
        "ties": 0
    }
    outcome_history = []
    total_blocks = ceil(TOTAL_SIZE / RANGE_SIZE)

    for _ in range(SIMULATIONS):
        max_offset = SECP256K1_ORDER - TOTAL_SIZE - 1
        offset = random.randint(0, max_offset)
        dataset = [offset + i for i in range(TOTAL_SIZE)]
        target_num = random.choice(dataset)
        target_hash = generate_h160(target_num)
        block_order = shuffled_block_order(total_blocks)

        start = time.perf_counter()
        seq_res = sequential_search(dataset, RANGE_SIZE, target_hash, block_order)
        seq_time = time.perf_counter() - start

        start = time.perf_counter()
        pre_res = prefix_search(dataset, RANGE_SIZE, PREFIX_LENGTH, target_hash, block_order)
        pre_time = time.perf_counter() - start

        for method, res, t in [("sequential", seq_res, seq_time), ("prefix", pre_res, pre_time)]:
            if res["found"]:
                results[method]["success"] += 1
                results[method]["checks"].append(res["checks"])
                results[method]["times"].append(t)

        if seq_res["found"] and pre_res["found"]:
            if seq_res["checks"] < pre_res["checks"]:
                results["sequential"]["wins"] += 1
                outcome_history.append("S")
            elif pre_res["checks"] < seq_res["checks"]:
                results["prefix"]["wins"] += 1
                outcome_history.append("P")
            else:
                results["ties"] += 1
                outcome_history.append("T")

    def get_stats(data):
        if not data:
            return {"mean": 0, "min": 0, "max": 0, "median": 0, "stdev": 0}
        return {
            "mean": statistics.mean(data),
            "min": min(data),
            "max": max(data),
            "median": statistics.median(data),
            "stdev": statistics.stdev(data) if len(data) > 1 else 0
        }

    seq_stats = get_stats(results["sequential"]["checks"])
    pre_stats = get_stats(results["prefix"]["checks"])
    seq_time_stats = get_stats(results["sequential"]["times"])
    pre_time_stats = get_stats(results["prefix"]["times"])

    seq_success_rate = results["sequential"]["success"] / SIMULATIONS
    pre_success_rate = results["prefix"]["success"] / SIMULATIONS

    total_comparisons = results["sequential"]["wins"] + results["prefix"]["wins"] + results["ties"]
    seq_win_rate = results["sequential"]["wins"] / total_comparisons if total_comparisons > 0 else 0
    pre_win_rate = results["prefix"]["wins"] / total_comparisons if total_comparisons > 0 else 0

    cv_seq = correct_coefficient_of_variation(results["sequential"]["checks"])
    cv_pre = correct_coefficient_of_variation(results["prefix"]["checks"])

    effect_size = compute_cohens_d(results["sequential"]["checks"], results["prefix"]["checks"])
    if len(results["sequential"]["checks"]) > 1 and len(results["prefix"]["checks"]) > 1:
        t_test = st.ttest_ind(results["sequential"]["checks"], results["prefix"]["checks"], equal_var=False)
    else:
        t_test = None

    print(f"""
=== FINAL ANALYSIS ===

[Success Rates]
Sequential: {seq_success_rate:.1%} ({results['sequential']['success']}/{SIMULATIONS})
Prefix:    {pre_success_rate:.1%} ({results['prefix']['success']}/{SIMULATIONS})

[Performance Metrics]
               | Sequential          | Prefix
---------------+---------------------+--------------------
Checks (mean)  | {seq_stats['mean']:>12,.1f} ± {seq_stats['stdev']:,.1f} | {pre_stats['mean']:>12,.1f} ± {pre_stats['stdev']:,.1f}
Time (mean ms) | {seq_time_stats['mean']*1000:>12.2f} ± {seq_time_stats['stdev']*1000:.2f} | {pre_time_stats['mean']*1000:>12.2f} ± {pre_time_stats['stdev']*1000:.2f}
Min checks     | {seq_stats['min']:>12,} | {pre_stats['min']:>12,}
Max checks     | {seq_stats['max']:>12,} | {pre_stats['max']:>12,}
Coef. Variation| {cv_seq:>11.1f}% | {cv_pre:>11.1f}%

[Comparison When Both Succeed]
Sequential wins: {results['sequential']['wins']} ({seq_win_rate:.1%})
Prefix wins:    {results['prefix']['wins']} ({pre_win_rate:.1%})
Ties:          {results['ties']}

[Statistical Significance]
Cohen's d: {effect_size:.3f}
Welch's t-test: {'t = %.3f, p = %.4f' % (t_test.statistic, t_test.pvalue) if t_test else 'Insufficient data'}
""")

    non_tie_outcomes = [o for o in outcome_history if o != "T"]
    streak_analysis = f"""
=== STREAK ANALYSIS ===
Longest Sequential streak: {longest_streak(outcome_history, 'S')}
Longest Prefix streak:    {longest_streak(outcome_history, 'P')}
Expected max streak:      {math.log(len(non_tie_outcomes), 2):.1f} (for {len(non_tie_outcomes)} trials)
"""
    print(streak_analysis)

    max_wins = max(results["sequential"]["wins"], results["prefix"]["wins"], results["ties"])
    print("=== WIN DISTRIBUTION ===")
    print(ascii_bar("Sequential", results["sequential"]["wins"], max_wins))
    print(ascii_bar("Prefix", results["prefix"]["wins"], max_wins))
    print(ascii_bar("Ties", results["ties"], max_wins))

if __name__ == '__main__':
    compare_methods()

test #1

Code:
=== Configuration ===
Total numbers: 100,000
Block size: 4,096
Total blocks needed: 25
Prefix: 3 characters (16^3 = 4,096 combinations)
Simulations: 1000
secp256k1 order: 115792089237316195423570985008687907852837564279074904382605163141518161494337


=== FINAL ANALYSIS ===

[Success Rates]
Sequential: 100.0% (1000/1000)
Prefix:    85.1% (851/1000)

[Performance Metrics]
               | Sequential          | Prefix
---------------+---------------------+--------------------
Checks (mean)  |     49,871.6 ± 28,366.8 |     42,476.4 ± 23,538.4
Time (mean ms) |       124.07 ± 71.32 |       107.76 ± 60.40
Min checks     |          106 |          106
Max checks     |       99,737 |       89,445
Coef. Variation|        56.9% |        55.4%

[Comparison When Both Succeed]
Sequential wins: 214 (25.1%)
Prefix wins:    603 (70.9%)
Ties:          34

[Statistical Significance]
Cohen's d: 0.282
Welch's t-test: t = 6.129, p = 0.0000


=== STREAK ANALYSIS ===
Longest Sequential streak: 6
Longest Prefix streak:    12
Expected max streak:      9.7 (for 817 trials)

=== WIN DISTRIBUTION ===
Sequential  : ################# (214)
Prefix      : ################################################## (603)
Ties        : ## (34)
Post
Topic
Board Bitcoin Discussion
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
by
tmar777
on 06/05/2025, 13:58:38 UTC
Quote
How can we narrow down the searching range by using these numbers?

no way, these are just people trying to find some good option that would help find the key faster, or at least find out where it starts)

yes, but how this would help in this?
Post
Topic
Board Bitcoin Discussion
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
by
tmar777
on 05/05/2025, 16:11:47 UTC
What’s up with this? Nobody dropped a Python script lately? Y’all running low on ideas or what?  Tongue

I have so many ideas—you wouldn’t even believe it. Half of ’em are junk. A few kinda work, but it really depends on the hardware. Python’s slow as hell. But hey, let me hook you up.


This will sound a bit twisted - but the puzzle can be solved with the following formula


Puzzle 65 as example:

(√(2^64)/8192×Y)^2+2^64 = 30568377312064202855

(√(2^64)/8192×6640.something)^2+2^64 = 30568377312064202855

Given equation: ((sqrt(2^64)/8192 * Y)^2 + 2^64) = 30568377312064202855

Simplify sqrt(2^64)
sqrt_2_64 = 2**32

Calculate divisor
divisor = 8192  # = 2**13

Simplify coefficient
coefficient = sqrt_2_64 / divisor  # = 2**19 = 524288

Isolate squared term
target = 30568377312064202855
squared_term = target - 2**64  # = 12121633238354651239

Take square root
sqrt_term = 3481613620  # Approximate sqrt(12121633238354651239)

Solve for Y
Y = sqrt_term / coefficient  # = 3481613620 / 524288 ≈ 6640.651

All puzzles

Code:
from decimal import Decimal, getcontext

# Set precision to 180 significant digits to ensure 100 decimal places after the decimal point
getcontext().prec = 180

# HISTORY list from the puzzle
HISTORY = [
    (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), (69, 297274491920375905804),
    (70, 970436974005023690481), (75, 22538323240989823823367), (80, 1105520030589234487939456)
]

# Process each puzzle in the HISTORY list
for n, value in HISTORY:
    # Step 1: Compute denominator = 2^(n-1)
    denominator = Decimal(2) ** (n - 1)
   
    # Step 2: Compute ratio = value / denominator
    ratio = Decimal(value) / denominator
   
    # Step 3: Compute ratio_minus_1 = ratio - 1
    ratio_minus_1 = ratio - Decimal('1')
   
    # Step 4: Compute sqrt(ratio_minus_1)
    sqrt_ratio = ratio_minus_1.sqrt()
   
    # Step 5: Compute Y_n = 8192 * sqrt(ratio_minus_1)
    Y_n = sqrt_ratio * Decimal(8192)
   
    # Step 6: Format Y_n to 100 decimal places
    formatted_Y = f"{Y_n:.10f}"
   
    # Print the result
    print(f"Puzzle {n}: Y = {formatted_Y}")

Puzzle 20: Y = 6587.5421820281
Puzzle 21: Y = 6988.8505492677
Puzzle 22: Y = 5397.3356389982
Puzzle 23: Y = 4740.4607371014
Puzzle 24: Y = 6951.2980082859
Puzzle 25: Y = 8101.4302440989
Puzzle 26: Y = 6478.3377497627
Puzzle 27: Y = 6696.3480345633
Puzzle 28: Y = 6834.3500056699
Puzzle 29: Y = 5750.5094991661
Puzzle 30: Y = 7876.3187149835
Puzzle 31: Y = 8018.1307321283
Puzzle 32: Y = 5437.1096584031
Puzzle 33: Y = 6664.3531850435
Puzzle 34: Y = 6580.7113769381
Puzzle 35: Y = 3384.8251708914
Puzzle 36: Y = 3959.7663115628
Puzzle 37: Y = 5549.1486413282
Puzzle 38: Y = 2157.4479371615
Puzzle 39: Y = 3453.3392889180
Puzzle 40: Y = 7443.5997756377
Puzzle 41: Y = 4679.2934501967
Puzzle 42: Y = 4609.8758232654
Puzzle 43: Y = 6779.0766164533
Puzzle 44: Y = 7100.7141263824
Puzzle 45: Y = 3028.4631512721
Puzzle 46: Y = 5562.8583573675
Puzzle 47: Y = 6856.6869060302
Puzzle 48: Y = 4905.6830762674
Puzzle 49: Y = 5516.5826397727
Puzzle 50: Y = 2396.8229729939
Puzzle 51: Y = 7456.7661640385
Puzzle 52: Y = 7651.9604283929
Puzzle 53: Y = 5803.2646952590
Puzzle 54: Y = 2684.5146133952
Puzzle 55: Y = 6694.6947438148
Puzzle 56: Y = 3905.7600843559
Puzzle 57: Y = 7851.2758274385
Puzzle 58: Y = 5100.2478999923
Puzzle 59: Y = 7425.8744623402
Puzzle 60: Y = 8063.9531293703
Puzzle 61: Y = 3985.3348435724
Puzzle 62: Y = 6829.3299699825
Puzzle 63: Y = 7984.9768850442
Puzzle 64: Y = 7899.4152467321
Puzzle 65: Y = 6640.6509340932
Puzzle 66: Y = 4146.6148384569
Puzzle 67: Y = 7317.2346798337
Puzzle 68: Y = 5734.9184846022
Puzzle 69: Y = 695.3631018793
Puzzle 70: Y = 6573.9673548600
Puzzle 75: Y = 3600.4645916176
Puzzle 80: Y = 7458.4526018771


You can see here also that Y number for puzzle 69 is low  Grin

How can we narrow down the searching range by using these numbers?
Post
Topic
Board Bitcoin Discussion
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
by
tmar777
on 04/04/2025, 08:10:05 UTC
1. I still cannot understand how and why this work...can you elaborate on this please?
2. what do you mean by "At least I know that if you have the correct base key for the right bit flip?
thanks

Python code:
Code:
xor_masks = {
    67: 0b1100111100000011110111001010001111100110101111010011111001010001,
    66: 0b10111110011010001001010001011000011010100101000011100101000010001,
    65: 0b101011111000111010011101100101011111010010011011001011110011000,
    64: 0b100011111010111000001101100001001111011011101110110100101011,
    63: 0b1100110001101000010000001001010011001100001001011111110111,
    62: 0b100111000010101010111110000101001001111011100101010000010001,
    61: 0b110000110110100101011100100010111101000010011011011011111001,
    60: 0b111111100001011110011111011010110010011000010001000001,
    59: 0b10110110100100110100010001111000001101010100101110110000,
    58: 0b100111001100010100100011110101101111001110110010111011110,
    57: 0b10100110110100011011011111000011010100010100111100011,
    56: 0b1100010111001110100100111000101001110110000000000100000,
    55: 0b10101010000011110000001100100100110000001111011101011,
    54: 0b11100100100000100100100101010010100101110000010111100,
    53: 0b111111110000111011100011011100000011100110110010011,
    52: 0b1000001010001111010011011001101000110000111000011,
    51: 0b101011111000111101011110010111111111011000101011,
    50: 0b1110101000010101111000011110100010110110010101011,
    49: 0b100010111110100010010100111111101010000010110010,
    48: 0b10100100001100100101000001100011100010001100100,
    47: 0b100110010100111101111010010101100001101000101,
    46: 0b100010011111001111100011101110010101010111011,
    45: 0b11011101000000110101111010111100001111111010,
    44: 0b11111110101001100101001011100101001110000,
    43: 0b10100001011000100110110000011101001101110,
    42: 0b10101110111011110001110100111001001110000,
    41: 0b1010110001111001011001010011001110100100,
    40: 0b1011001010001101101101100110000101001,
    39: 0b11010010100000011111001111110000010110,
    38: 0b1110111000111110100000101001100101111,
    37: 0b100010101000100010101001010101101100,
    36: 0b11000100001011111011111010110000011,
    35: 0b1101010001001011011110111010001111,
    34: 0b10110101100110100110111011100010,
    33: 0b1010110100100110101011100100111,
    32: 0b1000111100111010101100111010001,
    31: 0b10101100000001100010111000,
    30: 0b10011010110011001010011011,
    29: 0b1000000111011010101011100001,
    28: 0b10011011101001001100010111,
    27: 0b1010100111100011110001010,
    26: 0b101111111100110110010001,
    25: 0b1011010000100011010,
    24: 0b1000111101010111111011,
    23: 0b1010101001000110101101,
    22: 0b100100001101111110000,
    21: 0b1000101101011001011,
    20: 0b101101001110101010,
    19: 0b101000101101100000,
    18: 0b1111011111110010,
    17: 0b1000100110110000,
    16: 0b11011011001001,
    15: 0b1011100001100,
    14: 0b1011011001111,
    13: 0b101110011111,
    12: 0b10110000100,
    11: 0b1101111100,
    10: 0b111111101,
    9: 0b101100,
    8: 0b11111,
    7: 0b110011,
    6: 0b1110,
    5: 0b1010,
    4: 0b111,
    3: 0b0,
    2: 0b0,
    1: 0b0
}

def generate_private_keys():
    print("Puzzle | Private Key")
    print("-------------------")
    for puzzle in range(1, 68):
        if puzzle in xor_masks:
            puzzle_end = 2**puzzle - 1
            private_key = puzzle_end ^ xor_masks[puzzle]
            print(f"{puzzle:6} | {private_key}")
        else:
            print(f"{puzzle:6} | (Missing XOR mask)")

generate_private_keys()


Is it clearer now? If not, then nothing.  Grin

Hi, still no understand why this works...and why it is more efficient than bruteforcing.
The masks I suppose are the result of Mutagen?
Can you take please two minutes to explain in full?
Thanks
Post
Topic
Board Bitcoin Discussion
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
by
tmar777
on 03/04/2025, 15:46:17 UTC
You might want to check the date of the post Smiley

You don't have to check the calendar for this topic at all. Almost every day feels like April Fools' Day.

I wonder how the 67 was solved. Was it someone very lucky or with access to insane computing power.

Maybe some kind of botnet cracking keys...

=======================================
== Mutagen Puzzle Solver by Denevron ==
=======================================
Starting puzzle: 66 (66-bit)
Target HASH160: 20d45a6a76...94335db8a5
Base Key: 0x2A32ED54F2B4E35EE
Flip count: 6 (override, default was 35)
Total Flips: 90858768
Using: 12 threads
Progress: 11.006092%
Processed: 10000000
Speed: 33.49 Mkeys/s
Elapsed Time: 00:00:02
=======================================
=========== SOLUTION FOUND ============
=======================================
Private key: 0x2832ED74F2B5E35EE
Checked 19165236 combinations
Bit flips: 6
Time: 4.68 seconds (00:00:04)
Speed: 20.20 Mkeys/s
Solution saved to puzzle_66_solution.txt

At least I know that if you have the correct base key for the right bit flip, Mutagen is proven to work—from Puzzle 66 to Puzzle 128. But you have to guess exactly which one it is.  Grin

1. I still cannot understand how and why this work...can you elaborate on this please?
2. what do you mean by "At least I know that if you have the correct base key for the right bit flip?

thanks
Post
Topic
Board Bitcoin Discussion
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
by
tmar777
on 02/04/2025, 13:52:20 UTC
OK, I have to finally admit it.

I had it wrong with the way I was viewing things. I had some spare time (I don't do fishing yet) so I played around with the possibility that maybe, just maybe, prefixes might indeed be useful to accelerate the brute-force.

I can't believe how ashamed I feel, inside out, after managing to speed up a plain old scan search by 800% on average, by using prefixes as a good hint to stop all the GPU instances currently running and reset all the offsets and ranges based on the new informations.

So now my baby is purring out results at an astonishing speed, check this out. If you don't trust that my cracking grid spits out correct keys, you can check them one by one. I'm gonna let you figure out just how many hashes are usually needed to find a 32-bit minimum prefix match, but boy, look at that bad ass speed!!!

https://www.talkimg.com/images/2025/04/01/lcG9b.gif

To apologize for my fuck-up, I'm gonna share a few nice results I managed to grab recently, feel free to use them as you wish!

Code:
0xc4cf15366c5d3e412 1MVDYgVaSeWVxvT8vVRkujyHHoboXcUm6 0372222bf4e46bc20bb3d591f4350f4ccc5ae740040f948d0cce00cb5aef1c96ef
0xa59fc4663314c8c13 1MVDYgVaSCGMAW6FeE9jJJbrv2877Qh4C 035a1a8b0f903340a2e80df22b733e81d0f97c4252739879079d68803371cf72b7
0xa7cf01ad011bf227a 1MVDYgVaTTjBZ4ZPCJv4UYWYSt6792kds 025df7a3396982755ee35189402dda5aaf532c5bbd30f6e584486565929390b3e2
0x8f549725db946b1b8 1MVDYgVa89Q7rBWZaXcTf1UVPJ9BwDCX8 02c8befe745333183bb1ec263134f788fb768f6202053568f65c9c1506a17030e4
0x9468c372a5ce48cd5 1MVDYgVaDCnqjuvMjDSfS1nURGMR8cmuf 03d2a7ad2697e57153d31e4437830df14958dbe52b2dd89674c7e9a5cdf44b7763
0xa6e64129243ee31dc 1MVDYgVaCH57TSAQwoWMqX9Ztz8iNkpzW 0284e277b768a2a0e6d32ba9714ec4fe7d626a80d748c8ff457827f021235682d9
0xb1575cd28d49e82fb 1MVDYgVa7ZsJYQ8SFaXMSfoFJJgtgTtRY 02f03c02369c57339aaed65e1fb691ec3e6ff2bc1e80b15dddaf8e017d6f2761cb
0xc4e3650fd1b15ac18 1MVDYgVaHi8Q8rDmFYxkUkRq9vZpx5fE2 02fa68270c520d74351183b369b09001294f3b9796f1dfae78af15c28a70cb0436
0x8c7450c9a20a70e8d 1MVDYgVa3WmZ7XQK9PvzTBp6GvX96vdhy 03c535511fb1bf74b8433a626734446d8e68509e077b5ca08d09eb01060d1fb6ea
0x98ed1dd57d11bdcc4 1MVDYgVa34juD8zJFk88379qUjXju4ekQ 039a9caa2bb588fedcdfb6c44856f4e73d3044101b37f4cda51e48417ae49fe567
0xe7a0def14aea45067 1MVDYgVZvxTgAhh499DjDcG9YRaSdrAqD 036d6132ccf2e0fdef4bf35e595083930ce2e59fbfd04ad45e172c7994ec131f4e
0xe7c83c2c99506fc88 1MVDYgVa2qshGvVjSTi9MwkSHL1iUm2bU 030aa97b1220ee84638da8f4de8a93a77186f9d0cf54c5091aa39108360aed5770
0xea306846e30c25532 1MVDYgVa2soVBDM8U7vz2PS5Bwwsyvrfm 0320f88f4db86ad51678ee34cc7edf4f33f07b6059499d4eecb7636fdcfd7cedb4
0xf68a81d6a691ec69a 1MVDYgVa5UZv1JpqTMg3bi3oMM9CGJ8D2 03fda232afac8f6c9c79e428fbea4f69d390d33565716e3e0c9f2663709ff4fd24
0x9292254947908c82c 1MVDYgVaX8s2T7LS7Z9jHtHp3VW4d8dFS 037f4d46b12147ca48496a3ccba5a4a1984e67c3fefc4076472722412b2ec6a0a7
0x9ec5992003a4dadc6 1MVDYgVaaysSySK4bbDTKDkX5bsF8VojK 03fdf0c21b3272960296190a9ed54d5cf8e610de7fa24b777b2d1896199f25aa3c
0xa1d1d432e5556bab8 1MVDYgVawZkXLui2q5bH5wfPch1c4sdbn 03e7666c3bf6f535006a4d5cd1029eb5056176f80a11ec7b5f3509bde018e85283
0xaae90eb0cccb66062 1MVDYgVafTYPwaMyoratNAKSoxqWHGNGW 02a440bd241721eadfae0adfc39cc5f01a7961496e9911f17d13e7efb1f047f359
0xb45e67b553064938d 1MVDYgVaa6EGxVvwSnpbxQo3tJukg1uvb 03df9139f5820da4f3c23816d51417da7fc7a08d2b041c8931dd05c26348dcca16
0xc1715aa75c9addff4 1MVDYgVaaKfVGv1sSsfszDjwv77ciwK2C 02bacfd7ace256c8fef2f44fe1d9e9d1e0163e4fb5730eec7613213a0e9577e024
0xc5a3ea3ae2fb3f2e0 1MVDYgVaWC9o4SGj9yr4p17CH7QQSQnmR 029b6833144031ed7e27e3e01ac5adb893cf736ed4a47c9c64c00e6edb6c908fbb
0xcc74ef889d8fb4df8 1MVDYgVanb37tvZL7eXLhit7v9TYuB6Qd 034401be05aaaaf37790aa9f0cb28f8fb2c6be86962c9bad286bcd075c130244ab
0xd4b5b95d9059b0b6a 1MVDYgVb4dqSk9horLK28Yp9CLJgsFhyp 03e39346f8ec02ea5d7d1d15eab91b4fcd751c9c8c18b1ba039cf089a7c32a1769
0xdd48d47cad650d43f 1MVDYgVaeGi2w6xMy519XmjzjFBHbu11D 034994afee63f045733415827d62c4ac821b765bd0eaef6a3a446a478d2d1ea013
0xebf74596a5782a3f3 1MVDYgVb985cANsV7MGUtoYmquC6HogNK 022da6acacc2bf7884dca91b1d535a32799c51cdb7935eae5528a796a834000110
0x80f9a22915619799e 1MVDYgVbczqnMaRQXaXPHKYxGaWKR2VSB 027a32f73fd72476a37ad99513a0aa4994244df5dd97ef4307f39e028ed210d973
0x8286daab06e728065 1MVDYgVcVb59KJCp5D7toEQw91xVoZEk7 027e9d74c0230e30154523e586c78463e7269088913f85e0b76e8f8afb571a43cf
0x830a6dc8e7b186ef4 1MVDYgVbttrNR2iepzfYNvSWVXjzKm3ab 039743581b5a91c059d238b12c4f6175e8fffd12b015832ef71a22ca117d31864e
0x856808a6e195d6ee0 1MVDYgVcLfodUcRARmu3MJdGoBNb2G7QP 0205d67026caef7c016079ce06b98ef3e8bc21440445c557cd8c78c605d736be6c
0x8834d28549e657a6b 1MVDYgVbMndK6gonHeSv8KN4hJKZivtFi 02e86eb277b13a0ef3af813b3cfe977bcca40eaa9f9f0194c96b0ee2e8060e3fcb
0x8b8788ee35ab6f688 1MVDYgVceaSaWk4igpMBBDdXAu2NhPmFX 023b418523b3f8f03b4e4fee46a123ed501ee3e09605f37d0f77678e5cf52dc6ff
0x8d6c43786e61ca0f0 1MVDYgVcWwJ4g6Ru5iRSamGrW9RcuRRCP 020239984c4ff3aca947ddfbb8578eb38db6b4ad8c95f244aabeedf9ee354241ca
0x8f165aab5ef06ad88 1MVDYgVbizW2eYrMVF1x31XedFHNkpsy3 03254ef919d0faa4e32f346410c213c34d9aa600b383e7f72b6e71b4a5f370ee28
0x9a113c6c3562cb270 1MVDYgVbH35pfnuxAaw1QMypNfBrAw5h6 03909b672b3ced7a23a57612d4c13e7c054d4b7eaf76d4037c86f8738b07217f05
0x9c499b345e951c47b 1MVDYgVcaXHFuyNfSGCndHyxfnX1FQ7da 02803c366fc2762596dd2d9850d2d0f904eb306c51f7218306905da648d054ee68
0x9cebd9be1e8635286 1MVDYgVbvJfWvuvcHxGJrmUerPhE4SDro 03a24b1b62952342acef9f2a3d441a24e48e2a159bd9c9767f3b48cb9aaeef55a1
0xa082bf833dd4c729d 1MVDYgVbxhHJSWbFPmpRLBARecQkCULXi 03815a9cf5dc7de202cfd8c9ea0c4063f79dfb89e7780e97f0444a96eced6fe74e
0xa3511b31aa3c7f8a5 1MVDYgVcKYEoNovpX53wWsZZ44cKSvEnG 02788bcf6d9ae17b54e2a7eada5f5f9f0addfbf7d5290d11046cfcdbd582d8bb1c
0xa63215a737a6c13e6 1MVDYgVc6KrA1GensbpNG78ruFtFHi3Y4 02add55320bd62949d5ec2996b3d7e6e82227867ee3af5b3759ca4fdb699c16665
0xa7a74438ca8603bc7 1MVDYgVbczLHJFQyjWH2CCpoTkjdg6He8 02ee6d5228700b1d3c436c28c509f42c85a94cef5d1df8ceb4cb0b199046b71614
0xaf2cf75aaf7d2cfe4 1MVDYgVcJKCkCboRWSuNwdPf8jW4qW3Jq 020a249ab92368fb166be1a77415916b4b324238cd2cb8f2a6ea9521dd306036d1
0xb175e5d7b5149348e 1MVDYgVcGruUyjSyH7Ct5c7S9dgLk3dhh 0306a1b8a294dbfb66b8f634623278daf89df43065bfb01c3264cb0dd9ca012360
0xb2054f604e6fe93e5 1MVDYgVcZw3jnuMQVrgBnVr1capW3QLyo 03d61fc6547389a4ba5b2dc5409cd9ae56247b685b932aaf796f72b81f7af27af0
0xb3f858dfe2c3abc32 1MVDYgVbaNnRKk4866xubVCQthZHNMucR 024291bb32c33666a7fbf6a577d67bb26f54b61b39f2134cb8fe23a0cb20029135
0xb66df5467aa2f5c89 1MVDYgVbeuM7fxzwT6DwbBeEetBwZHnay 03755b0ccab1973d2355eae5095a6006e108560b5dd823903dbdfe672f5f66b07c
0xb8108f1c949edf349 1MVDYgVcNS5rwbw6Ae9P87GBrSUwYNe59 034099eb475e157e01fda361460c44879f2042b24605529c46c96d0303fe75808c
0xb958b8feb47fc3344 1MVDYgVc3jQwGFmXRqE8Brcnt162agbeu 03cf85ea9de786c828d46603491d0d10e1e5624224f737b530657ad27e88a5c439
0xbff333ada94e53a57 1MVDYgVbQVwMuZZ7Fk55mzN9aPVv3HkAE 027103fc06daa9a7ba536353506e560275e45c3d211bccc03cec593fd851bd4daf
0xc251183d8a7cca7a5 1MVDYgVbNrnHEejxuN8E4ACPSV9z9QQj2 038ab193e66457c09257838e2af39a5094b7fc6abd5d6e19b31872fe1b597227b5
0xc2e7c6fd21e66e389 1MVDYgVcZfSJkZ6id2mceBkV7cGXkKqTk 032a6113d7b44a15e46a59843023564471768ca676f02d2e7218f8b976d9da40a8
0xc44afc2001582cd79 1MVDYgVbSHGvy6mdtrQDfh2UoQSyYG9oK 02c3e9d2842fdc53c274b12cb4c9bd1ba0960a341adf4ae76fe2641ce55aa5f618
0xccc7129a330cf2b54 1MVDYgVbbAtBJA7bw8DHj7FUToUU22zZ8 032d5866e989321533d1d8a50296199860a5d1e798568f65336d698892f6a25b48
0xd05c6446a36f37ec7 1MVDYgVbgjPUrteB3ifNLLHepREf1Lfye 039536215bb7ee81ae278c369bd8458289c69df948db918e4c81ae2cfd0721fbb5
0xd173007057baea098 1MVDYgVbbhTssLoUCE1AXWPnFXnquoKzE 02f2933969f86a5841d3a7ac42ba5032d9b31d13096b7e1a8235bf92f3778bec76
0xd9b49644827b2a5d0 1MVDYgVbgA1fkKNECFuTjms4ZJv8JZRcu 025bd8fbbd1b6e9fe530f4c33335358a4c1ab07d77c79d9ba75a65923f097ad41a
0xde34dae79f4c7b982 1MVDYgVcKDLrcgB9WSmb4z3ifmDhiSPiP 02d13c2fec303aed19f586246d73c567db1967307ae580fc778e8bb574e879f50f
0xe59da4cd15b851643 1MVDYgVbF5RLm7sRYk6Epeqj2NwwE9g1P 02bd84576f7c4eb9acedc1ba26f47a8d374b2ff09bba18416faab7ef0cfb5721c6
0xe76651e59864e8ffd 1MVDYgVcTnxhgWxmjdzJCr4o2bTFfWEqo 021f269ae7f3bedc8223e2abb2c66defe76f70448d4052039564d3f20e6cd3aa4e
0xedb056f19b3b7e978 1MVDYgVbMKv6FWAoqU1UmRpPMiDYLpTZK 0290b437276ccd7361b79af0219526f892d345db15b91ce2edf4ade83e2b8e71ff
0xeef3d5de8f60848aa 1MVDYgVc7L3DpYSDcNudjdAXXn7fR45He 02584494f02759351078e8b6efd65ef50264d5b363e053aba6fd177a1236bba189
0xef03db9594d46948d 1MVDYgVbdBLfdiEK1mGy6xXPTfauSzTWg 0271eace4829ea972516eb3f4d3c59a2ad78531b994d8f320b8c8c57e5045fbf73
0xf2f5d60eda10e663b 1MVDYgVbNjRsQbLXQBK4o1BeuZtYyPVWH 026fd6bcaea1558618c38865971d088774c74d3eee1130c52f09df8365b7e31217
0xf68a76a1a957e717e 1MVDYgVcLJFT935gCXxMd4qzZUNGLD7BD 03cfabfdcc89b1c242b860e1023154be7c74d40a85bcfbc612e71882219626d266
0xf7aa3c2801c4622fe 1MVDYgVbGn8hAwUqjv9ZoRRjiB32odVmK 03f04749db897868f0257e1196581d58dd04a880f0a22dc7de955d5743c87b2d31
0xf7c1e9abfde5064ed 1MVDYgVc3hZPHSoxi4C7d8iBQZU8HgiAT 02b30a7b233b3630989dfb9dfb112024b182a451622d5daf9e48682c3996fe237c
0xfbce787b31400e3cd 1MVDYgVbgmHjzXLoTunHtBwqNWKTna8PL 03a5ffe4a8df77dd6afe16e5b7314ed33c64e8897538fceacf7a9f571833874586
0xfe9057e046e196507 1MVDYgVcDS1m8CA2YPkNmNZQq9c8t9f1q 03ae326fb4b2ec9dd7c0915b1add7cb179964e2457661f4b17017ad1f2c3b4b93c
0xff420fc4fe6aa1203 1MVDYgVcGpfkqV7iQXDZb6b55XUVunS5w 03f13e24b4e57de088972d4f9cbd3ca20be80c4e501d561278e70fb0e1b2b375b2
0x88b3e0b282f83009e 1MVDYgVesrxeMuyEHb7zxW3Nb3KjqbfyJ 029824b2d17445069bf9ea7fdb221871cbf4d5069bacc50865e64b4abe4b2a949e
0x8ad59bb29c80889ef 1MVDYgVfM2BvwiofJmYPqL5T5XM7kHWhM 03bb9075fab9e1c28e25e13dd9ded85f22eb4ae2ee883ce331e2182d6c95fa5001
0x8e86c364e15b88007 1MVDYgVcpNBXMhwDW8xgtDQ657NcRNXWM 02e2e6d3ff30c09a8a237b38faaa44b0952ec316df6078cff7a6ef614d1839c94d
0x9103f91ff55f4952f 1MVDYgVfLc65da7jfMyEtuWjDkpiRkN6a 02c0a826f58c00453aca375fbd8d8fbf14931a471a456dc240252db35bb4a54b2d
0x91ab23bdc6bcb328c 1MVDYgVf9X8h4gBMAW2viqGtCPN4Gfmr5 02ed86c4404ce74e42d51de34bcbec1f2b127b8f5141cb789a591fef4b40ce6c91
0x96217b861e12b9b96 1MVDYgVeHQUG1xnGLLRxxaWRqiVx7dtsR 034e97834e9c111136850c6be561b7699be6c17e4a1d8e8b15b158a1eb2f913927
0x975a8968afa93141c 1MVDYgVejxoD691FhZkqwLNsXr3HY6avJ 0204e53e5acf48770a435f1e2d0256f9a8d601cd5094d114778943ab7c4301f1a1
0x977964d6f60cbf2d9 1MVDYgVeC1LEcpdfyVYLhYGC8TPv4VHLV 0331ef8a350a2f20dbdc5c9865e2c1768570002986b4c019496c155c1fa8495b0b
0x996239a0da4cb78a8 1MVDYgVeNZHw9uKhohqfJcJxsXte1dRPG 0241e8d4f4f6b31c31697bf629b2a6f1e291eb34f64b63f2b336085cb1d329e842
0x9d5e6590c5f78ddba 1MVDYgVdadL4qMR1hLyyBa4j8fSM6XkMT 021ae1c43beffefb7e478ec8a2a836b4fb906c7e9ecaf895cd81209a10b54d405c
0x9ff9be752cdfa2884 1MVDYgVdRVv8Ur1dmTpTYdukoTLiraWEo 03df2947a14fbf5564b6e0d6a62680a4248d1788f129d11627f0256fc38ad6e75f
0xa40f0213ddd965953 1MVDYgVebshZjmkWveyyho1sHdpb7USwT 03ac8a1d88ef0c64748fda3026bffc0dbcdd1ca7ed478897ead019eaa492753963
0xa68ecf0c25de252fa 1MVDYgVe12BZLd6MGMRRj7NvwEBsqWebs 02691283c48cc6596c765e72f2c20644f2e3029af89bd0ee6061c84f8015980ec7
0xa8d65f7191dd7cdf9 1MVDYgVeTXvxqG11yTSqyFgtv1rj1D8mT 027e903254caf038a9f8721f13fe42233f267e18133394c324fca95f000646308d
0xab4cac702f0c684e2 1MVDYgVdNQJDutD82NjnD9FJPAFE8guF6 020f223ccfe720f8eb62a869924dc7d3b0ee5d63e80bf86cbb24794aeacd7e688d
0xb0031e137c7b1ff41 1MVDYgVdGYyCpCJFifrbgpqTMEYuteqaH 02d45d1fca587f39c086e32b3e657ae58df5b06437a2cda79c66509106d86f72bb
0xb58061c36fa6cf575 1MVDYgVdjy5S3fTjUHX1s22p22vzpNStm 02a380f59310e64a976452e01c46ac290386a75c7a6a991918ac6874edf2f291e3
0xb8444d33a3e90c4b1 1MVDYgVeEgyAMGB1YuGFQR2qx8Qa6pvgt 03678802cba2fd295ea4462ed3fa223f1bae68b0ba5ce1d5ab7bfa59bd0a090ccc
0xbeb19a4daa70f9a54 1MVDYgVdw2MEbxZMQ3dhtSvL3D2oV8BaJ 03efee90fc03b215ff99412da65b0bc0c4fc70c78eff517cd550c007a6a59d00c4
0xc511c38570914087c 1MVDYgVfMrPwCs3LknHLB3U2mjxtWqW48 023149928889168c4ed1e2229ace1b21b5597b4ed4e1e853bee5d4222d3e987d97
0xc5e006698355486cb 1MVDYgVeiCmNE29eh6MmpmExEcXY7eud8 026fe5da0b489869b92886b7fcb42377dc3025a383b54cd89a818ce04529b63874
0xc7bc8515d67c43583 1MVDYgVf9NzyUA73pURaJdYqwmH21kj8Q 03e1d9fc8f75c782fe218cfb6f356113ebc107ea3cc66ef76b3b0c608b68c6ab0d
0xcabdfaa08f2b4955b 1MVDYgVd9iurd9VaRScV1QWPWkj1mTnwh 03bc014236158a450adce0e88f83dbd7d8a97decd21fe7eeb8a4c7b46f409bd53b
0xd4614e77972dd6143 1MVDYgVfTSEs49AFFUNq6EzVzu1Wb5QhB 0373e3ccb526a3dad4540044ba3555ef498f646e530f8f0d78223d77ffab9a8198
0xd6019f357ffaacb54 1MVDYgVds11pn5Z43NYBfpkGG6V2jAWpB 021e58051d89e0ed871f0a1aaa505373ecc31d43a42ee168210a02e246dfeefc24
0xd9c90b9aadd3e0d8d 1MVDYgVdbNLwHuDWSBXP2vbEx3XnqvrUe 0229484889768d3d4ef89c623d6adeed29442c94dfaff85322c67a429d1c882123
0xdaf8d0f952dc74197 1MVDYgVeYoCFXKE2yLaheoUqqcwdYTKhB 02ba45511a67af6eb2c5b098535425f5721376d10419524762190fd43a15c43ca1
0xdcc6a7d71026def78 1MVDYgVfYMC38QzPuq3pzsS7Z1LHGx5qE 03d9529aea733d3e2d2ed6dedcacb8e82382a0a9037f8521f0fd1181a9a88d1433
0xdd536a767df5c5b74 1MVDYgVe3iSXRqFjXmrCT1DyHJrSZWUDj 029d276ca9bebe25198cf152917e17fd99d9e7e605dd4953e401567ad18c022a17
0xdea515860ae23ad0a 1MVDYgVcsDpz5UoYStrFuWUZbS2FnR9oU 0336345c8359e65c72da464ccf4577b8a535ff4d221fdd846055b2af7c317ad69c
0xdf1cde6807737aecb 1MVDYgVfKYNgjcN2Bj6beC1NyukssuTAm 03e03c34047e1f87b78431bbd3637130facc0ad7b935a0ecfc7e9dd524bcd57973
0xe0c3cef16d85eb043 1MVDYgVcgMxmYSiDXjjzA7utJ82rCDmHY 02a97ca2c620bec36478be7ba97b1157c0a95da7176217af08f0bafa13c1c3e405

... 220k more


But now I have another problem: I have so many prefixes, that computing the next ranges to scan takes a longer time than actually scanning the ranges. This mad spiral requires some GPUs to do the computation of the offsets for the GPU computation (of the offsets of the next GPU computation, because too many prefixes...), what do you think??

I'm gonna start swapping some sweet ranges soon with ya guys, tune up your telegrams if you've got your match-9 or longer address prefixes nicely lined up!


kTimesG
nomachine
bibilgin
Bram24732

I have read in the forum about this method with prefixes but still I cannot understand how on earth can be faster than bruteforcing.
Given the following Hash functions, the avalanche effect, how can this work?
Can any (or better all of you) give a concise answer to the rest of us to understand the following?

1. how can it be faster than brute-forcing?
2. what is the mathematical explanation of this?
3. if using '-f/--flips: Override default flip count' or the default, as long as it is not 1, then doesn't it miss some hashes?

Please give a full explanation in one post each to have it here for anybody who is trying to learn.
Thanks
Post
Topic
Board Bitcoin Discussion
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
by
tmar777
on 18/03/2025, 16:47:09 UTC
What do you think is the set it and forget it best method?

To reverse engineer a random seed when the creator designed the puzzle at that specific moment, as far as I know, zahid888 made the most progress in that area. I gave up after puzzle 60 while searching for the seed.   Grin

what if the see has a salt involved?
can you quote what are you referring for zahid888's work on it?
Post
Topic
Board Bitcoin Discussion
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
by
tmar777
on 18/03/2025, 09:22:05 UTC
The goal here is to guess private keys that are already in use. The rule is that there are no rules about what you should use as a random generator.

RTX 4090 is capable of doing 7.0 - 7.1 GK/s to scan a given range, not 4 or 5. Yes, just the keys in a given interval, not the ones with symmetry or endo (in that case, it can surpass 10 GK/s).

What do you guys even use as a random generator if the speed needs to be 10 GK/s?

Zero PRNG. The keys are in sequence, the only difference between hashing keys at random positions, and keys that are in sequence, is that it's much faster to do them in sequence. And there is no risk to hash the same keys twice, because the birthday paradox cannot occur.

Take a sequence of 2**N keys. You need to have a large N.
Split it evenly by number of threads (let's say, for CUDA, we have 16384 blocks * 256 threads each, and each thread does 2048 point additions at every launch).
Compute the first starting key and delta key (that's only two EC point multiplications).
Compute starting keys for all threads, evenly (that's 16384 * 256 EC group additions - very fast).
Run kernel a required amount of times, to scan full range (it only does EC group additions, and hashing of each key).
For symmetry/endo: also compute hashes of X*beta, X*beta2, combined with -Y. No EC math involved. Also, Y does not even need to be computed at all (except once, for the delta jump) - just check both parities for compressed pubKey!

So: only two point multiplications, and a shitload of group additions. This is how one gets to 10 GK/s using just 450 watts.

Very clever approach! Is this code somewhere available?
I am not an experienced programmer.
Thanks
Post
Topic
Board Bitcoin Discussion
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
by
tmar777
on 13/03/2025, 15:51:57 UTC
Can someone please explain all these "methods" of finding the prefixes? Is it only me who believes that this is nonsense?
I have read so many posts here and still I can't understand why you have chosen this path?
Post
Topic
Board Bitcoin Discussion
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
by
tmar777
on 22/02/2025, 09:03:15 UTC
This puzzle is very strange. If it's for measuring the world's brute forcing capacity, 161-256 are just a waste (RIPEMD160 entropy is filled by 160, and by all of P2PKH Bitcoin). The puzzle creator could improve the puzzle's utility without bringing in any extra funds from outside - just spend 161-256 across to the unsolved portion 51-160, and roughly treble the puzzle's content density.

If on the other hand there's a pattern to find... well... that's awfully open-ended... can we have a hint or two? Cheesy

I am the creator.

You are quite right, 161-256 are silly.  I honestly just did not think of this.  What is especially embarrassing, is this did not occur to me once, in two years.  By way of excuse, I was not really thinking much about the puzzle at all.

I will make up for two years of stupidity.  I will spend from 161-256 to the unsolved parts, as you suggest.  In addition, I intend to add further funds.  My aim is to boost the density by a factor of 10, from 0.001*length(key) to 0.01*length(key).  Probably in the next few weeks.  At any rate, when I next have an extended period of quiet and calm, to construct the new transaction carefully.

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).  It is simply a crude measuring instrument, of the cracking strength of the community.

Finally, I wish to express appreciation of the efforts of all developers of new cracking tools and technology.  The "large bitcoin collider" is especially innovative and interesting!

I've been analyzing the puzzle formation algorithm for two years. Just look at this information. After you figure this out, I'm ready for further dialogue.
https://i.postimg.cc/dVHh5k8h/XLS.jpg

It's part of the algorithm, there's another part, but what's the point of it all if the bots take the entire reward?

DM me, I may help further.
Post
Topic
Board Development & Technical Discussion
Re: Pollard's kangaroo ECDLP solver
by
tmar777
on 14/01/2025, 15:30:06 UTC
what is the order of magnitude in Address/s that can be achieved by commercial GPUs and an optimized code to solve the puzzles without knows public keys, for example puzzle 66.

The number of address/s should be near 10^15 (Peta-addresses/s) to 10^18 (Exa-addreses/s) to solve such puzzles in seconds. Remember each extra bit increment the difficult twice the previous value.

Whaaat  Huh 10^15 addresses/s with a GPU, is it with NVIDIA H100 ?

I was proud of a GPU code that can do SHA256 alone at a rate of 10^10 hash/s, so I can't imagine adding full address calculations and at the same time reducing latency 10^5 times.

Hats off to those who solved previous puzzles, at this level it requires state funded resources.



can you send me a DM? can you share your code?
Post
Topic
Board Development & Technical Discussion
Re: Solving ECDLP with Kangaroos: Part 1 + 2 + RCKangaroo
by
tmar777
on 09/01/2025, 17:30:20 UTC
not at all. did you manage to assemble the code?

I finally managed to compile the VanitySearch and Kangaroo projects by Jean-Luc with the version he uploaded on GitHub. It's much easier now! I hope he'll update his projects to allow us to randomly define a search interval. If you're here, Jean-Luc, we need you! (As for Satoshi, we'll save you for last, haha!)

Best regards,
P.S. A big thank you to Satoshi, even though I lost all my 10 BTC back in 2017 Cry. That’s why I want to try my luck with Jean Luc’s code.
PFR ==> bc1qltyqxw94nynyj9nq8kqfvzuxjrwejd6vrdvhlm

Hi,
this is what i was looking for and just came across!
can you please share your code?
Thanks
Post
Topic
Board Development & Technical Discussion
Re: Solving ECDLP with Kangaroos: Part 1 + 2 + RCKangaroo
by
tmar777
on 05/01/2025, 09:08:38 UTC
Hi albertajuelo and kTimesG

thank you both for your replies, especially albertajuelo's detailed explanation was very helpful!
While being here to solve the puzzle, the process itself has become more interesting than the price itself. The parallel computing power of GPUs it will become my next learning endeavour.
albertajuelo and kTimesG if not bothering you, please DM me as I cannot send you as a newbie (bitcointalk by default has deactivated the option to receive from newbies DMs)
Thanks
Post
Topic
Board Development & Technical Discussion
Re: Solving ECDLP with Kangaroos: Part 1 + 2 + RCKangaroo
by
tmar777
on 01/01/2025, 17:02:28 UTC
Updated Part #1, v1.4:

- added option to make K better at the range edges (for SOTA and SOTA+) - define BETTER_EDGE_K.
- added option to see interval stats - define INTERVAL_STATS.
- fixed some bugs.

First, Happy New Year to everybody!

RetiredCoder thank you for sharing your work!
I had commented on your repo with a pdf that may be useful to speedup the code. Also, I asked you kindly to contact me to my email but you didn't, which is a bit sad, but it's up to you.

Regarding the RCKangaroo version I have three questions:

1) does it use any CPU for DPs?
I ask because I use a rented GPU and I am not sure if I can get a powerful CPU from this provider

2) can you explain a bit the ideal -dp value for small and high puzzles and the impact on each case?

3) i rent an RTX 4090 but no matter the options I use, it doesn't utilize the full RAM of the GPU...why is that? is it from my side or a bug in your updated version?

Thanks

Post
Topic
Board Bitcoin Discussion
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
by
tmar777
on 01/12/2024, 10:15:03 UTC
@Albert0bsd

I use CPU, so my understanding is that I have to use keyhunter, right?
Where can I find the most updated version?
I tried to find it out by reading in the forum but I lost.
Any help appreciated.
Post
Topic
Board Bitcoin Discussion
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
by
tmar777
on 01/12/2024, 09:32:34 UTC
@Etar
@albert0bsd
Thanks for sharing your code with all of us!

Quote from: user_USER
GPU is just parallelization of the process. This is clear. When I was doing tests, something else was interesting. A specific machine, a specific key in the range. (specific task) Load in 1 thread, core. Only the time spent on execution was taken as a basis.
Thanks for replying. What do you mean here, sorry didn't get it.

Quote from: COBRAS
Thanks for replying too.
Agree, what wat is  GPU depends only from your hend and your brain. To who is thinking what he is too stupid for crack 135, look. Then I was try crack 120, I use a bsgs from iceland, and fu-k, I geberate and regenerate his bloom filters about 5 hours, but,I rent a pc at avast with 125 CPU, and I remember what I was need crack only about upper 0xfffffff from dip ! So, all in your brain and hands
Thanks for replying too. What do you mean here, sorry didn't get it too.

#67 All funds will be transferred to this BTC address:13gLHZJYcCJVSCoSuWbAFiYPU3X7kv47iH
Congratulations man!
Post
Topic
Board Bitcoin Discussion
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
by
tmar777
on 30/11/2024, 17:32:50 UTC
Guys, can we make a wrap-up based on recent puzzle-solving scripts versions and speed tests?

1. What script is ideal for low-bit puzzles? For how many bits is this ideal?
Use with GPU or CPU?
Most recent improved version? Is it publicly available? If not, who is using it?

2. What script is ideal for high-bit puzzles?
Use with GPU or CPU?
Most recent improved version? Is it publicly available? If not, who is using it?

Thanks guys :-)