Solving ECDLP with Kangaroos: Part 1 + 2 + RCKangaroo

[AntonioNemcd]

That’s interesting, but I’d like to get an expert opinion on whether it’s worth creating checkpoints and continuing the search in this format, as I haven't found a pool with a different approach.

[RetiredCoder]

I named my app RCKangaroo because it's fun! I don't care that its algo is not original Pollard's kangaroo algo.
Sorry, I removed your crazy discussion, please use that useless almost-1000-pages thread for such endless talks

That’s interesting, but I’d like to get an expert opinion on whether it’s worth creating checkpoints and continuing the search in this format, as I haven't found a pool with a different approach.

I didn't check it so I have no idea.

[citramonb]

Hi, I'm using your improved Kangaroo Palard: https://github.com/RetiredC/RCKangaroo/blob/main/Ec.cpp - method via depseek.
I lost 13 characters of my private key - WIF.
I did this: to find the hex/range, I set my unknown 13 characters to the highest character base 58 - 1, and the lowest character z, created a script through the gpt chat and got the hex/range (I don’t know did I do it right or not...) - After that, I took your improved method of kangaroo palard, rented 2 servers with 6+8 RTX 4090 cards and launched it on 14 video cards at once, but before that, I again created a script through deepseek which divided my hex/range into two servers with 6-8 video cards.
But I ran into a problem:
1. I don’t know if I did everything correctly and if I’m wasting time and money renting video cards in vain?
2. Is it correct that I took the largest and smallest symbol of base 58 and inserted them into my lost 13 symbols of private key to convert to hex - to understand the range and run kangaroo?
3. The problem is that my buffer fills up quickly. I set it to 22 dp to have fewer saves, but even then there's not enough space... But at the time of writing the comment, I have 28 dp on 6 and 8 video cards:
6 card: MAIN: Speed: 45985 MKeys/s, Err: 0, DPs: 356K/0K, Time: 0d:00h:32m/0d:00h:00m
8 card: MAIN: Speed: 57411 MKeys/s, Err: 0, DPs: 286K/0K, Time: 0d:00h:31m/0d:00h:00m

I was losing all hope, I was depressed until I read about you, that you were able to find the key to 3 puzzles in 2-3 months, using your improved version of RetiredC...
I got inspired by this today and started looking for a key, but I don't understand anything about programming, I do everything using chat gpt...

I would be incredibly grateful and happy if you could just answer and point me in the right direction: tell me whether I am doing everything right or not?
I'm not asking you to help me find the key, I just need help, so that you can point out my mistakes so that I can correct them...
I'd definitely thank you even if you refuse to help me, because I'm searching with your improved version of the Palard kangaroo! Thanks, man, you're a genius!

P.S.: I attached a screenshot of how the program works.
P.S.S, I forgot, my hex also starts at 21cc and not 000
P.S.S.S I showed how my cards work in the screenshot.

https://ibb.co/cSDbRj0H
https://ibb.co/60Dxw9sH
https://ibb.co/xSd4pwQy

[kTimesG]

I lost 13 characters of my private key - WIF.
I did this: to find the hex/range, I set my unknown 13 characters to the highest character base 58 - 1, and the lowest character z, created a script through the gpt chat and got the hex/range (I don’t know did I do it right or not...)

If all the missing 13 chars were actually at the end of the encoded priv key then it sounds ok, otherwise the range needs correction after some modular shifts, which likely increases the range a little to compensate for base58 irregularities. For 13 chars though, if you really know the correct public key and range, you don't need so much compute power, it's solvable in seconds.

[citramonb]

I lost 13 characters of my private key - WIF.
I did this: to find the hex/range, I set my unknown 13 characters to the highest character base 58 - 1, and the lowest character z, created a script through the gpt chat and got the hex/range (I don’t know did I do it right or not...)

If all the missing 13 chars were actually at the end of the encoded priv key then it sounds ok, otherwise the range needs correction after some modular shifts, which likely increases the range a little to compensate for base58 irregularities. For 13 chars though, if you really know the correct public key and range, you don't need so much compute power, it's solvable in seconds.

Here is an example of a key that I have, unknown characters are in a row...

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxxxxxxxxxxxxxAAAAA
A - known
x - unknown

P.S: Compressed private key: K
Compressed address: 1D
Public private key: 03
----------------------------------------------------

P.S.S: I used this script to get the key in hex:

import base58
import math

