❯ ./Cyclone -a 1FRoHA9xewq7DjrZ1psWJVeTer8gHRqEvR -r 1:ffffffff -p 3

================= WORK IN PROGRESS =================
Target Address: 1FRoHA9xewq7DjrZ1psWJVeTer8gHRqEvR
Prefix length : 3 bytes
CPU Threads   : 16
Mkeys/s       : 37.71
Total Checked : 1885316608
Elapsed Time  : 00:00:50
Range         : 1:ffffffff
Progress      : 43.8959 %
Progress Save : 0
================== PARTIAL MATCH FOUND! ============
Prefix length : 3 bytes
Private Key   : 0000000000000000000000000000000000000000000000000000000018573147
Public Key    : 02E1C602DEB1BCF47A66166D2397112FD44B85457C2BBA47BADEE3AA56A64A356E
WIF           : KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M8ADiUeziYmcmg
Found Hash160 : 9e426069a651b8c2d9a44cf42b23da4b2ef9cb5c
Target Hash160: 9e42601eeaedc244e15f17375adb0e2cd08efdc9
Matched bytes : 9e4260
================== FOUND MATCH! ====================
Private Key   : 00000000000000000000000000000000000000000000000000000000B862A62E
Public Key    : 0209C58240E50E3BA3F833C82655E8725C037A2294E14CF5D73A5DF8D56159DE69
WIF           : KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9MACNivtz8yMYTd
P2PKH Address : 1FRoHA9xewq7DjrZ1psWJVeTer8gHRqEvR
Total Checked : 2262740480
Elapsed Time  : 00:00:52
Speed         : 36.2887 Mkeys/s

           // Construct local buffeer
            for (int i = 0; i < fullBatchSize; i++) {
                pointToCompressedBin(pointBatch[i], localPubKeys[localBatchCount]);
                pointIndices[localBatchCount] = i;
                localBatchCount++;

                // 8 keys are ready - time to use avx2
                if (localBatchCount == HASH_BATCH_SIZE) {
                    computeHash160BatchBinSingle(localBatchCount, localPubKeys, localHashResults);
                    // Results check
                    for (int j = 0; j < HASH_BATCH_SIZE; j++) {
                        __m128i cand16 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(localHashResults[j]));
                        __m128i cmp = _mm_cmpeq_epi8(cand16, target16);

                        // Use the g_prefixLength variable for comparison
                        if (_mm_movemask_epi8(cmp) & ((1 << g_prefixLength) - 1) == ((1 << g_prefixLength) - 1)) {
                            // If the first g_prefixLength bytes match, perform a memcmp to be sure
                            if (!matchFound && std::memcmp(localHashResults[j], targetHash160.data(), g_prefixLength) == 0) {
                                #pragma omp critical
                                {
                                    if (!matchFound) {
                                        auto tEndTime = std::chrono::high_resolution_clock::now();
                                        globalElapsedTime = std::chrono::duration<double>(tEndTime - tStart).count();
                                        mkeysPerSec = (double)(globalComparedCount + localComparedCount) globalElapsedTime 1e6;
                                        
                                        // Recovering private key
                                        Int matchingPrivateKey;
                                        matchingPrivateKey.Set(&currentBatchKey);
                                        int idx = pointIndices[j];
                                        if (idx < 256) {
                                            Int offset; offset.SetInt32(idx);
                                            matchingPrivateKey.Add(&offset);
                                        } else {
                                            Int offset; offset.SetInt32(idx - 256);
                                            matchingPrivateKey.Sub(&offset);
                                        }
                                        foundPrivateKeyHex = padHexTo64(intToHex(matchingPrivateKey));
                                        Point matchedPoint = pointBatch[idx];
                                        foundPublicKeyHex = pointToCompressedHex(matchedPoint);

                                        bool bytesMatch = true;
                                        for (int b = 0; b < 20; b++) {
                                            if (localHashResults[j][b] != targetHash160.data()[b]) {
                                                bytesMatch = false;
                                                break;
                                            }
                                        }
                                        if (bytesMatch) {
                                            matchFound = true;
                                            foundWIF = P2PKHDecoder::compute_wif(foundPrivateKeyHex, true);
                                        } else {
                                            matchFound = false;
                                            foundWIF = P2PKHDecoder::compute_wif(foundPrivateKeyHex, true);
                                            // Print the partial match information
                                            std::lock_guard<std::mutex> lock(coutMutex);
                                            std::cout << "\033[11;1H";
                                            std::cout << "\033[K";
                                            std::cout << "================== PARTIAL MATCH FOUND! ============\n";
                                            std::cout << "Prefix length : " << g_prefixLength << " bytes" << "\n";
                                            std::cout << "Private Key   : " << foundPrivateKeyHex << "\n";
                                            std::cout << "Public Key    : " << foundPublicKeyHex << "\n";
                                            std::cout << "WIF           : " << foundWIF << "\n";
                                            std::cout << "Found Hash160 : ";
                                            for (int b = 0; b < 20; b++) {
                                                printf("%02x", localHashResults[j][b]);
                                            }
                                            std::cout << "\n";
                                            std::cout << "Target Hash160: ";
                                            for (int b = 0; b < 20; b++) {
                                                printf("%02x", targetHash160.data()[b]);
                                            }
                                            std::cout << "\n";
                                            std::cout << "Matched bytes : ";
                                            for (int b = 0; b < g_prefixLength; b++) {
                                                printf("%02x", targetHash160.data()[b]);
                                            }
                                            std::cout << std::endl;
                                            std::cout.flush();
                                          }
                                        }

                                    }
                                }
                                #pragma omp cancel parallel
                            }
                            localComparedCount++;
                        } else {
                            localComparedCount++;
                        }
                    }
                    localBatchCount = 0;
                }