[9845 s] nLT012 = 4818944; 18211.71 M/s
[+] Key ID: 13949
S = 00000000000005a2844f65e43e868b000e27f653d19722b3da630bb59a57e34d
Z = 80000000000002d14227b2b6a674ef3fdaca7c092b7a374f200d1e4abbe775e4
Found! nLockTime = 498af3fc

#define GPU_CLOCK_FREQUENCY      2.712e9.    // RTX 4090 boost mode

__maxnreg__(128)
__global__
void kernelMineS(
    limb_t * __restrict__ pgSH,    // one script hash / thread
) {
    const U32 basePos = blockIdx.x * BLOCK_SIZE * 2 + threadIdx.x;
    const U128 * pSH = (U128 *) pgSH + basePos;

    U32 scriptHash[8];      // output script hash (32 bytes)
    U32 md[8];              // SHA256 [0:128] state (32 bytes)
    U32 total = 0;

    // load script hash from gmem to registers; coalesced
    LOAD_SH(scriptHash, pSH, 0, BLOCK_SIZE);

    // hash the first 128 bytes (same result for all threads and all scriptHashes)
    // (the message data is fixed all the way up to byte 157 - start of scriptHash)
    prepare_hash_12(md);

    U64 start_time = clock64();

    // iterate for all possible 3 last bytes of the 3rd message chunk
    // these bytes are part of the nLockTime
    for (U32 nLT012 = 0; nLT012 < 1 << 24; nLT012++) {
        U32 md2[8];            // SHA256 [0:192] state

        if (nLT012 % 2048 == 0
           &nbsp;&amp;& blockIdx.x == 0 && threadIdx.x == 0
        ) {
            U64 now = clock64();
            float elapsed_sec = float(now - start_time) / GPU_CLOCK_FREQUENCY;
            float keys_per_sec = (nLT012// counter * 256ULL256 tries * gridDim.xnumBlocks * BLOCK_SIZE) / elapsed_sec;threadsPerBlock * 2 sigsPerCheck
            float keys_per_sec = (nLT012 * 256ULL * gridDim.x * BLOCK_SIZE * 2) / elapsed_sec;
            printf("[%.2f] nLT012 = %u, %.2f M/s\n",
               elapsed_sec,printf("[%.2f] nLT012 = %u, keys_per_sec %.2f M/ 1e6);s\n",
       }         elapsed_sec, nLT012, keys_per_sec / 1e6);
        }
        // hash the 3rd chunk, by reusing the SHA state of first 2 chunks
        // thishash the 3rd chunk contains, by reusing the scriptHashSHA state of our thread, so we basically justfirst 2 chunks
        // changethis chunk contains the 3 bytesscriptHash of the nLockTime and hash the new 64 bytes of dataour thread, so we basically just
       prepare_hash_3(md2, md, scriptHash, nLT012) ;// change the 3 bytes of the nLockTime and hash the new 64 bytes of data
        prepare_hash_3(md2, md, scriptHash, nLT012);
        // iterate through the 4th nLockTime byte
       for (U16 nLT3 = 0; nLT3 &ltnbsp; 256; nLT3++) {// iterate through the 4th nLockTime byte
           // this does a single SHA256 for the last 5 bytes (4th data chunkU16 nLT3 = 0; nLT3 < 256; nLT3++) {
            // by reusingthis does a single SHA256 for the SHA state of the first 192last 5 bytes hashed so far(4th data chunk)
            // Then, it hashesby reusing the final SHA to obtainstate of the Z valuefirst 192 bytes hashed so far
            // It then checks whether S = (Then, it hashes the final SHA to obtain the Z + R) + (Z + R) mod N is a solutionvalue
            // orIt then checks whether N - S = (Z + R) + (Z + R) mod N is a solution
            // Another speed upor whether N - S is that Z must start with either 0x00000000,a solution
            // 0xffffffffAnother speed up is that Z must start with either 0x00000000, or 0x7fffffff in order for S to ever be a solution0x80000000,
           if (check_s(md2 // 0xffffffff, nLT3)) {or 0x7fffffff in order for S to ever be a solution
               U32 nLockTime = nLT012 << 8 |if (check_s(md2, nLT3;)) {
               printf("Found! U32 nLockTime = %08x\n", nLockTime)nLT012 <;< 8 | nLT3;
               PTX_TRAP ;printf("Found! nLockTime = %08x\n", nLockTime);
           }     PTX_TRAP;
            }
        }
    }
}

[9845 s] nLT012 = 4818944; 18211.71 M/s
[+] Key ID: 13949
S = 00000000000005a2844f65e43e868b000e27f653d19722b3da630bb59a57e34d
Z = 80000000000002d14227b2b6a674ef3fdaca7c092b7a374f200d1e4abbe775e4
Found! nLockTime = 498af3fc

#define GPU_CLOCK_FREQUENCY     2.712e9.   // RTX 4090 boost mode

__maxnreg__(128)
__global__
void kernelMineS(
    limb_t * __restrict__ pgSH,    // one script hash / thread
) {
    const U32 basePos = blockIdx.x * BLOCK_SIZE * 2 + threadIdx.x;
    const U128 * pSH = (U128 *) pgSH + basePos;

    U32 scriptHash[8];      // output script hash (32 bytes)
    U32 md[8];              // SHA256 [0:128] state (32 bytes)
    U32 total = 0;

    // load script hash from gmem to registers; coalesced
    LOAD_SH(scriptHash, pSH, 0, BLOCK_SIZE);

    // hash the first 128 bytes (same result for all threads and all scriptHashes)
    // (the message data is fixed all the way up to byte 157 - start of scriptHash)
    prepare_hash_12(md);

    U64 start_time = clock64();

    // iterate for all possible 3 last bytes of the 3rd message chunk
    // these bytes are part of the nLockTime
    for (U32 nLT012 = 0; nLT012 < 1 << 24; nLT012++) {
        U32 md2[8];            // SHA256 [0:192] state

        if (nLT012 % 2048 == 0
            && blockIdx.x == 0 && threadIdx.x == 0
        ) {
            U64 now = clock64();
            float elapsed_sec = float(now - start_time) / GPU_CLOCK_FREQUENCY;
            float keys_per_sec = (nLT012 * 256ULL * gridDim.x * BLOCK_SIZE) / elapsed_sec;

            printf("[%.2f] nLT012 = %u, %.2f M/s\n",
                elapsed_sec, nLT012, keys_per_sec / 1e6);
        }

        // hash the 3rd chunk, by reusing the SHA state of first 2 chunks
        // this chunk contains the scriptHash of our thread, so we basically just
        // change the 3 bytes of the nLockTime and hash the new 64 bytes of data
        prepare_hash_3(md2, md, scriptHash, nLT012);

        // iterate through the 4th nLockTime byte
        for (U16 nLT3 = 0; nLT3 < 256; nLT3++) {
            // this does a single SHA256 for the last 5 bytes (4th data chunk)
            // by reusing the SHA state of the first 192 bytes hashed so far
            // Then, it hashes the final SHA to obtain the Z value
            // It then checks whether S = (Z + R) + (Z + R) mod N is a solution
            // or whether N - S is a solution
            // Another speed up is that Z must start with either 0x00000000,
            // 0xffffffff, or 0x7fffffff in order for S to ever be a solution
            if (check_s(md2, nLT3)) {
                U32 nLockTime = nLT012 << 8 | nLT3;
                printf("Found! nLockTime = %08x\n", nLockTime);
                PTX_TRAP;
            }
        }
    }
}