def wif_to_hex_range(wif_pattern):
    # Replace '?' with '1' (min) and 'z' (max)
    min_wif = wif_pattern.replace('?', '1')
    max_wif = wif_pattern.replace('?', 'z')

    def decode_wif_raw(wif):
        data = base58.b58decode(wif)
        data = data[:-4]  # remove checksum
        data = data[1:]    # remove version byte
        if len(data) == 33:
            data = data[:-1]  # remove the compression flag for compressed keys
        return data

    min_key = decode_wif_raw(min_wif)
    max_key = decode_wif_raw(max_wif)

    min_hex = min_key.hex()
    max_hex = max_key.hex()
    min_int = int.from_bytes(min_key, 'big')
    max_int = int.from_bytes(max_key, 'big')
    diff = max_int - min_int

    print(f"MIN HEX: {min_hex}")
    print(f"MAX HEX: {max_hex}")
    print(f"DIFF: ~ 2^{math.log2(diff):.2f}")
    return min_hex, max_hex

# Example
wif = "KytszeJyhc9dypinFjp7TVmKsxWKweizRq????ZQppG"
wif_to_hex_range(wif)
----------------------------------------------------
[Original Hex]
4fd32b78e040007e7ae0cac8b676133ad5ff0ddecd9ce13b6709057e1f60a7f9
 
[What I got using the script above]
MIN HEX: 4fd32b78e040007e7ae0cac8b676133ad5ff0ddecd9ce13a7f359e77ede4e4b1
MAX HEX: 4fd32b78e040007e7ae0cac8b676133ad5ff0ddecd9ce13d378ddf740b4f2cbc
----------------------------------------------------
[KytszeJyhc9dypinFjp7TVmKsxWKweizRq????ZQppG - test key]
----------------------------------------------------
The way I launched RCKangaroo👉: https://ibb.co/7NQS8r7F
----------------------------------------------------
P.S.S: Memory fills up very quickly when you set low dp (14) 👉: https://ibb.co/n8CGPYH2

[Cricktor]

@citramonb
You may consider to look at the following topic where someone lost the last 18 characters of his WIF key:
https://bitcointalk.org/index.php?topic=5580016.0

It looks of similar search range complexity to me, because the last five characters of a WIF key are checksum which isn't missing in your case.

Here's a quote of an experiment with 18 missing last characters from above thread, solved with a CPU in 04m28s. That wasn't with RCKangaroo but with JLP Kangaroo. I would assume both should find a solution.

The gear you're throwing at the problem seems way too much firepower. If your LLM vibe coding did mess up, no amount of number crunching power will help you.

now i have two long hex chars , i checked in what bit range those two hexare like where the value changes and its 80 bits.
so could i just input the small right part of the first hex and use it as start range no?

That should work,
I even reproduced that using a sample WIF with omitted 18characters and my CPU finished it with 55mKeys/s in just 4min 28 sec.

Partial private key: KxnFYf7tBNgaLd4GChPktcLUSceMp37M7t
Decode to hex with min/max padding:

KxnFYf7tBNgaLd4GChPktcLUSceMp37M7t111111111111111111
802e93dc28477c67aa3810d11e657792d33f61fbf26228c59fe19d1bb9c424f69294591c0000
KxnFYf7tBNgaLd4GChPktcLUSceMp37M7tzzzzzzzzzzzzzzzzzz
802e93dc28477c67aa3810d11e657792d33f61fbf26228c5a299f55cb5e18f3e9d7c533fffff

Kangaroo inFile:

Code:

2e93dc28477c67aa3810d11e657792d33f61fbf26228c59fe19d1bb9c424f692
2e93dc28477c67aa3810d11e657792d33f61fbf26228c5a299f55cb5e18f3e9d
02fa7119cc8e246466ec38a9cd8e3e96e61746594452bc95bfb6511af46b6cb86d

Here's the terminal log:

Code:

kangaroo -o kangaroo-34char_test-result.txt kangaroo-34char_test.txt
Kangaroo v2.2
Start:2E93DC28477C67AA3810D11E657792D33F61FBF26228C59FE19D1BB9C424F692
Stop :2E93DC28477C67AA3810D11E657792D33F61FBF26228C5A299F55CB5E18F3E9D
Keys :1
Number of CPU thread: 12
Range width: 2^66
Jump Avg distance: 2^32.97
Number of kangaroos: 2^13.58
Suggested DP: 16
Expected operations: 2^34.10
Expected RAM: 22.7MB
DP size: 16 [0xFFFF000000000000]
SolveKeyCPU Thread 11: 1024 kangaroos
SolveKeyCPU Thread 0: 1024 kangaroos
SolveKeyCPU Thread 4: 1024 kangaroos
SolveKeyCPU Thread 6: 1024 kangaroos
SolveKeyCPU Thread 7: 1024 kangaroos
SolveKeyCPU Thread 5: 1024 kangaroos
SolveKeyCPU Thread 2: 1024 kangaroos
SolveKeyCPU Thread 9: 1024 kangaroos
SolveKeyCPU Thread 10: 1024 kangaroos
SolveKeyCPU Thread 8: 1024 kangaroos
SolveKeyCPU Thread 3: 1024 kangaroos
SolveKeyCPU Thread 1: 1024 kangaroos
[55.54 MK/s][GPU 0.00 MK/s][Count 2^33.60][Dead 1][04:27 (Avg 05:30)][8.0/27.1MB]
Done: Total time 04:28

