return solutions;
}
+// Scan given kernel for solutions
+bool ScanKernelBackward(unsigned char *kernel, uint32_t nBits, uint32_t nInputTxTime, int64_t nValueIn, std::pair<uint32_t, uint32_t> &SearchInterval, std::pair<uint256, uint32_t> &solution)
+{
+ CBigNum bnTargetPerCoinDay;
+ bnTargetPerCoinDay.SetCompact(nBits);
+
+ CBigNum bnValueIn(nValueIn);
+
+ // Get maximum possible target to filter out the majority of obviously insufficient hashes
+ uint256 nMaxTarget = (bnTargetPerCoinDay * bnValueIn * nStakeMaxAge / COIN / nOneDay).getuint256();
+
+#ifdef USE_ASM
+
+#ifdef __x86_64__
+ if (false && fUse8Way) // AVX2 CPU
+ {
+ uint32_t blocks1[8 * 16] __attribute__((aligned(16)));
+ uint32_t blocks2[8 * 16] __attribute__((aligned(16)));
+ uint32_t candidates[8 * 8] __attribute__((aligned(16)));
+
+ vector<uint32_t> vRow = vector<uint32_t>(8);
+ uint32_t *pnKernel = (uint32_t *) kernel;
+
+ for(int i = 0; i < 7; i++)
+ {
+ fill(vRow.begin(), vRow.end(), pnKernel[i]);
+ copyrow8_swap32(&blocks1[i*8], &vRow[0]);
+ }
+
+ memcpy(&blocks1[56], &block1_suffix_8way[0], 36*8); // sha256 padding
+ memcpy(&blocks2[64], &block2_suffix_8way[0], 32*8);
+
+ uint32_t nHashes[8];
+ uint32_t nTimeStamps[8];
+
+ // Search forward in time from the given timestamp
+ // Stopping search in case of shutting down
+ for (uint32_t nTimeTx=SearchInterval.first, nMaxTarget32 = nMaxTarget.Get32(7); nTimeTx<SearchInterval.second && !fShutdown; nTimeTx -=8)
+ {
+ sha256_init_8way(blocks2);
+ sha256_init_8way(candidates);
+
+ nTimeStamps[0] = nTimeTx;
+ nTimeStamps[1] = nTimeTx-1;
+ nTimeStamps[2] = nTimeTx-2;
+ nTimeStamps[3] = nTimeTx-3;
+ nTimeStamps[4] = nTimeTx-4;
+ nTimeStamps[5] = nTimeTx-5;
+ nTimeStamps[6] = nTimeTx-6;
+ nTimeStamps[7] = nTimeTx-7;
+
+ copyrow8_swap32(&blocks1[24], &nTimeStamps[0]); // Kernel timestamps
+ sha256_transform_8way(&blocks2[0], &blocks1[0], 0); // first hashing
+ sha256_transform_8way(&candidates[0], &blocks2[0], 0); // second hashing
+ copyrow8_swap32(&nHashes[0], &candidates[56]);
+
+ for(int nResult = 0; nResult < 8; nResult++)
+ {
+ if (nHashes[nResult] <= nMaxTarget32) // Possible hit
+ {
+ uint256 nHashProofOfStake = 0;
+ uint32_t *pnHashProofOfStake = (uint32_t *) &nHashProofOfStake;
+
+ for (int i = 0; i < 7; i++)
+ pnHashProofOfStake[i] = __builtin_bswap32(candidates[(i*8) + nResult]);
+ pnHashProofOfStake[7] = nHashes[nResult];
+
+ CBigNum bnCoinDayWeight = bnValueIn * GetWeight((int64_t)nInputTxTime, (int64_t)nTimeStamps[nResult]) / COIN / nOneDay;
+ CBigNum bnTargetProofOfStake = bnCoinDayWeight * bnTargetPerCoinDay;
+
+ if (bnTargetProofOfStake >= CBigNum(nHashProofOfStake))
+ {
+ solution.first = nHashProofOfStake;
+ solution.second = nTimeStamps[nResult];
+
+ return true;
+ }
+ }
+ }
+ }
+ }
+ else
+#endif
+ if (fUse4Way) // SSE2 or Neon CPU
+ {
+ uint32_t blocks1[4 * 16] __attribute__((aligned(16)));
+ uint32_t blocks2[4 * 16] __attribute__((aligned(16)));
+ uint32_t candidates[4 * 8] __attribute__((aligned(16)));
+
+ vector<uint32_t> vRow = vector<uint32_t>(4);
+ uint32_t *pnKernel = (uint32_t *) kernel;
+
+ for(int i = 0; i < 7; i++)
+ {
+ fill(vRow.begin(), vRow.end(), pnKernel[i]);
+ copyrow4_swap32(&blocks1[i*4], &vRow[0]);
+ }
+
+ memcpy(&blocks1[28], &block1_suffix_4way[0], 36*4); // sha256 padding
+ memcpy(&blocks2[32], &block2_suffix_4way[0], 32*4);
+
+ uint32_t nHashes[4];
+ uint32_t nTimeStamps[4];
+
+ // Search forward in time from the given timestamp
+ // Stopping search in case of shutting down
+ for (uint32_t nTimeTx=SearchInterval.first, nMaxTarget32 = nMaxTarget.Get32(7); nTimeTx<SearchInterval.second && !fShutdown; nTimeTx -=4)
+ {
+ sha256_init_4way(blocks2);
+ sha256_init_4way(candidates);
+
+ nTimeStamps[0] = nTimeTx;
+ nTimeStamps[1] = nTimeTx-1;
+ nTimeStamps[2] = nTimeTx-2;
+ nTimeStamps[3] = nTimeTx-3;
+
+ copyrow4_swap32(&blocks1[24], &nTimeStamps[0]); // Kernel timestamps
+ sha256_transform_4way(&blocks2[0], &blocks1[0], 0); // first hashing
+ sha256_transform_4way(&candidates[0], &blocks2[0], 0); // second hashing
+ copyrow4_swap32(&nHashes[0], &candidates[28]);
+
+ for(int nResult = 0; nResult < 4; nResult++)
+ {
+ if (nHashes[nResult] <= nMaxTarget32) // Possible hit
+ {
+ uint256 nHashProofOfStake = 0;
+ uint32_t *pnHashProofOfStake = (uint32_t *) &nHashProofOfStake;
+
+ for (int i = 0; i < 7; i++)
+ pnHashProofOfStake[i] = __builtin_bswap32(candidates[(i*4) + nResult]);
+ pnHashProofOfStake[7] = nHashes[nResult];
+
+ CBigNum bnCoinDayWeight = bnValueIn * GetWeight((int64_t)nInputTxTime, (int64_t)nTimeStamps[nResult]) / COIN / nOneDay;
+ CBigNum bnTargetProofOfStake = bnCoinDayWeight * bnTargetPerCoinDay;
+
+ if (bnTargetProofOfStake >= CBigNum(nHashProofOfStake))
+ {
+ solution.first = nHashProofOfStake;
+ solution.second = nTimeStamps[nResult];
+
+ return true;
+ }
+ }
+ }
+ }
+ }
+ else // Other CPU
+ {
+#endif
+
+#if !defined(USE_ASM) || defined(__i386__)
+ SHA256_CTX ctx, workerCtx;
+ // Init new sha256 context and update it
+ // with first 24 bytes of kernel
+ SHA256_Init(&ctx);
+ SHA256_Update(&ctx, kernel, 8 + 16);
+ workerCtx = ctx; // save context
+
+ // Search backward in time from the given timestamp
+ // Stopping search in case of shutting down
+ for (uint32_t nTimeTx=SearchInterval.first; nTimeTx>SearchInterval.second && !fShutdown; nTimeTx--)
+ {
+ // Complete first hashing iteration
+ uint256 hash1;
+ SHA256_Update(&ctx, (unsigned char*)&nTimeTx, 4);
+ SHA256_Final((unsigned char*)&hash1, &ctx);
+
+ // Restore context
+ ctx = workerCtx;
+
+ // Finally, calculate kernel hash
+ uint256 hashProofOfStake;
+ SHA256((unsigned char*)&hash1, sizeof(hashProofOfStake), (unsigned char*)&hashProofOfStake);
+
+ // Skip if hash doesn't satisfy the maximum target
+ if (hashProofOfStake > nMaxTarget)
+ continue;
+
+ CBigNum bnCoinDayWeight = CBigNum(nValueIn) * GetWeight((int64_t)nInputTxTime, (int64_t)nTimeTx) / COIN / nOneDay;
+ CBigNum bnTargetProofOfStake = bnCoinDayWeight * bnTargetPerCoinDay;
+
+ if (bnTargetProofOfStake >= CBigNum(hashProofOfStake))
+ {
+ solution.first = hashProofOfStake;
+ solution.second = nTimeTx;
+
+ return true;
+ }
+ }
+#else
+ uint32_t block1[16] __attribute__((aligned(16)));
+ uint32_t block2[16] __attribute__((aligned(16)));
+ uint32_t candidate[8] __attribute__((aligned(16)));
+
+ memcpy(&block1[7], &block1_suffix[0], 36); // sha256 padding
+ memcpy(&block2[8], &block2_suffix[0], 32);
+
+ uint32_t *pnKernel = (uint32_t *) kernel;
+
+ for (int i = 0; i < 6; i++)
+ block1[i] = __builtin_bswap32(pnKernel[i]);
+
+ // Search forward in time from the given timestamp
+ // Stopping search in case of shutting down
+ for (uint32_t nTimeTx=SearchInterval.first, nMaxTarget32 = nMaxTarget.Get32(7); nTimeTx<SearchInterval.second && !fShutdown; nTimeTx--)
+ {
+ memcpy(&block2[0], &sha256_initial[0], 32);
+ memcpy(&candidate[0], &sha256_initial[0], 32);
+
+ block1[6] = __builtin_bswap32(nTimeTx);
+
+ sha256_transform(&block2[0], &block1[0], 0); // first hashing
+ sha256_transform(&candidate[0], &block2[0], 0); // second hashing
+
+ uint32_t nHash7 = __builtin_bswap32(candidate[7]);
+
+ // Skip if hash doesn't satisfy the maximum target
+ if (nHash7 > nMaxTarget32)
+ continue;
+
+ uint256 nHashProofOfStake;
+ uint32_t *pnHashProofOfStake = (uint32_t *) &nHashProofOfStake;
+
+ for (int i = 0; i < 7; i++)
+ pnHashProofOfStake[i] = __builtin_bswap32(candidate[i]);
+ pnHashProofOfStake[7] = nHash7;
+
+ CBigNum bnCoinDayWeight = bnValueIn * GetWeight((int64_t)nInputTxTime, (int64_t)nTimeTx) / COIN / nOneDay;
+ CBigNum bnTargetProofOfStake = bnCoinDayWeight * bnTargetPerCoinDay;
+
+ if (bnTargetProofOfStake >= CBigNum(nHashProofOfStake))
+ {
+ solution.first = nHashProofOfStake;
+ solution.second = nTimeTx;
+
+ return true;
+ }
+ }
+#endif
+#ifdef USE_ASM
+ }
+#endif
+
+ return false;
+}