Just to make sure, are those long hex characters 32Bytes long (64 characters)?
If so, you're in the right track.

I would always do a test recovery case where the solution is known. If your toolchain can't solve the test case, it likely won't solve your real recovery case.

[citramonb]

I'm confused bro, I'm completely new here, I came here because I was in a desperate situation...

Look bro, I have a hex of 64 characters, from - [0-9 - a,b,c,d,e,f] - I got them using a python script that was written through the gpt chat, I took my key with the missing characters and replaced them with the largest number and also for the smallest one - [1-z], And I got this conversion to hex:
 
 python3 2script.py
=== INPUT ===
MIN WIF: KytszeJyhc9dypinFjp7TVmKsxWKweizRq1111111111111ZQppG
MAX WIF: KytszeJyhc9dypinFjp7TVmKsxWKweizRqzzzzzzzzzzzzzZQppG
=== HEX RANGE ===
MIN HEX: 4fd32b78e040007e7ae0cac8b676133ad5ff0ddecd9ce13a7f359e77ede4e4b1
MAX HEX: 4fd32b78e040007e7ae0cac8b676133ad5ff0ddecd9ce13d378ddf740b4f2cbc
=== INT RANGE ===
MIN: 36105819802649078027956049361812326277499756755464119873764253351252100179121
MAX: 36105819802649078027956049361812326277499756755464119873814430277952018001084
DIFF: 50176926699917821963
~ 2^65.44

I take the resulting hex and insert it into the command for the RCkangaroo:

tmux new -s kangaroo_10x3090
cd /root/RCKangaroo
./rckangaroo -gpu 0123456789 -dp 22 -range 66 -start 4fd32b78e040007e7ae0cac8b676133ad5ff0ddecd9ce13a7f359e77ede4e4b1 -pubkey 036105819802649078027956049361812326277499756755464119873780958159971245139961

[This is an example of my command, a hex from a known private key, but the public key is not public, I wrote any numbers so that the command would be a whole]

Could you please tell me what exactly I'm doing wrong? Could you please reply with an example of how to take a hex, and what it should be like if I'm taking it incorrectly?


Or you can test the Python script that I use:

import base58
import math

def wif_to_hex_range(wif_pattern):
    # гpaницы
    min_wif = wif_pattern.replace('?', '1')
    max_wif = wif_pattern.replace('?', 'z')

    def decode_wif_raw(wif):
        data = base58.b58decode(wif)

        data = data[:-4]  # yбpaть checksum
        data = data[1:]   # yбpaть вepcию

        if len(data) == 33:
            data = data[:-1]

        return data

    min_key = decode_wif_raw(min_wif)
    max_key = decode_wif_raw(max_wif)

    min_hex = min_key.hex()
    max_hex = max_key.hex()

    min_int = int.from_bytes(min_key, 'big')
    max_int = int.from_bytes(max_key, 'big')

    diff = max_int - min_int

    print("=== INPUT ===")
    print("MIN WIF:", min_wif)
    print("MAX WIF:", max_wif)

    print("\n=== HEX RANGE ===")
    print("MIN HEX:", min_hex)
    print("MAX HEX:", max_hex)

    print("\n=== INT RANGE ===")
    print("MIN:", min_int)
    print("MAX:", max_int)
    print("DIFF:", diff)

    if diff > 0:
        print("~ 2^%.2f" % math.log2(diff))


# TBOЙ HOBЫЙ КЛЮЧ
wif = "KytszeJyhc9dypinFjp7TVmKsxWKweizRq????ZQppG"

wif_to_hex_range(wif)


-----
P.S.: I'm currently running a test on 13-15 unknown characters, but on a known key, to see if I'm running everything correctly - following the very good advice above.

P.S.S.: I encountered a problem where when I run the program on 8 4090 cards at once, it freezes. However, before that, I ran it on one RTX 4090 card and it started and worked perfectly at a speed of 2600mKey - https://ibb.co/Rk2Grqxs (I'm doing a test with 130 puzzles)

P.S.S.S: After some time, the program finally started working and after 6 minutes stopped its search, but nothing was found - even on the test key from 130 puzzle - https://ibb.co/FLrkwB5z
Maybe I'm doing something wrong or my command is incorrect using chat gpt?:

cat > /root/Kangaroo/test_big.txt << 'EOF'
000000000000000000000000000000033e7665705359ec8ef00d0fb13d25f255
000000000000000000000000000000033e766570535ffffffffffffffffffff
03633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852
EOF


And then I run this command:
cd /root/Kangaroo && ./kangaroo -gpu -gpuId 0,1,2,3,4,5,6,7 -t 8 -d 16 -o result_big.txt test_big.txt

https://ibb.co/sJMbYgbT 👆🦘

[Cricktor]

...

Because I can't run RCKangaroo in my virtual machine where I can't easily give it a Nvidia GPU, I ran an example of 17 missing trailing WIF characters (18 would've been a bit too much for my VM as it only uses two (our of four) measly cores of a slightly vintage laptop).

As I don't want to derail RetiredCoder's thread here, come over to this thread where I will show you all details of successfully finding an example private key. No ChatGPT vibe coding necessary, all tools required are available online (not ideal for your real recovery case where I would recommend to run everything in a disposable offline machine to avoid potential leakage of your private key material).

[EccMath]

v2.0 (Windows/Linux):
https://github.com/RetiredC/RCKangaroo

- added support for 30xx, 20xx and 1xxx cards.
- some minor changes.

Speed:
4090 - 7.9GKeys/s.
3090 - 4.1GKeys/s.
2080Ti - 2.9GKeys/s.

Please report speed for other cards, for old cards speedup is up to 40%.

Does anyone have performance numbers for the 50xx series cards? I’m interested in the 5060, 5060 Ti, 5070… Didn’t find anything in the thread. What would you recommend for example, 2080 Ti vs 5060? The 5060 has a much larger L2 cache, I’m planning to upgrade my GPU.

[olnev]

Does anyone have performance numbers for the 50xx series cards? I’m interested in the 5060, 5060 Ti, 5070… Didn’t find anything in the thread. What would you recommend for example, 2080 Ti vs 5060? The 5060 has a much larger L2 cache, I’m planning to upgrade my GPU.

8xV100 19000 MKeys/s
4x4060 6530 MKeys/s
1x5060 - 1900 MKeys/s
1x5060Ti - 2263 MKeys/s
1x5080 - 5269 MKeys/s

You can rent any GPU for 10-15 minutes to make benchmarks.

[SecretAdmirere]

Hello RetiredCoder, i just wanted to express my gratitude towards your contribution in all of this. I recently saw your SASS implementation of MulMod256, and it led me towards rewriting my own which turned out better than i imagined it would, still it's nothing compared to your custom version written in sass (or from others like kTimesG), but i'm happy with it for now (it is fast and it is computing correct results). So in a way, i wouldn't do it if it weren't for you, or at very least i wouldn't do it now, so for that i wanna say to you a BIG THANK YOU!

I'm new to this scene, CUDA programming, PTX, C++, elliptic curves, SHA256, RIPEMD160, registers, occupancy, etc.. So there is still a lot to do, learn and improve, but every day there is a new milestone for me. Sometimes one step forward - two steps back, sometimes vice versa (eg. had an issue in the reduction, was correct 98% of the times, didn't notice it because i was lazy to test it properly, turns out it was wrong, was slightly faster but computed wrong results so yeah)..

I didn't bother benchmarking just the ModMult, since i have RTX 3070 Ti and currently i have other things that need financial focus rather than spending money on renting GPUs just for benchmarking it on 4090/5090/PRO 6000. But here are some numbers taken from my address hashing kernel (Mkeys/s is referring to hash160 checks against hash160 target) and i just replaced ModMult for benchmarking and everything else was the same for all four:

Code:

===============================================================================

https://github.com/FixedPaul/VanitySearch-Bitcrack/blob/master/GPU/GPUMath.h

_ModMult

2020 Mkeys/s - Let's call it a baseline

===============================================================================

https://github.com/RetiredC/RCKangaroo/blob/main/RCGpuUtils.h

MulModP

2020 Mkeys/s - Let's call it a baseline

===============================================================================

My old before rewrite

ModMult

2080 Mkeys/s - increase by ~3% over a baseline

===============================================================================

My new after rewrite

ModMult

2200 Mkeys/s - increase by ~9% over a baseline

===============================================================================

It is written completely in C++ and PTX, i don't think it's worth spending the mental cycles to do something beyond C++ and PTX for a RTX 30-series GPUs, maybe one day when i'm able to afford 4090 or 5090 i would spend more time doing it, but for the time being it will stay as C++ and PTX. This is the sass of the ModMult, taken out directly from the compiled kernel, as is, i hope i didn't miss something (don't wanna share the code as C++ and PTX, i'm sharing it as sass since those who can reverse it back to C++ and PTX probably know a lot more to just write it for themselves a better version, and those "eating magic mushrooms" people from 660 pages thread can't get their hands on it for now):

Code:

RC SASS implementation of MulMod256:
47 - IMAD.WIDE.U32.X
27 - IMAD.WIDE.U32
37 - IADD3.X
1 - IADD3
Total: 112 instructions

My new after rewrite ModMult:
68 - IMAD.WIDE.U32
50 - IADD3.X
28 - IMAD.MOV.U32
8 - IMAD.X
7 - IMAD.WIDE.U32.X
4 - IADD3
1 - IMAD.HI.U32
1 - IMAD
1 - SEL
Total: 168 instructions

Line 471 /*0800*/ IMAD.WIDE.U32 R4, R56, R64, RZ ;

Line 475 /*07d0*/ IMAD.MOV.U32 R7, RZ, RZ, RZ ;
         /*0820*/ IMAD.MOV.U32 R6, RZ, RZ, R5 ;
         /*0840*/ IMAD.WIDE.U32 R6, P2, R56, R65, R6 ;
Line 476 /*0860*/ IMAD.WIDE.U32 R6, P3, R57, R64, R6 ;
         /*0890*/ IADD3.X R11, RZ, RZ, RZ, P3, P2 ;

Line 480 /*0880*/ IMAD.MOV.U32 R10, RZ, RZ, R7 ;
         /*08c0*/ IMAD.WIDE.U32 R10, P2, R56, R61, R10 ;
Line 481 /*08e0*/ IMAD.WIDE.U32 R10, P3, R57, R65, R10 ;
         /*08f0*/ IADD3.X R12, RZ, RZ, RZ, P3, P2 ;
Line 482 /*0900*/ IMAD.WIDE.U32 R10, P4, R54, R64, R10 ;
         /*0910*/ IMAD.X R13, RZ, RZ, R12, P4 ;

Line 486 /*0920*/ IMAD.MOV.U32 R12, RZ, RZ, R11 ;
         /*0930*/ IMAD.WIDE.U32 R12, P2, R56, R62, R12 ;
Line 487 /*0940*/ IMAD.WIDE.U32 R12, P3, R57, R61, R12 ;
         /*0950*/ IADD3.X R14, RZ, RZ, RZ, P3, P2 ;
Line 488 /*0960*/ IMAD.WIDE.U32 R12, P4, R54, R65, R12 ;
Line 489 /*0970*/ IMAD.WIDE.U32 R12, P5, R55, R64, R12 ;
         /*0980*/ IADD3.X R15, RZ, RZ, R14, P5, P4 ;

Line 493 /*0990*/ IMAD.MOV.U32 R14, RZ, RZ, R13 ;
         /*09a0*/ IMAD.WIDE.U32 R14, P4, R56, R60, R14 ;
Line 494 /*09b0*/ IMAD.WIDE.U32 R14, P5, R57, R62, R14 ;
         /*09c0*/ IADD3.X R66, RZ, RZ, RZ, P5, P4 ;
Line 495 /*09d0*/ IMAD.WIDE.U32 R14, P3, R54, R61, R14 ;
Line 496 /*09e0*/ IMAD.WIDE.U32 R14, P2, R55, R65, R14 ;
         /*09f0*/ IADD3.X R66, RZ, RZ, R66, P2, P3 ;
Line 497 /*0a00*/ IMAD.WIDE.U32 R14, P4, R18, R64, R14 ;
         /*0a10*/ IMAD.X R67, RZ, RZ, R66, P4 ;

Line 501 /*0a20*/ IMAD.MOV.U32 R66, RZ, RZ, R15 ;
         /*0a30*/ IMAD.WIDE.U32 R66, P4, R56, R59, R66 ;
Line 502 /*0a40*/ IMAD.WIDE.U32 R66, P5, R57, R60, R66 ;
         /*0a50*/ IADD3.X R68, RZ, RZ, RZ, P5, P4 ;
Line 503 /*0a60*/ IMAD.WIDE.U32 R66, P2, R54, R62, R66 ;
Line 504 /*0a70*/ IMAD.WIDE.U32 R66, P3, R55, R61, R66 ;
         /*0a80*/ IADD3.X R68, RZ, RZ, R68, P3, P2 ;
Line 505 /*0a90*/ IMAD.WIDE.U32 R66, P4, R18, R65, R66 ;
Line 506 /*0aa0*/ IMAD.WIDE.U32 R66, P5, R17, R64, R66 ;
         /*0ab0*/ IADD3.X R69, RZ, RZ, R68, P5, P4 ;

Line 510 /*0ac0*/ IMAD.MOV.U32 R68, RZ, RZ, R67 ;
         /*0ad0*/ IMAD.WIDE.U32 R68, P4, R56, R58, R68 ;
Line 511 /*0ae0*/ IMAD.WIDE.U32 R68, P5, R57, R59, R68 ;
         /*0af0*/ IADD3.X R74, RZ, RZ, RZ, P5, P4 ;
Line 512 /*0b00*/ IMAD.WIDE.U32 R68, P2, R54, R60, R68 ;
Line 513 /*0b10*/ IMAD.WIDE.U32 R68, P3, R55, R62, R68 ;
         /*0b20*/ IADD3.X R74, RZ, RZ, R74, P3, P2 ;
Line 514 /*0b30*/ IMAD.WIDE.U32 R68, P5, R18, R61, R68 ;
Line 515 /*0b40*/ IMAD.WIDE.U32 R68, P4, R17, R65, R68 ;
         /*0b50*/ IADD3.X R74, RZ, RZ, R74, P4, P5 ;
Line 516 /*0b60*/ IMAD.WIDE.U32 R68, P2, R16, R64, R68 ;
         /*0b70*/ IMAD.X R75, RZ, RZ, R74, P2 ;

Line 520 /*0b80*/ IMAD.MOV.U32 R74, RZ, RZ, R69 ;
         /*0b90*/ IMAD.WIDE.U32 R74, P4, R56, R63, R74 ;
Line 521 /*0ba0*/ IMAD.WIDE.U32 R74, P5, R57, R58, R74 ;
         /*0bb0*/ IADD3.X R76, RZ, RZ, RZ, P5, P4 ;
Line 522 /*0bc0*/ IMAD.WIDE.U32 R74, P3, R54, R59, R74 ;
Line 523 /*0bd0*/ IMAD.WIDE.U32 R74, P2, R55, R60, R74 ;
         /*0be0*/ IADD3.X R76, RZ, RZ, R76, P2, P3 ;
Line 524 /*0bf0*/ IMAD.WIDE.U32 R74, P0, R18, R62, R74 ;
Line 525 /*0c00*/ IMAD.WIDE.U32 R74, P1, R17, R61, R74 ;
         /*0c10*/ IADD3.X R76, RZ, RZ, R76, P1, P0 ;
Line 526 /*0c20*/ IMAD.WIDE.U32 R74, P4, R16, R65, R74 ;
Line 527 /*0c30*/ IMAD.WIDE.U32 R74, P2, R53, R64, R74 ;
         /*0c40*/ IADD3.X R77, RZ, RZ, R76, P2, P4 ;

Line 531 /*0c50*/ IMAD.MOV.U32 R76, RZ, RZ, R75 ;
         /*0c60*/ IMAD.WIDE.U32 R56, P1, R57, R63, R76 ;
Line 532 /*0c70*/ IMAD.WIDE.U32 R56, P2, R54, R58, R56 ;
         /*0c80*/ IADD3.X R64, RZ, RZ, RZ, P2, P1 ;
Line 533 /*0c90*/ IMAD.WIDE.U32 R56, P3, R55, R59, R56 ;
Line 534 /*0ca0*/ IMAD.WIDE.U32 R56, P4, R18, R60, R56 ;
         /*0cb0*/ IADD3.X R64, RZ, RZ, R64, P4, P3 ;
Line 535 /*0cc0*/ IMAD.WIDE.U32 R56, P0, R17, R62, R56 ;
Line 536 /*0cd0*/ IMAD.WIDE.U32 R56, P1, R16, R61, R56 ;
         /*0ce0*/ IADD3.X R64, RZ, RZ, R64, P1, P0 ;
Line 537 /*0cf0*/ IMAD.WIDE.U32 R56, P2, R53, R65, R56 ;
         /*0d00*/ IMAD.X R65, RZ, RZ, R64, P2 ;

Line 541 /*0d10*/ IMAD.MOV.U32 R64, RZ, RZ, R57 ;
         /*0d30*/ IMAD.WIDE.U32 R64, P0, R54, R63, R64 ;
Line 542 /*0d40*/ IMAD.WIDE.U32 R64, P1, R55, R58, R64 ;
         /*0d50*/ IADD3.X R76, RZ, RZ, RZ, P1, P0 ;
Line 543 /*0d60*/ IMAD.WIDE.U32 R64, P2, R18, R59, R64 ;
Line 544 /*0d70*/ IMAD.WIDE.U32 R64, P3, R17, R60, R64 ;
         /*0d80*/ IADD3.X R76, RZ, RZ, R76, P3, P2 ;
Line 545 /*0d90*/ IMAD.WIDE.U32 R64, P4, R16, R62, R64 ;
Line 546 /*0da0*/ IMAD.WIDE.U32 R64, P0, R53, R61, R64 ;
         /*0db0*/ IADD3.X R77, RZ, RZ, R76, P0, P4 ;

Line 550 /*0dc0*/ IMAD.MOV.U32 R76, RZ, RZ, R65 ;
         /*0dd0*/ IMAD.WIDE.U32 R54, P0, R55, R63, R76 ;
Line 551 /*0de0*/ IMAD.WIDE.U32 R54, P1, R18, R58, R54 ;
         /*0df0*/ IADD3.X R76, RZ, RZ, RZ, P1, P0 ;
Line 552 /*0e00*/ IMAD.WIDE.U32 R54, P2, R17, R59, R54 ;
Line 553 /*0e10*/ IMAD.WIDE.U32 R54, P3, R16, R60, R54 ;
         /*0e20*/ IADD3.X R76, RZ, RZ, R76, P3, P2 ;
Line 554 /*0e30*/ IMAD.WIDE.U32 R54, P0, R53, R62, R54 ;
         /*0e40*/ IMAD.X R77, RZ, RZ, R76, P0 ;

Line 558 /*0e50*/ IMAD.MOV.U32 R76, RZ, RZ, R55 ;
         /*0e60*/ IMAD.WIDE.U32 R76, P0, R18, R63, R76 ;
Line 559 /*0e70*/ IMAD.WIDE.U32 R76, P1, R17, R58, R76 ;
         /*0ea0*/ IADD3.X R76, RZ, RZ, RZ, P1, P0 ;
Line 560 /*0e80*/ IMAD.WIDE.U32 R76, P2, R16, R59, R76 ;
Line 561 /*0e90*/ IMAD.WIDE.U32 R60, P3, R53, R60, R76 ;
         /*0ed0*/ IADD3.X R77, RZ, RZ, R76, P3, P2 ;

Line 565 /*0ef0*/ IMAD.MOV.U32 R76, RZ, RZ, R61 ;
         /*0f10*/ IMAD.WIDE.U32 R76, P1, R17, R63, R76 ;
Line 566 /*0f20*/ IMAD.WIDE.U32 R76, P2, R16, R58, R76 ;
         /*0f30*/ IADD3.X R11, RZ, RZ, RZ, P2, P1 ;
Line 567 /*0f40*/ IMAD.WIDE.U32 R76, P3, R53, R59, R76 ;
         /*0f60*/ IMAD.X R11, RZ, RZ, R11, P3 ;

Line 571 /*0f70*/ IMAD.MOV.U32 R10, RZ, RZ, R77 ;
         /*0f90*/ IMAD.WIDE.U32 R16, P3, R16, R63, R10 ;
Line 572 /*1030*/ IMAD.WIDE.U32 R16, P4, R53, R58, R16 ;
         /*1050*/ IADD3.X R13, RZ, RZ, RZ, P4, P3 ;

Line 577 /*10a0*/ IMAD.MOV.U32 R12, RZ, RZ, R17 ;
         /*10c0*/ IMAD.WIDE.U32 R6, R53, R63, R12 ;

Line 585 /*0eb0*/ IADD3 R5, P0, R6, R56, RZ ;
Line 586 /*0ee0*/ IADD3.X R13, P0, R10, R64, RZ, P0, !PT ;
Line 587 /*0f00*/ IADD3.X R15, P0, R12, R54, RZ, P0, !PT ;
Line 588 /*0fb0*/ IADD3.X R5, P0, R14, R60, RZ, P0, !PT ;
Line 589 /*0fe0*/ IADD3.X R67, P0, R66, R76, RZ, P0, !PT ;
Line 590 /*1060*/ IADD3.X R69, P0, R68, R16, RZ, P0, !PT ;
Line 591 /*10f0*/ IADD3.X R75, P0, R74, R6, RZ, P0, !PT ;
Line 592 /*1140*/ IADD3.X R13, P0, RZ, R7, RZ, P0, !PT ;
Line 593 /*1170*/ SEL R5, RZ, 0x1, !P0 ;

Line 597 /*0ec0*/ IMAD.HI.U32 R6, R56, 0x3d1, RZ ;
Line 598 /*08a0*/ IMAD.MOV.U32 R7, RZ, RZ, RZ ;
         /*0f80*/ IMAD.WIDE.U32 R6, P1, R64, 0x3d1, R6 ;
Line 600 /*0fc0*/ IMAD.MOV.U32 R10, RZ, RZ, R7 ;
         /*0fd0*/ IMAD.MOV.U32 R11, RZ, RZ, RZ ;
         /*1000*/ IMAD.WIDE.U32.X R10, P1, R54, 0x3d1, R10, P1 ;
Line 602 /*0ff0*/ IMAD.MOV.U32 R7, RZ, RZ, RZ ;
         /*1010*/ IMAD.MOV.U32 R6, RZ, RZ, R11 ;
         /*1040*/ IMAD.WIDE.U32.X R6, P1, R60, 0x3d1, R6, P1 ;
Line 604 /*1070*/ IMAD.MOV.U32 R10, RZ, RZ, R7 ;
         /*1090*/ IMAD.MOV.U32 R11, RZ, RZ, RZ ;
         /*10b0*/ IMAD.WIDE.U32.X R10, P1, R76, 0x3d1, R10, P1 ;
Line 606 /*10e0*/ IMAD.MOV.U32 R12, RZ, RZ, R11 ;
         /*1100*/ IMAD.MOV.U32 R13, RZ, RZ, RZ ;
         /*1120*/ IMAD.WIDE.U32.X R12, P1, R16, 0x3d1, R12, P1 ;
Line 608 /*1110*/ IMAD.MOV.U32 R11, RZ, RZ, RZ ;
         /*1130*/ IMAD.MOV.U32 R10, RZ, RZ, R13 ;
         /*1160*/ IMAD.WIDE.U32.X R10, P1, R6, 0x3d1, R10, P1 ;
Line 610 /*1180*/ IMAD.MOV.U32 R12, RZ, RZ, R11 ;
         /*11a0*/ IMAD.WIDE.U32.X R6, P1, R7, 0x3d1, R12, P1 ;

Line 615 /*0d20*/ IMAD R57, R56, 0x3d1, RZ ;
         /*0f50*/ IADD3 R4, P2, R57, R4, RZ ;
Line 616 /*0fa0*/ IADD3.X R18, P2, R5, R6, RZ, P2, !PT ;
Line 617 /*1020*/ IADD3.X R55, P2, R13, R10, RZ, P2, !PT ;
Line 618 /*1080*/ IADD3.X R15, P2, R15, R6, RZ, P2, !PT ;
Line 619 /*10d0*/ IADD3.X R14, P2, R5, R10, RZ, P2, !PT ;
Line 620 /*1150*/ IADD3.X R67, P2, R67, R12, RZ, P2, !PT ;
Line 621 /*1190*/ IADD3.X R69, P2, R69, R10, RZ, P2, !PT ;
Line 622 /*11b0*/ IADD3.X R75, P2, R75, R6, RZ, P2, !PT ;
Line 623 /*11c0*/ IADD3.X R57, P2, RZ, R7, RZ, P2, !PT ;
Line 624 /*11d0*/ IADD3.X R11, RZ, RZ, R5, P2, P1 ;

Line 632 /*11e0*/ IMAD.WIDE.U32 R6, R11, 0x3d1, RZ ;
         /*11f0*/ IMAD.WIDE.U32 R6, P0, R57, 0x1, R6 ;
         /*1200*/ IMAD.WIDE.U32 R56, R57, 0x3d1, RZ ;
         /*1220*/ IADD3 R57, P1, R57, R6, RZ ;
         /*1230*/ IADD3 R56, P0, R4, R56, RZ ;
         /*1250*/ IADD3.X R57, P0, R18, R57, RZ, P0, !PT ;
Line 633 /*1210*/ IMAD.X R5, RZ, RZ, RZ, P0 ;
         /*1240*/ IMAD.MOV.U32 R4, RZ, RZ, R7 ;
         /*1260*/ IMAD.WIDE.U32.X R4, R11, 0x1, R4, P1 ;
         /*1280*/ IADD3.X R54, P0, R55, R4, RZ, P0, !PT ;
         /*1290*/ IADD3.X R55, P0, R15, R5, RZ, P0, !PT ;
Line 634 /*12b0*/ IADD3.X R18, P0, RZ, R14, RZ, P0, !PT ;
         /*12d0*/ IADD3.X R17, P0, RZ, R67, RZ, P0, !PT ;
Line 635 /*1300*/ IADD3.X R16, P0, RZ, R69, RZ, P0, !PT ;
         /*1320*/ IMAD.X R53, RZ, RZ, R75, P0 ;