RCKangaroo.cpp

// This file is a part of RCKangaroo software
// (c) 2024, RetiredCoder (RC)
// License: GPLv3, see "LICENSE.TXT" file
// https://github.com/RetiredC
//
// Puzzle-140 research fork: checkpoint/resume, ramlimit freeze, autotune, compact DP.
// + Entropy140 / LinkSolve / TagTrace / VarianceForge / LotteryHerd / DualLane
// + 3.3: StreamTrio/L2Pin/WarpDP/JumpDNA/herd knobs/sidechannels/hybrid/FoundShield/Advise
// + 3.4: JumpDNA full multi-gen + TagTrace GPU implant
// + 3.5: TrueCollider inventions pack (20)
// + 3.6: AI-imagination echo-modes pack (25)


#include <iostream>
#include <vector>
#include <math.h>
#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#include "cuda_runtime.h"
#include "cuda.h"

#include "defs.h"
#include "utils.h"
#include "GpuKang.h"
#include "autotune.h"
#include "netherd.h"
#include "entropy140.h"
#include "linksolve.h"
#include "tagtrace.h"
#include "p140ops.h"
#include "sidechannel.h"
#include "hybridmath.h"
#include "inventions.h"
#include "echomodes.h"


EcJMP EcJumps1[JMP_CNT];
EcJMP EcJumps2[JMP_CNT];
EcJMP EcJumps3[JMP_CNT];

RCGpuKang* GpuKangs[MAX_GPU_CNT];
int GpuCnt;
volatile long ThrCnt;
volatile bool gSolved;

EcInt Int_HalfRange;
EcPoint Pnt_HalfRange;
EcPoint Pnt_NegHalfRange;
EcInt Int_TameOffset;
Ec ec;

CriticalSection csAddPoints;
u8* pPntList;
u8* pPntList2;
volatile int PntIndex;
TFastBase db;
EcPoint gPntToSolve;
EcInt gPrivKey;

volatile u64 TotalOps;
u32 TotalSolved;
u32 gTotalErrors;
u64 PntTotalOps;
bool IsBench;

u32 gDP;
u32 gRange;
EcInt gStart;
bool gStartSet;
EcPoint gPubKey;
u8 gGPUs_Mask[MAX_GPU_CNT];
char gTamesFileName[1024];
double gMax;
bool gGenMode; //tames generation mode
bool gIsOpsLimit;

// Fork options
bool gAutoTune = true;
bool gAutoTuneSet = false;
char gProfile[64] = "";
double gRamLimitGB = 0;
char gSaveFile[1024] = "";
char gLoadFile[1024] = "";
double gCheckpointHours = 0;
volatile bool gStopRequested = false;
volatile bool gFreezeTames = false;
int gPhase = PHASE_FILL;
int gPuzzle = 0;
bool gDP_user_set = false;
bool gRange_user_set = false;
NetHerdConfig gNetHerd;
bool gLoadCheckpoint = false;
u64 gJumpSeed = 0; // jumps always built with seed 0 for compatibility
AutoTuneResult gTune;

// New P140 capability flags
int gMode = MODE_SOTA;
bool gTagTrace = false;
bool gTagTraceSet = false;
bool gVarianceForge = true;
bool gVarianceForgeSet = false;
bool gDualLane = true;
bool gDualLaneSet = false;
int gLotteryWaves = 0;       // 0 = unset; -lottery N sets waves
u64 gLotteryOps = 0;         // ops budget per wave (0 = use -max)
bool gLotteryKeepDp = true;  // keep DP table between waves
bool gPreserveDb = false;    // lottery: don't clear DP on wave end
EntropyConfig gEntropy;
bool gEntropyTSet = false;
LinkSolveResult gLinkResult;
bool gModUserSet = false;
u64 gModM = 0;
u64 gModR = 0;

// 3.3 knobs
bool gStreamTrio = true;
bool gStreamTrioSet = false;
bool gL2Pin = true;
bool gL2PinSet = false;
bool gWarpDP = true;
bool gWarpDPSet = false;
bool gGroupSweep = false;
bool gGroupSweepSet = false;
bool gJumpDNA = false;
bool gJumpDNASet = false;
bool gWaveRoulette = false;
bool gAntiLoop = false;
bool gHerdSkew = false;
bool gSobol = false;
bool gGravity = false;
bool gFoundShield = true;
bool gFoundShieldSet = false;
bool gOrbitResolve = false;
bool gGaudry = false;
bool gAdvise = false;
bool gPocketRadar = false;
int gModFan = 0;
u64 gSideMaxCand = 0;
PocketRadarConfig gPocketCfg;
GaudryBox gGaudryBox;
AntiLoopState gAntiLoopState;
GravityCluster gGravityHost;

// 3.5 invention knobs
bool gSlipstream = true;
bool gSlipstreamSet = false;
bool gChronos = false;
bool gPhantom = false;
bool gForecast = false;
bool gMirrorWorld = false;
bool gTimeCrystal = false;
bool gJumpPoison = false;
bool gDarkRoom = false;
bool gNearMiss = false;
bool gFalseDawn = true;
bool gFalseDawnSet = false;
bool gFleetHive = false;
bool gBoneyard = false;
bool gBudget = false;
u64 gTimeCrystalSeed = 1421345234ull;
ChronosState gChronosState;
ForecastState gForecastState;
PhantomStats gPhantomStats;
int gNetHerdRole = NETHERD_ROLE_ANY;
bool gNetHerdDemo = false;

// 3.6 echo-mode knobs
bool gEchoChamber = false;
bool gShadowLedger = false;
u64 gShadowMod = 65537ull;
bool gDriftCompass = false;
bool gKeyholeSaw = false;
bool gTwinFlame = false;
bool gAfterimage = false;
bool gClaimPredator = false;
bool gDreamReplay = false;
bool gSymmetryPoison = false;
bool gBreadcrumb = false;
bool gQuantumFanfic = false;
bool gDreamtime = false;
bool gMobius = false;
bool gNegentropy = false;
bool gCageMatch = false;
bool gStowaway = false;
bool gApocalypse = false;
EchoChamberState gEchoState;
DriftCompassState gDriftState;
AfterimageState gAfterState;
DreamReplayState gDreamReplayState;
NegentropyState gNegentropyState;
CageMatchState gCageState;
ApocalypseState gApocalypseState;
u64 gTwinFlameH = 0;

static u64 gDpAdded = 0;
static u64 gDpTameSkipped = 0;
static u64 gLastOpsSnapshot = 0;
static u64 gLastStatsMs = 0;

void InitGpus()
{
	GpuCnt = 0;
	int gcnt = 0;
	cudaGetDeviceCount(&gcnt);
	if (gcnt > MAX_GPU_CNT)
		gcnt = MAX_GPU_CNT;

	if (!gcnt)
		return;

	int drv, rt;
	cudaRuntimeGetVersion(&rt);
	cudaDriverGetVersion(&drv);
	char drvver[100];
	sprintf(drvver, "%d.%d/%d.%d", drv / 1000, (drv % 100) / 10, rt / 1000, (rt % 100) / 10);

	printf("CUDA devices: %d, CUDA driver/runtime: %s\r\n", gcnt, drvver);
	cudaError_t cudaStatus;
	for (int i = 0; i < gcnt; i++)
	{
		cudaStatus = cudaSetDevice(i);
		if (cudaStatus != cudaSuccess)
		{
			printf("cudaSetDevice for gpu %d failed!\r\n", i);
			continue;
		}

		if (!gGPUs_Mask[i])
			continue;

		cudaDeviceProp deviceProp;
		cudaGetDeviceProperties(&deviceProp, i);
		printf("GPU %d: %s, %.2f GB, %d CUs, cap %d.%d, PCI %d, L2 size: %d KB\r\n", i, deviceProp.name, ((float)(deviceProp.totalGlobalMem / (1024 * 1024))) / 1024.0f, deviceProp.multiProcessorCount, deviceProp.major, deviceProp.minor, deviceProp.pciBusID, deviceProp.l2CacheSize / 1024);
		
		if (deviceProp.major < 6)
		{
			printf("GPU %d - not supported, skip\r\n", i);
			continue;
		}

		cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync);

		GpuKangs[GpuCnt] = new RCGpuKang();
		GpuKangs[GpuCnt]->CudaIndex = i;
		GpuKangs[GpuCnt]->persistingL2CacheMaxSize = deviceProp.persistingL2CacheMaxSize;
		GpuKangs[GpuCnt]->mpCnt = deviceProp.multiProcessorCount;
		GpuKangs[GpuCnt]->IsOldGpu = deviceProp.l2CacheSize < 16 * 1024 * 1024;
		GpuKangs[GpuCnt]->ComputeMajor = deviceProp.major;
		GpuKangs[GpuCnt]->ComputeMinor = deviceProp.minor;
		GpuKangs[GpuCnt]->Is5xxx = (deviceProp.major == 12);
		int cm = deviceProp.major * 10 + deviceProp.minor;
		if (cm == 89 || cm == 120)
		{
			GpuKangs[GpuCnt]->sm_inv_cnt = GpuKangs[GpuCnt]->Is5xxx
				? (GpuKangs[GpuCnt]->mpCnt / 24) : (GpuKangs[GpuCnt]->mpCnt / 32);
			if (!GpuKangs[GpuCnt]->sm_inv_cnt)
				GpuKangs[GpuCnt]->sm_inv_cnt = 1;
			printf("GPU %d: v4 turbo ASM candidate (sm_%d) — will load cubin in Prepare\r\n", i, cm);
		}
		else if (cm == 86)
		{
			printf("GPU %d: RTX Ampere sm_86 — optimized CUDA fatbin path (ASM turbo blocked: Ada ULDC)\r\n", i);
		}
		GpuCnt++;
	}
	printf("Total GPUs for work: %d\r\n", GpuCnt);
}

#ifdef _WIN32
static BOOL WINAPI ConsoleCtrlHandler(DWORD type)
{
	if (type == CTRL_C_EVENT || type == CTRL_BREAK_EVENT || type == CTRL_CLOSE_EVENT)
	{
		printf("\r\nCtrl+C — requesting checkpoint stop...\r\n");
		gStopRequested = true;
		return TRUE;
	}
	return FALSE;
}
u32 __stdcall kang_thr_proc(void* data)
{
	RCGpuKang* Kang = (RCGpuKang*)data;
	Kang->Execute();
	InterlockedDecrement(&ThrCnt);
	return 0;
}
#else
static void UnixSignalHandler(int)
{
	gStopRequested = true;
}
void* kang_thr_proc(void* data)
{
	RCGpuKang* Kang = (RCGpuKang*)data;
	Kang->Execute();
	__sync_fetch_and_sub(&ThrCnt, 1);
	return 0;
}
#endif

void AddPointsToList(u32* data, int pnt_cnt, u64 ops_cnt)
{
	csAddPoints.Enter();
	if (PntIndex + pnt_cnt >= MAX_CNT_LIST)
	{
		csAddPoints.Leave();
		printf("DPs buffer overflow, some points lost, increase DP value!\r\n");
		return;
	}
	memcpy(pPntList + GPU_DP_SIZE * PntIndex, data, pnt_cnt * GPU_DP_SIZE);
	PntIndex += pnt_cnt;
	PntTotalOps += ops_cnt;
	csAddPoints.Leave();
}

bool Collision_SOTA(EcPoint& pnt, EcInt t, int TameType, EcInt w, int WildType, bool IsNeg)
{
	if (IsNeg)
		t.Neg();
	if (TameType == TAME)
	{
		gPrivKey = t;
		gPrivKey.Sub(w);
		EcInt sv = gPrivKey;
		gPrivKey.Add(Int_HalfRange);
		EcPoint P = ec.MultiplyG(gPrivKey);
		if (P.IsEqual(pnt))
			return true;
		gPrivKey = sv;
		gPrivKey.Neg();
		gPrivKey.Add(Int_HalfRange);
		P = ec.MultiplyG(gPrivKey);
		return P.IsEqual(pnt);
	}
	else
	{
		gPrivKey = t;
		gPrivKey.Sub(w);
		if (gPrivKey.data[4] >> 63)
			gPrivKey.Neg();
		gPrivKey.ShiftRight(1);
		EcInt sv = gPrivKey;
		gPrivKey.Add(Int_HalfRange);
		EcPoint P = ec.MultiplyG(gPrivKey);
		if (P.IsEqual(pnt))
			return true;
		gPrivKey = sv;
		gPrivKey.Neg();
		gPrivKey.Add(Int_HalfRange);
		P = ec.MultiplyG(gPrivKey);
		return P.IsEqual(pnt);
	}
}

static u64 MixSeed(u64 x)
{
	x ^= x >> 30; x *= 0xbf58476d1ce4e5b9ULL;
	x ^= x >> 27; x *= 0x94d049bb133111ebULL;
	x ^= x >> 31;
	return x ? x : 0x9e3779b97f4a7c15ULL;
}

static void MaybeUpdateFreezePhase()
{
	if (gRamLimitGB <= 0 || gGenMode)
		return;
	double used = db.GetRamUsedGB();
	double ratio = used / gRamLimitGB;
	if (!gFreezeTames && ratio >= 0.93)
	{
		gFreezeTames = true;
		gPhase = PHASE_FREEZE;
		printf("RAM limit: %.3f / %.3f GB (%.1f%%) — FREEZE new TAMEs, continue WILDs (FreezeCascade)\r\n",
			used, gRamLimitGB, ratio * 100.0);
		gPhase = PHASE_WILD_STORM;
		printf("Phase -> WILD storm (TAME table frozen)\r\n");
	}
}

void CheckNewPoints()
{
	csAddPoints.Enter();
	if (!PntIndex)
	{
		csAddPoints.Leave();
		return;
	}

	int cnt = PntIndex;
	memcpy(pPntList2, pPntList, GPU_DP_SIZE * cnt);
	PntIndex = 0;
	csAddPoints.Leave();

	MaybeUpdateFreezePhase();

	for (int i = 0; i < cnt; i++)
	{
		DBRec nrec;
		u8* p = pPntList2 + i * GPU_DP_SIZE;
		memcpy(nrec.x, p, 12);
		memcpy(nrec.d, p + 16, 22);
		nrec.type = gGenMode ? TAME : p[40];

		if (!gGenMode && gFreezeTames && nrec.type == TAME)
		{
			gDpTameSkipped++;
			continue;
		}

		u8* pref_raw = db.FindOrAddDataBlock((u8*)&nrec);
		if (!pref_raw)
		{
			gDpAdded++;
			if (gPhantom)
				Phantom_NotePack(&gPhantomStats);
			if (gNetHerd.enabled && !gNetHerd.is_server)
				NetHerd_SubmitDP(&nrec);
			continue;
		}
		if (gGenMode)
			continue;

		DBRec pref_rec;
		UnpackDBRec(pref_raw, nrec.x[0], nrec.x[1], nrec.x[2], &pref_rec);
		// restore full x prefix match identity for collision (use nrec.x for first 3; packed has 5 more)
		memcpy(pref_rec.x, nrec.x, 3);

		if (pref_rec.type == nrec.type)
		{
			if (pref_rec.type == TAME)
				continue;

			if (*(u64*)pref_rec.d == *(u64*)nrec.d)
				continue;
		}

		if (TagTrace_CheapRejectSameDist(&pref_rec, &nrec))
			continue;

		EcInt w, t;
		int TameType, WildType;
		if (pref_rec.type != TAME)
		{
			memcpy(w.data, pref_rec.d, sizeof(pref_rec.d));
			if (pref_rec.d[21] == 0xFF) memset(((u8*)w.data) + 22, 0xFF, 18);
			memcpy(t.data, nrec.d, sizeof(nrec.d));
			if (nrec.d[21] == 0xFF) memset(((u8*)t.data) + 22, 0xFF, 18);
			TameType = nrec.type;
			WildType = pref_rec.type;
		}
		else
		{
			memcpy(w.data, nrec.d, sizeof(nrec.d));
			if (nrec.d[21] == 0xFF) memset(((u8*)w.data) + 22, 0xFF, 18);
			memcpy(t.data, pref_rec.d, sizeof(pref_rec.d));
			if (pref_rec.d[21] == 0xFF) memset(((u8*)t.data) + 22, 0xFF, 18);
			TameType = TAME;
			WildType = nrec.type;
		}

		bool res = Collision_SOTA(gPntToSolve, t, TameType, w, WildType, false) || Collision_SOTA(gPntToSolve, t, TameType, w, WildType, true);
		if (!res)
		{
			EcInt dummy;
			if (CompactResolve_Try(&pref_rec, &nrec, &dummy))
			{
				gPrivKey = dummy;
				gSolved = true;
				break;
			}
			bool w12 = ((pref_rec.type == WILD1) && (nrec.type == WILD2)) || ((pref_rec.type == WILD2) && (nrec.type == WILD1));
			if (w12)
				;
			else
			{
				printf("Collision Error\r\n");
				gTotalErrors++;
			}
			// Near-miss gravity: same-type collisions / close tags
			if (gGravity)
			{
				Gravity_ObserveNearMiss(&gGravityHost, nrec.x, 1);
				for (int gi = 0; gi < GpuCnt; gi++)
					GpuKangs[gi]->ObserveGravityNearMiss(nrec.x, 1);
			}
			if (gNearMiss)
				NearMiss_Commit(nrec.x, 1, true);
			if (gHerdSkew)
			{
				for (int gi = 0; gi < GpuCnt; gi++)
					GpuKangs[gi]->ObserveHerdSkew(false);
			}
			continue;
		}
		if (gHerdSkew)
		{
			for (int gi = 0; gi < GpuCnt; gi++)
				GpuKangs[gi]->ObserveHerdSkew(true);
		}
		if (gPhantom)
			Phantom_NoteReconstruct(&gPhantomStats);
		gSolved = true;
		break;
	}
}

static const char* PhaseName(int p)
{
	switch (p)
	{
	case PHASE_FILL: return "FILL";
	case PHASE_FREEZE: return "FREEZE";
	case PHASE_WILD_STORM: return "WILD";
	default: return "?";
	}
}

void ShowStats(u64 tm_start, double exp_ops, double dp_val)
{
#ifdef DEBUG_MODE
	for (int i = 0; i <= MD_LEN; i++)
	{
		u64 val = 0;
		for (int j = 0; j < GpuCnt; j++)
		{
			val += GpuKangs[j]->dbg[i];
		}
		if (val)
			printf("Loop size %d: %llu\r\n", i, val);
	}
#endif

	int speed = GpuKangs[0]->GetStatsSpeed();
	for (int i = 1; i < GpuCnt; i++)
		speed += GpuKangs[i]->GetStatsSpeed();

	u64 est_dps_cnt = (u64)(exp_ops / dp_val);
	u64 exp_sec = 0xFFFFFFFFFFFFFFFFull;
	if (speed)
		exp_sec = (u64)((exp_ops / 1000000) / speed);
	u64 exp_days = exp_sec / (3600 * 24);
	int exp_hours = (int)(exp_sec - exp_days * (3600 * 24)) / 3600;
	int exp_min = (int)(exp_sec - exp_days * (3600 * 24) - exp_hours * 3600) / 60;

	u64 sec = (GetTickCount64() - tm_start) / 1000;
	u64 days = sec / (3600 * 24);
	int hours = (int)(sec - days * (3600 * 24)) / 3600;
	int min = (int)(sec - days * (3600 * 24) - hours * 3600) / 60;

	double progress = (exp_ops > 0) ? ((double)PntTotalOps / exp_ops) : 0;
	if (progress > 1.0) progress = 1.0;
	double ram_gb = db.GetRamUsedGB();
	double ops_bits = (PntTotalOps > 0) ? log2((double)PntTotalOps) : 0;

	u64 now = GetTickCount64();
	double dp_rate = 0;
	if (gLastStatsMs && now > gLastStatsMs)
	{
		double dt = (now - gLastStatsMs) / 1000.0;
		if (dt > 0)
			dp_rate = (double)(PntTotalOps - gLastOpsSnapshot) / dt;
	}
	gLastStatsMs = now;
	gLastOpsSnapshot = PntTotalOps;

	if (gRamLimitGB > 0)
		printf("%sSpeed: %d MKeys/s, Err: %d, DPs: %lluK/%lluK (%.1f%%), ops: 2^%.2f / 2^%.2f, RAM: %.2f/%.2f GB, DP/s: %.0f, Phase: %s, Time: %llud:%02dh:%02dm/%llud:%02dh:%02dm\r\n",
			gGenMode ? "GEN: " : (IsBench ? "BENCH: " : "MAIN: "),
			speed, gTotalErrors, db.GetBlockCnt() / 1000, est_dps_cnt / 1000, progress * 100.0,
			ops_bits, log2(exp_ops), ram_gb, gRamLimitGB, dp_rate, PhaseName(gPhase),
			days, hours, min, exp_days, exp_hours, exp_min);
	else
		printf("%sSpeed: %d MKeys/s, Err: %d, DPs: %lluK/%lluK (%.1f%%), ops: 2^%.2f / 2^%.2f, RAM: %.2f GB, DP/s: %.0f, Phase: %s, Time: %llud:%02dh:%02dm/%llud:%02dh:%02dm\r\n",
			gGenMode ? "GEN: " : (IsBench ? "BENCH: " : "MAIN: "),
			speed, gTotalErrors, db.GetBlockCnt() / 1000, est_dps_cnt / 1000, progress * 100.0,
			ops_bits, log2(exp_ops), ram_gb, dp_rate, PhaseName(gPhase),
			days, hours, min, exp_days, exp_hours, exp_min);
	fflush(stdout);
}

static bool SaveJumpTables(FILE* fp)
{
	for (int i = 0; i < JMP_CNT; i++)
	{
		if (fwrite(EcJumps1[i].p.x.data, 1, 40, fp) != 40) return false;
		if (fwrite(EcJumps1[i].p.y.data, 1, 40, fp) != 40) return false;
		if (fwrite(EcJumps1[i].dist.data, 1, 40, fp) != 40) return false;
	}
	for (int i = 0; i < JMP_CNT; i++)
	{
		if (fwrite(EcJumps2[i].p.x.data, 1, 40, fp) != 40) return false;
		if (fwrite(EcJumps2[i].p.y.data, 1, 40, fp) != 40) return false;
		if (fwrite(EcJumps2[i].dist.data, 1, 40, fp) != 40) return false;
	}
	for (int i = 0; i < JMP_CNT; i++)
	{
		if (fwrite(EcJumps3[i].p.x.data, 1, 40, fp) != 40) return false;
		if (fwrite(EcJumps3[i].p.y.data, 1, 40, fp) != 40) return false;
		if (fwrite(EcJumps3[i].dist.data, 1, 40, fp) != 40) return false;
	}
	return true;
}

static bool LoadJumpTables(FILE* fp)
{
	for (int i = 0; i < JMP_CNT; i++)
	{
		if (fread(EcJumps1[i].p.x.data, 1, 40, fp) != 40) return false;
		if (fread(EcJumps1[i].p.y.data, 1, 40, fp) != 40) return false;
		if (fread(EcJumps1[i].dist.data, 1, 40, fp) != 40) return false;
	}
	for (int i = 0; i < JMP_CNT; i++)
	{
		if (fread(EcJumps2[i].p.x.data, 1, 40, fp) != 40) return false;
		if (fread(EcJumps2[i].p.y.data, 1, 40, fp) != 40) return false;
		if (fread(EcJumps2[i].dist.data, 1, 40, fp) != 40) return false;
	}
	for (int i = 0; i < JMP_CNT; i++)
	{
		if (fread(EcJumps3[i].p.x.data, 1, 40, fp) != 40) return false;
		if (fread(EcJumps3[i].p.y.data, 1, 40, fp) != 40) return false;
		if (fread(EcJumps3[i].dist.data, 1, 40, fp) != 40) return false;
	}
	return true;
}

bool SaveCheckpoint(const char* path)
{
	char tmp[1100];
	snprintf(tmp, sizeof(tmp), "%s.tmp", path);

	// Pause GPU threads so kangaroo buffers are stable
	for (int i = 0; i < GpuCnt; i++)
		GpuKangs[i]->RequestPause();
	Sleep(500);

	FILE* fp = fopen(tmp, "wb");
	if (!fp)
	{
		printf("checkpoint: cannot open %s\r\n", tmp);
		for (int i = 0; i < GpuCnt; i++)
			GpuKangs[i]->ClearPause();
		return false;
	}

	bool ok = true;
	ok = ok && fwrite(CHECKPOINT_MAGIC, 1, 8, fp) == 8;
	u32 ver = CHECKPOINT_VER;
	ok = ok && fwrite(&ver, 1, 4, fp) == 4;
	ok = ok && fwrite(&gRange, 1, 4, fp) == 4;
	ok = ok && fwrite(&gDP, 1, 4, fp) == 4;
	ok = ok && fwrite(gStart.data, 1, 40, fp) == 40;
	ok = ok && fwrite(gPubKey.x.data, 1, 40, fp) == 40;
	ok = ok && fwrite(gPubKey.y.data, 1, 40, fp) == 40;
	ok = ok && fwrite((const void*)&PntTotalOps, 1, 8, fp) == 8;
	u8 freeze = gFreezeTames ? 1 : 0;
	ok = ok && fwrite(&freeze, 1, 1, fp) == 1;
	ok = ok && fwrite(&gPhase, 1, 4, fp) == 4;
	ok = ok && SaveRndState(fp);
	ok = ok && SaveJumpTables(fp);

	// DP table to sidecar
	char dbpath[1100];
	snprintf(dbpath, sizeof(dbpath), "%s.dp", path);
	db.Header[0] = (u8)gRange;
	db.Header[1] = 'C';
	ok = ok && db.AtomicSaveToFile(dbpath);

	ok = ok && fwrite(&GpuCnt, 1, 4, fp) == 4;
	for (int i = 0; i < GpuCnt && ok; i++)
		ok = GpuKangs[i]->SaveKangState(fp);

	fclose(fp);

	for (int i = 0; i < GpuCnt; i++)
		GpuKangs[i]->ClearPause();

	if (!ok)
	{
		printf("checkpoint: write failed\r\n");
		remove(tmp);
		return false;
	}
	if (!AtomicRenameFile(tmp, path))
	{
		printf("checkpoint: rename failed\r\n");
		return false;
	}
	printf("checkpoint saved: %s (+ %s)\r\n", path, dbpath);
	return true;
}

bool LoadCheckpointMeta(const char* path)
{
	FILE* fp = fopen(path, "rb");
	if (!fp)
		return false;
	char magic[8];
	if (fread(magic, 1, 8, fp) != 8 || memcmp(magic, CHECKPOINT_MAGIC, 8) != 0)
	{
		fclose(fp);
		printf("checkpoint: bad magic\r\n");
		return false;
	}
	u32 ver = 0;
	fread(&ver, 1, 4, fp);
	if (ver != CHECKPOINT_VER)
	{
		fclose(fp);
		printf("checkpoint: unsupported version %u\r\n", ver);
		return false;
	}
	fread(&gRange, 1, 4, fp);
	fread(&gDP, 1, 4, fp);
	fread(gStart.data, 1, 40, fp);
	gStartSet = true;
	fread(gPubKey.x.data, 1, 40, fp);
	fread(gPubKey.y.data, 1, 40, fp);
	fread((void*)&PntTotalOps, 1, 8, fp);
	u8 freeze = 0;
	fread(&freeze, 1, 1, fp);
	gFreezeTames = freeze != 0;
	fread(&gPhase, 1, 4, fp);
	if (!LoadRndState(fp) || !LoadJumpTables(fp))
	{
		fclose(fp);
		printf("checkpoint: rng/jumps load failed\r\n");
		return false;
	}

	char dbpath[1100];
	snprintf(dbpath, sizeof(dbpath), "%s.dp", path);
	if (!db.LoadFromFile(dbpath))
	{
		fclose(fp);
		printf("checkpoint: DP table load failed (%s)\r\n", dbpath);
		return false;
	}

	int gpu_cnt_file = 0;
	fread(&gpu_cnt_file, 1, 4, fp);
	// Kangaroo states loaded after InitGpus in LoadCheckpointGpus
	fclose(fp);

	gRange_user_set = true;
	gDP_user_set = true;
	gLoadCheckpoint = true;
	printf("checkpoint meta loaded: range=%u dp=%u ops=%llu freeze=%d phase=%s DPs=%llu\r\n",
		gRange, gDP, (unsigned long long)PntTotalOps, (int)gFreezeTames, PhaseName(gPhase),
		(unsigned long long)db.GetBlockCnt());
	return true;
}

bool LoadCheckpointGpus(const char* path)
{
	FILE* fp = fopen(path, "rb");
	if (!fp)
		return false;
	// skip header through jumps+db already loaded — re-parse to GPU section
	char magic[8];
	u32 ver;
	fread(magic, 1, 8, fp);
	fread(&ver, 1, 4, fp);
	u32 tmp32; EcInt tmpi; EcPoint tmpp; u64 tmp64; u8 tmp8;
	fread(&tmp32, 1, 4, fp); // range
	fread(&tmp32, 1, 4, fp); // dp
	fread(tmpi.data, 1, 40, fp);
	fread(tmpp.x.data, 1, 40, fp);
	fread(tmpp.y.data, 1, 40, fp);
	fread(&tmp64, 1, 8, fp);
	fread(&tmp8, 1, 1, fp);
	fread(&tmp32, 1, 4, fp);
	if (!LoadRndState(fp)) { fclose(fp); return false; } // consume (already applied)
	if (!LoadJumpTables(fp)) { fclose(fp); return false; }

	int gpu_cnt_file = 0;
	fread(&gpu_cnt_file, 1, 4, fp);
	if (gpu_cnt_file != GpuCnt)
	{
		printf("checkpoint: GPU count mismatch file=%d now=%d\r\n", gpu_cnt_file, GpuCnt);
		fclose(fp);
		return false;
	}
	for (int i = 0; i < GpuCnt; i++)
	{
		if (!GpuKangs[i]->LoadKangState(fp))
		{
			fclose(fp);
			return false;
		}
	}
	fclose(fp);
	printf("checkpoint: kangaroo states loaded for %d GPU(s)\r\n", GpuCnt);
	return true;
}

bool SolvePoint(EcPoint PntToSolve, int Range, int DP, EcInt* pk_res)
{
	if ((Range < 32) || (Range > 180))
	{
		printf("Unsupported Range value (%d)!\r\n", Range);
		return false;
	}
	if ((DP < 14) || (DP > 60)) 
	{
		printf("Unsupported DP value (%d)!\r\n", DP);
		return false;
	}

	printf("\r\nSolving point: Range %d bits, DP %d, start...\r\n", Range, DP);
	double ops = 1.15 * pow(2.0, Range / 2.0);
	double dp_val = (double)(1ull << DP);
	double ram = (DB_REC_LEN + 4 + 4) * ops / dp_val;
	ram += sizeof(TListRec) * 256 * 256 * 256;
	ram /= (1024 * 1024 * 1024);
	printf("SOTA method, estimated ops: 2^%.3f, RAM for DPs: %.3f GB (compact %dB/rec). DP and GPU overheads not included!\r\n",
		log2(ops), ram, DB_REC_LEN);
	printf("Honest note: for range %d this is ~2^%.1f group ops — a single 3060 Ti will NOT finish #140 quickly.\r\n",
		Range, log2(ops));

	gIsOpsLimit = false;
	double MaxTotalOps = 0.0;
	if (gMax > 0)
	{
		MaxTotalOps = gMax * ops;
		double ram_max = (DB_REC_LEN + 4 + 4) * MaxTotalOps / dp_val;
		ram_max += sizeof(TListRec) * 256 * 256 * 256;
		ram_max /= (1024 * 1024 * 1024);
		printf("Max allowed number of ops: 2^%.3f, max RAM for DPs: %.3f GB\r\n", log2(MaxTotalOps), ram_max);
	}
	if (gRamLimitGB > 0)
		printf("RAM limit: %.3f GB (freeze TAMEs at 93%%)\r\n", gRamLimitGB);

	u64 total_kangs = GpuKangs[0]->CalcKangCnt();
	for (int i = 1; i < GpuCnt; i++)
		total_kangs += GpuKangs[i]->CalcKangCnt();
	double path_single_kang = ops / total_kangs;	
	double DPs_per_kang = path_single_kang / dp_val;
	printf("Estimated DPs per kangaroo: %.3f.%s\r\n", DPs_per_kang, (DPs_per_kang < 5) ? " DP overhead is big, use less DP value if possible!" : "");
	printf("Herd: concurrent TAME+WILD1+WILD2 from start (1/3 each).\r\n");
	if (gTagTrace)
		printf("TagTrace: ON (GPU implant + host safety filter)\r\n");
	if (gDualLane)
		printf("DualLane: requested (per-GPU stream path if CUDA streams OK)\r\n");
	if (gStreamTrio)
		printf("StreamTrio: requested (hop / DP-pack / host-copy)\r\n");
	if (gL2Pin)
		printf("L2Pin: requested (persisting L2 for jumps on Ampere+)\r\n");
	if (gWarpDP)
		printf("WarpDP: requested (warp ballot before DPs_out atomics)\r\n");
	if (gAntiLoop)
		printf("AntiLoop Sentinel: ON\r\n");
	if (gChronos)
		printf("ChronosKernel: ON (mid-run host retune)\r\n");
	if (gPhantom)
		printf("PhantomHerd: ON (denser DP hot path)\r\n");
	if (gForecast)
		printf("CollisionForecast: ON (sterility -> reseed)\r\n");
	if (gTimeCrystal)
		printf("TimeCrystal: ON\r\n");
	if (gJumpPoison)
		printf("JumpPoison: ON\r\n");
	if (gMirrorWorld)
		printf("MirrorWorld: ON (limited dual)\r\n");
	if (gFalseDawn)
		printf("FalseDawn Filter: ON (default)\r\n");
	if (gEchoChamber)
		printf("EchoChamber: ON (orthogonal dual-table sensor)\r\n");
	if (gShadowLedger)
		printf("ShadowLedger: ON (M=%llu)\r\n", (unsigned long long)gShadowMod);
	if (gDriftCompass)
		printf("DriftCompass: ON\r\n");
	if (gDreamtime)
		printf("DreamtimeWalk: ON (entropy jumps)\r\n");
	if (gAfterimage)
		printf("Afterimage: ON\r\n");
	if (gDreamReplay)
		printf("DreamReplay: ON\r\n");
	if (gNegentropy)
		printf("NegentropyBudget: ON\r\n");
	if (gApocalypse)
		printf("ApocalypseSave: ON (multi-path ckpt)\r\n");
	if (gStowaway)
		printf("Stowaway: ON (polite priority)\r\n");
	if (gTwinFlame)
		printf("TwinFlame: ON (host-only H)\r\n");
	if (gHerdSkew)
		printf("HerdSkew: ON (dynamic TAME:WILD)\r\n");
	if (gSobol)
		printf("SobolStarts: ON (quasirandom WILD)\r\n");
	if (gGravity)
		printf("GravityRespawn: ON (near-miss bias)\r\n");
	if (gOrbitResolve)
	{
		OrbitResolveResult orb;
		OrbitResolve_Run(PntToSolve, &orb);
	}
	if (gMirrorWorld)
	{
		EcPoint Q;
		char note[320];
		MirrorWorld_Prepare(PntToSolve, &Q, note, (int)sizeof(note));
		printf("  %s\r\n", note);
	}

	if (!gGenMode && gTamesFileName[0] && !gLoadCheckpoint)
	{
		printf("load tames...\r\n");
		if (db.LoadFromFile(gTamesFileName))
		{
			printf("tames loaded\r\n");
			if (db.Header[0] != gRange)
			{
				printf("loaded tames have different range, they cannot be used, clear\r\n");
				db.Clear();
			}
		}
		else
			printf("tames loading failed\r\n");
	}

	bool jumps_from_ckpt = gLoadCheckpoint;
	if (!jumps_from_ckpt)
	{
		TagTrace_SetEnabled(gTagTrace);
		TagTrace_ResetStats();
		if (gJumpDNA)
		{
			JumpDNAResult jd;
			JumpDNA_Run(Range, DP, EcJumps1, EcJumps2, EcJumps3, &jd);
			PrintJumpDNA(&jd);
			gJumpSeed = gJumpDNA_Seed ? gJumpDNA_Seed : jd.best_seed;
		}
		else if (gDreamtime)
		{
			u64 ent = gTimeCrystalSeed ? gTimeCrystalSeed : 0xD2EA4718ULL;
#ifdef _WIN32
			FILETIME ft; GetSystemTimeAsFileTime(&ft);
			ent ^= ((u64)ft.dwHighDateTime << 32) | ft.dwLowDateTime;
#endif
			Dreamtime_BuildJumps(Range, ent, EcJumps1, EcJumps2, EcJumps3);
			gJumpSeed = ent;
		}
		else if (gTimeCrystal)
		{
			TimeCrystal_BuildJumps(Range, gTimeCrystalSeed, EcJumps1, EcJumps2, EcJumps3);
			gJumpSeed = gTimeCrystalSeed;
		}
		else if (gJumpPoison)
		{
			JumpPoison_BuildJumps(Range, gVarianceProfileId, gJumpSeed ? gJumpSeed : 0x50150001ULL, EcJumps1, EcJumps2, EcJumps3);
		}
		else if (gVarianceForge && !gVarianceForgeDone)
		{
			VarianceForgeResult vf;
			VarianceForge_Run(Range, DP, false, EcJumps1, EcJumps2, EcJumps3, &vf);
			PrintVarianceForge(&vf);
			if (gJumpSeed != 0)
				BuildJumpTablesProfile(Range, gVarianceProfileId, gJumpSeed, EcJumps1, EcJumps2, EcJumps3);
		}
		else if (gVarianceForgeDone)
		{
			BuildJumpTablesProfile(Range, gVarianceProfileId, gJumpSeed, EcJumps1, EcJumps2, EcJumps3);
			printf("VarianceForge: profile id=%d seed=%llu\r\n",
				gVarianceProfileId, (unsigned long long)gJumpSeed);
		}
		else
		{
			BuildJumpTablesProfile(Range, 0, gJumpSeed, EcJumps1, EcJumps2, EcJumps3);
			PrintVarianceForgeLite(Range, DP);
		}
		if (gTagTrace)
			TagTrace_Precompute(EcJumps1, EcJumps2, EcJumps3);
	}

	if (!gLoadCheckpoint && !gPreserveDb)
		PntTotalOps = 0;
	u64 ops_at_start = PntTotalOps; // lottery keep-DP: limit is per-wave delta
	PntIndex = 0;

	Int_HalfRange.Set(1);
	Int_HalfRange.ShiftLeft(Range - 1);
	Pnt_HalfRange = ec.MultiplyG(Int_HalfRange);
	Pnt_NegHalfRange = Pnt_HalfRange;
	Pnt_NegHalfRange.y.NegModP();
	Int_TameOffset.Set(1);
	Int_TameOffset.ShiftLeft(Range - 1);
	EcInt tt;
	tt.Set(1);
	tt.ShiftLeft(Range - 5);
	Int_TameOffset.Sub(tt);
	gPntToSolve = PntToSolve;

	if (!gFreezeTames)
		gPhase = PHASE_FILL;

	for (int i = 0; i < GpuCnt; i++)
	{
		GpuKangs[i]->SetDualLane(gDualLane);
		GpuKangs[i]->SetStreamTrio(gStreamTrio);
		GpuKangs[i]->SetL2Pin(gL2Pin);
		GpuKangs[i]->SetWarpDP(gWarpDP);
		GpuKangs[i]->SetGroupSweep(gGroupSweep);
		GpuKangs[i]->SetSobol(gSobol);
		GpuKangs[i]->SetGravity(gGravity);
		GpuKangs[i]->SetHerdSkew(gHerdSkew);
		if (gGravity && gGravityHost.hits > 0)
			*GpuKangs[i]->GetGravityCluster() = gGravityHost;
		if (!GpuKangs[i]->Prepare(PntToSolve, Range, DP, EcJumps1, EcJumps2, EcJumps3))
		{
			GpuKangs[i]->Failed = true;
			printf("GPU %d Prepare failed\r\n", GpuKangs[i]->CudaIndex);
		}
	}

	if (gAntiLoop)
		AntiLoop_Init(&gAntiLoopState);
	if (gChronos)
		Chronos_Init(&gChronosState);
	if (gForecast)
		Forecast_Init(&gForecastState);
	if (gPhantom)
		Phantom_Init(&gPhantomStats);
	if (gEchoChamber)
		EchoChamber_Init(&gEchoState);
	if (gDriftCompass)
		DriftCompass_Init(&gDriftState);
	if (gAfterimage)
		Afterimage_Init(&gAfterState);
	if (gDreamReplay)
		DreamReplay_Init(&gDreamReplayState);
	if (gNegentropy)
		Negentropy_Init(&gNegentropyState);
	if (gCageMatch)
		CageMatch_Init(&gCageState);
	if (gApocalypse)
		Apocalypse_Init(&gApocalypseState, gSaveFile);
	if (gStowaway)
		RunStowaway();
	if (gTwinFlame)
		gTwinFlameH = TwinFlame_HostSecretH();

	u64 tm0 = GetTickCount64();
	printf("GPUs started...\r\n");

#ifdef _WIN32
	HANDLE thr_handles[MAX_GPU_CNT];
#else
	pthread_t thr_handles[MAX_GPU_CNT];
#endif

	u32 ThreadID;
	gSolved = false;
	gStopRequested = false;
	ThrCnt = GpuCnt;
	for (int i = 0; i < GpuCnt; i++)
	{
#ifdef _WIN32
		thr_handles[i] = (HANDLE)_beginthreadex(NULL, 0, kang_thr_proc, (void*)GpuKangs[i], 0, &ThreadID);
#else
		pthread_create(&thr_handles[i], NULL, kang_thr_proc, (void*)GpuKangs[i]);
#endif
	}

	u64 tm_stats = GetTickCount64();
	u64 tm_ckpt = GetTickCount64();
	u64 ckpt_period_ms = (gCheckpointHours > 0) ? (u64)(gCheckpointHours * 3600.0 * 1000.0) : 0;

	while (!gSolved && !gStopRequested)
	{
		CheckNewPoints();
		int sleep_ms = 10;
		if (gChronos && gChronosState.sleep_ms > 0)
			sleep_ms = gChronosState.sleep_ms;
		Sleep(sleep_ms);
		u64 now_stats = GetTickCount64();
		// During FILL at 0 Mk/s, print every 2s so KernelGen/first-hop isn't mistaken for a hang.
		u64 stats_period = 10 * 1000;
		if (gPhase == PHASE_FILL)
		{
			int sp0 = (GpuCnt > 0 && GpuKangs[0]) ? GpuKangs[0]->GetStatsSpeed() : 0;
			if (sp0 <= 0)
				stats_period = 2 * 1000;
		}
		if (now_stats - tm_stats > stats_period)
		{
			ShowStats(tm0, ops, dp_val);
			tm_stats = now_stats;
			bool reseed = false;
			if (gAntiLoop && AntiLoop_Check(&gAntiLoopState, db.GetBlockCnt(), PntTotalOps, 0))
				reseed = true;
			if (gForecast && Forecast_Observe(&gForecastState, db.GetBlockCnt(), PntTotalOps))
				reseed = true;
			if (gChronos)
				Chronos_Retune(&gChronosState, PntTotalOps, db.GetBlockCnt(), GetTickCount64());
			if (gEchoChamber)
				EchoChamber_Note(&gEchoState, db.GetBlockCnt(), PntTotalOps);
			if (gDriftCompass)
				DriftCompass_Observe(&gDriftState, db.GetBlockCnt(), PntTotalOps);
			if (gDreamReplay && DreamReplay_Observe(&gDreamReplayState, db.GetBlockCnt(), PntTotalOps))
				reseed = true;
			if (gNegentropy)
				Negentropy_Observe(&gNegentropyState, db.GetBlockCnt(), PntTotalOps);
			if (reseed)
			{
				gJumpSeed = MixSeed(gJumpSeed ^ PntTotalOps);
				printf("Reseed signal: sterile herd — new seed=%llu (GPU jumps update on next Prepare/lottery wave; "
					"for mid-run reseed use -mode lottery)\r\n",
					(unsigned long long)gJumpSeed);
			}
		}

		if (ckpt_period_ms && gSaveFile[0] && (GetTickCount64() - tm_ckpt >= ckpt_period_ms))
		{
			SaveCheckpoint(gSaveFile);
			if (gApocalypse)
				RunApocalypseSave(gSaveFile);
			tm_ckpt = GetTickCount64();
		}

		if ((MaxTotalOps > 0.0) && ((PntTotalOps - ops_at_start) > MaxTotalOps))
		{
			gIsOpsLimit = true;
			printf("Operations limit reached\r\n");
			break;
		}
	}

	if (gStopRequested && gSaveFile[0])
	{
		printf("Saving checkpoint on stop...\r\n");
		SaveCheckpoint(gSaveFile);
	}
	else if (gStopRequested && !gSaveFile[0])
	{
		const char* auto_name = "checkpoint_autosave.rck";
		printf("Saving autosave checkpoint (%s)...\r\n", auto_name);
		SaveCheckpoint(auto_name);
	}

	printf("Stopping work ...\r\n");
	for (int i = 0; i < GpuCnt; i++)
		GpuKangs[i]->Stop();
	while (ThrCnt)
		Sleep(10);
	for (int i = 0; i < GpuCnt; i++)
	{
#ifdef _WIN32
		CloseHandle(thr_handles[i]);
#else
		pthread_join(thr_handles[i], NULL);
#endif
	}

	if (gStopRequested && !gSolved)
	{
		db.Clear();
		return false;
	}

	if (gIsOpsLimit)
	{
		if (gGenMode)
		{
			printf("saving tames...\r\n");
			db.Header[0] = gRange; 
			if (db.AtomicSaveToFile(gTamesFileName))
				printf("tames saved\r\n");
			else
				printf("tames saving failed\r\n");
		}
		if (!gPreserveDb)
			db.Clear();
		return false;
	}

	double K = (double)PntTotalOps / pow(2.0, Range / 2.0);
	printf("Point solved, K: %.3f (with DP and GPU overheads)\r\n\r\n", K);
	TagTrace_PrintStats();
	if (gPhantom)
		Phantom_Print(&gPhantomStats);
	if (!gPreserveDb)
		db.Clear();
	*pk_res = gPrivKey;
	return true;
}

// LotteryHerd: many short independent waves; keep best K; optional DP keep.
// WaveRoulette: keep only the top-scoring wave's DP density (discard others).
// Default: keep DP table between waves (fat left-tail farming). Fresh starts: -lottery-fresh.
static bool SolveLotteryHerd(EcPoint PntToSolve, int Range, int DP, EcInt* pk_res)
{
	int waves = gLotteryWaves > 0 ? gLotteryWaves : 8;
	double saved_max = gMax;
	if (gLotteryOps > 0)
	{
		double exp_ops = 1.15 * pow(2.0, Range / 2.0);
		gMax = (double)gLotteryOps / exp_ops;
		if (gMax < 0.001) gMax = 0.001;
	}
	else if (gMax <= 0)
		gMax = 0.05; // short default wave

	printf("\r\n========== LOTTERYHERD%s ==========\r\n", gWaveRoulette ? " + WAVEROULETTE" : "");
	printf("Honest: luck-shaping via many short herd waves — NOT a √N break.\r\n");
	printf("Waves=%d  per-wave -max=%.4f  keep_DP=%s  waveroulette=%s\r\n",
		waves, gMax,
		gLotteryKeepDp && !gWaveRoulette ? "yes (accumulate)" : "fresh/roulette",
		gWaveRoulette ? "ON (keep top DP-density wave only)" : "off");
	printf("Checkpoint between waves if -save set.\r\n");
	printf("=================================\r\n\r\n");

	double best_K = 1e300;
	double best_dp_density = -1.0;
	bool solved = false;
	u64 best_wave_ops = 0;
	u64 best_wave_dps = 0;
	gPreserveDb = gLotteryKeepDp && !gWaveRoulette;

	if (gJumpDNA && !gVarianceForgeDone)
	{
		JumpDNAResult jd;
		JumpDNA_Run(Range, DP, EcJumps1, EcJumps2, EcJumps3, &jd);
		PrintJumpDNA(&jd);
	}
	else if (gVarianceForge && !gVarianceForgeDone)
	{
		VarianceForgeResult vf;
		VarianceForge_Run(Range, DP, false, EcJumps1, EcJumps2, EcJumps3, &vf);
		PrintVarianceForge(&vf);
	}

	for (int w = 1; w <= waves && !gStopRequested && !solved; w++)
	{
		gJumpSeed = (u64)w * 0x9e3779b97f4a7c15ULL;
		if (gAntiLoop && gAntiLoopState.reseed_cnt)
			gJumpSeed ^= MixSeed(gAntiLoopState.reseed_cnt);

		printf("\r\n--- LotteryHerd wave %d / %d seed=%llu best_K=%s%.3f ---\r\n",
			w, waves, (unsigned long long)gJumpSeed,
			best_K < 1e299 ? "" : "n/a ",
			best_K < 1e299 ? best_K : 0.0);

		if (!gLotteryKeepDp || gWaveRoulette)
			db.Clear();

		gIsOpsLimit = false;
		gSolved = false;
		u64 ops_before = PntTotalOps;
		u64 dps_before = db.GetBlockCnt();
		EcInt pk;
		bool ok = SolvePoint(PntToSolve, Range, DP, &pk);
		u64 wave_ops = (PntTotalOps >= ops_before) ? (PntTotalOps - ops_before) : PntTotalOps;
		u64 wave_dps = (db.GetBlockCnt() >= dps_before) ? (db.GetBlockCnt() - dps_before) : db.GetBlockCnt();
		double wave_K = (double)wave_ops / pow(2.0, Range / 2.0);
		double density = wave_ops > 0 ? (double)wave_dps / (double)wave_ops : 0.0;

		if (wave_ops > 0 && wave_K < best_K)
			best_K = wave_K;

		if (gWaveRoulette)
		{
			if (density > best_dp_density)
			{
				best_dp_density = density;
				best_wave_ops = wave_ops;
				best_wave_dps = wave_dps;
				printf("WaveRoulette: new best DP density=%.6e (DPs=%llu ops=%llu) — keeping this wave's table\r\n",
					density, (unsigned long long)wave_dps, (unsigned long long)wave_ops);
				// keep DB as-is for this wave; next wave clears then this logic re-picks
			}
			else
			{
				printf("WaveRoulette: density=%.6e < best=%.6e — discard wave DP\r\n",
					density, best_dp_density);
				db.Clear();
			}
		}

		printf("Wave %d done: wave_K=%.3f  best_K=%.3f  density=%.3e  solved=%s\r\n",
			w, wave_K, best_K < 1e299 ? best_K : wave_K, density, ok ? "YES" : "no");

		if (ok)
		{
			*pk_res = pk;
			solved = true;
			break;
		}

		if (gSaveFile[0])
		{
			printf("LotteryHerd: checkpoint between waves...\r\n");
			SaveCheckpoint(gSaveFile);
		}
		gLoadCheckpoint = false;
	}

	gPreserveDb = false;
	gMax = saved_max;
	if (!gLotteryKeepDp || gWaveRoulette)
		db.Clear();
	printf("\r\nLotteryHerd finished. best_K=%.3f best_density=%.3e solved=%s\r\n",
		best_K < 1e299 ? best_K : 0.0, best_dp_density > 0 ? best_dp_density : 0.0,
		solved ? "YES" : "no");
	(void)best_wave_ops; (void)best_wave_dps;
	return solved;
}

static void ApplyPuzzle(int n)
{
	gPuzzle = n;
	if (n == 140)
	{
		if (!gPubKey.SetHexStr(PUZZLE140_PUBKEY))
			printf("error: puzzle 140 pubkey\r\n");
		if (!gStartSet)
		{
			gStart.SetHexStr(PUZZLE140_START);
			gStartSet = true;
		}
		if (!gRange_user_set)
		{
			gRange = PUZZLE140_RANGE;
			gRange_user_set = true;
		}
		if (!gAutoTuneSet)
			gAutoTune = true;
		printf("Preset -puzzle 140: start=%s range=%d pubkey=%s\r\n",
			PUZZLE140_START, PUZZLE140_RANGE, PUZZLE140_PUBKEY);
	}
	else if (n == 70)
	{
		if (!gPubKey.SetHexStr(PUZZLE70_PUBKEY))
			printf("error: puzzle 70 pubkey\r\n");
		if (!gStartSet)
		{
			gStart.SetHexStr(PUZZLE70_START);
			gStartSet = true;
		}
		if (!gRange_user_set)
		{
			gRange = PUZZLE70_RANGE;
			gRange_user_set = true;
		}
		printf("Preset -puzzle 70 (validation): start=%s range=%d\r\n",
			PUZZLE70_START, PUZZLE70_RANGE);
	}
	else
		printf("error: unsupported -puzzle %d (use 70 or 140)\r\n", n);
}

bool ParseCommandLine(int argc, char* argv[])
{
	int ci = 1;
	while (ci < argc)
	{
		char* argument = argv[ci];
		ci++;
		if (strcmp(argument, "-gpu") == 0)
		{
			if (ci >= argc)
			{
				printf("error: missed value after -gpu option\r\n");
				return false;
			}
			char* gpus = argv[ci];
			ci++;
			memset(gGPUs_Mask, 0, sizeof(gGPUs_Mask));
			for (int i = 0; i < (int)strlen(gpus); i++)
			{
				if ((gpus[i] < '0') || (gpus[i] > '9'))
				{
					printf("error: invalid value for -gpu option\r\n");
					return false;
				}
				gGPUs_Mask[gpus[i] - '0'] = 1;
			}
		}
		else
		if (strcmp(argument, "-dp") == 0)
		{
			int val = atoi(argv[ci]);
			ci++;
			if ((val < 14) || (val > 60))
			{
				printf("error: invalid value for -dp option\r\n");
				return false;
			}
			gDP = val;
			gDP_user_set = true;
		}
		else
		if (strcmp(argument, "-range") == 0)
		{
			int val = atoi(argv[ci]);
			ci++;
			if ((val < 32) || (val > 170))
			{
				printf("error: invalid value for -range option\r\n");
				return false;
			}
			gRange = val;
			gRange_user_set = true;
		}
		else
		if (strcmp(argument, "-start") == 0)
		{	
			if (!gStart.SetHexStr(argv[ci]))
			{
				printf("error: invalid value for -start option\r\n");
				return false;
			}
			ci++;
			gStartSet = true;
		}
		else
		if (strcmp(argument, "-pubkey") == 0)
		{
			if (!gPubKey.SetHexStr(argv[ci]))
			{
				printf("error: invalid value for -pubkey option\r\n");
				return false;
			}
			ci++;
		}
		else
		if (strcmp(argument, "-tames") == 0)
		{
			strcpy(gTamesFileName, argv[ci]);
			ci++;
		}
		else
		if (strcmp(argument, "-max") == 0)
		{
			double val = atof(argv[ci]);
			ci++;
			if (val < 0.001)
			{
				printf("error: invalid value for -max option\r\n");
				return false;
			}
			gMax = val;
		}
		else
		if (strcmp(argument, "-puzzle") == 0)
		{
			int val = atoi(argv[ci]);
			ci++;
			ApplyPuzzle(val);
		}
		else
		if (strcmp(argument, "-ramlimit") == 0)
		{
			gRamLimitGB = atof(argv[ci]);
			ci++;
			if (gRamLimitGB < 0.5)
			{
				printf("error: invalid -ramlimit\r\n");
				return false;
			}
		}
		else
		if (strcmp(argument, "-save") == 0)
		{
			strncpy(gSaveFile, argv[ci], sizeof(gSaveFile) - 1);
			ci++;
		}
		else
		if (strcmp(argument, "-load") == 0)
		{
			strncpy(gLoadFile, argv[ci], sizeof(gLoadFile) - 1);
			ci++;
		}
		else
		if (strcmp(argument, "-checkpoint") == 0)
		{
			gCheckpointHours = atof(argv[ci]);
			ci++;
			if (gCheckpointHours <= 0)
			{
				printf("error: invalid -checkpoint hours\r\n");
				return false;
			}
		}
		else
		if (strcmp(argument, "-autotune") == 0)
		{
			gAutoTune = true;
			gAutoTuneSet = true;
		}
		else
		if (strcmp(argument, "-no-autotune") == 0)
		{
			gAutoTune = false;
			gAutoTuneSet = true;
		}
		else
		if (strcmp(argument, "-profile") == 0)
		{
			strncpy(gProfile, argv[ci], sizeof(gProfile) - 1);
			ci++;
		}
		else
		if (strcmp(argument, "-netherd") == 0)
		{
			gNetHerd.enabled = true;
			if (ci < argc && argv[ci][0] != '-')
			{
				if (strcmp(argv[ci], "server") == 0)
					gNetHerd.is_server = true;
				else if (strcmp(argv[ci], "client") == 0 || strcmp(argv[ci], "worker") == 0)
					gNetHerd.is_server = false;
				else if (strcmp(argv[ci], "demo") == 0)
				{
					gNetHerdDemo = true;
					gMode = MODE_NETHERD;
				}
				ci++;
			}
		}
		else
		if (strcmp(argument, "-netherd-port") == 0)
		{
			gNetHerd.port = atoi(argv[ci]);
			ci++;
		}
		else
		if (strcmp(argument, "-netherd-role") == 0)
		{
			char* r = argv[ci++];
			if (strcmp(r, "tame") == 0) gNetHerdRole = NETHERD_ROLE_TAME;
			else if (strcmp(r, "wild") == 0) gNetHerdRole = NETHERD_ROLE_WILD;
			else gNetHerdRole = NETHERD_ROLE_ANY;
			gNetHerd.role = gNetHerdRole;
		}
		else
		if (strcmp(argument, "-help-netherd") == 0)
		{
			NetHerd_PrintProtocolHelp();
			return false;
		}
		else
		if (strcmp(argument, "-help-inventions") == 0)
		{
			Inventions_PrintHelp();
			return false;
		}
		else
		if (strcmp(argument, "-help-echomodes") == 0)
		{
			EchoModes_PrintHelp();
			return false;
		}
		else
		if (strcmp(argument, "-mode") == 0)
		{
			if (ci >= argc)
			{
				printf("error: missed value after -mode\r\n");
				return false;
			}
			char* m = argv[ci++];
			if (strcmp(m, "sota") == 0) gMode = MODE_SOTA;
			else if (strcmp(m, "entropy") == 0) gMode = MODE_ENTROPY;
			else if (strcmp(m, "link") == 0) gMode = MODE_LINK;
			else if (strcmp(m, "lottery") == 0) gMode = MODE_LOTTERY;
			else if (strcmp(m, "archaeology") == 0) gMode = MODE_ARCHAEOLOGY;
			else if (strcmp(m, "hdlattice") == 0) gMode = MODE_HDLATTICE;
			else if (strcmp(m, "keydelta") == 0) gMode = MODE_KEYDELTA;
			else if (strcmp(m, "prng") == 0) gMode = MODE_PRNG;
			else if (strcmp(m, "pattern") == 0) gMode = MODE_PATTERN;
			else if (strcmp(m, "pocket") == 0) gMode = MODE_POCKET;
			else if (strcmp(m, "hybrid") == 0) gMode = MODE_HYBRID;
			else if (strcmp(m, "advise") == 0) { gMode = MODE_ADVISE; gAdvise = true; }
			else if (strcmp(m, "seedoracle") == 0) gMode = MODE_SEEDORACLE;
			else if (strcmp(m, "rosetta") == 0) gMode = MODE_ROSETTA;
			else if (strcmp(m, "deltacrystal") == 0) gMode = MODE_DELTACRYSTAL;
			else if (strcmp(m, "mempoolghost") == 0) gMode = MODE_MEMPOOLGHOST;
			else if (strcmp(m, "budget") == 0) { gMode = MODE_BUDGET; gBudget = true; }
			else if (strcmp(m, "netherd") == 0) gMode = MODE_NETHERD;
			else if (strcmp(m, "isopath") == 0) gMode = MODE_ISOPATH;
			else if (strcmp(m, "quasirho") == 0) gMode = MODE_QUASIRHO;
			else if (strcmp(m, "boneyard") == 0) { gMode = MODE_BONEYARD; gBoneyard = true; }
			else if (strcmp(m, "fleethive") == 0) { gMode = MODE_FLEETHIVE; gFleetHive = true; }
			else if (strcmp(m, "echochamber") == 0) gMode = MODE_ECHOCHAMBER;
			else if (strcmp(m, "shadowledger") == 0) gMode = MODE_SHADOWLEDGER;
			else if (strcmp(m, "keyholesaw") == 0) gMode = MODE_KEYHOLESAW;
			else if (strcmp(m, "choir") == 0) gMode = MODE_CHOIR;
			else if (strcmp(m, "clockwork") == 0) gMode = MODE_CLOCKWORK;
			else if (strcmp(m, "heirloom") == 0) gMode = MODE_HEIRLOOM;
			else if (strcmp(m, "glasscannon") == 0) gMode = MODE_GLASSCANNON;
			else if (strcmp(m, "silentauction") == 0) gMode = MODE_SILENTAUCTION;
			else if (strcmp(m, "oraclemirage") == 0) gMode = MODE_ORACLEMIRAGE;
			else if (strcmp(m, "paleontology") == 0) gMode = MODE_PALEONTOLOGY;
			else if (strcmp(m, "doppelganger") == 0) gMode = MODE_DOPPELGANGER;
			else if (strcmp(m, "driftcompass") == 0) gMode = MODE_DRIFTCOMPASS;
			else if (strcmp(m, "twinflame") == 0) gMode = MODE_TWINFLAME;
			else if (strcmp(m, "afterimage") == 0) gMode = MODE_AFTERIMAGE;
			else if (strcmp(m, "claimpredator") == 0) gMode = MODE_CLAIMPREDATOR;
			else if (strcmp(m, "dreamreplay") == 0) gMode = MODE_DREAMREPLAY;
			else if (strcmp(m, "symmetrypoison") == 0) gMode = MODE_SYMMETRYPOISON;
			else if (strcmp(m, "breadcrumb") == 0) gMode = MODE_BREADCRUMB;
			else if (strcmp(m, "quantumfanfic") == 0) gMode = MODE_QUANTUMFANFIC;
			else if (strcmp(m, "dreamtime") == 0) gMode = MODE_DREAMTIME;
			else if (strcmp(m, "mobius") == 0) gMode = MODE_MOBIUS;
			else if (strcmp(m, "negentropy") == 0) gMode = MODE_NEGENTROPY;
			else if (strcmp(m, "cagematch") == 0) gMode = MODE_CAGEMATCH;
			else if (strcmp(m, "stowaway") == 0) gMode = MODE_STOWAWAY;
			else if (strcmp(m, "apocalypse") == 0) gMode = MODE_APOCALYPSE;
			else
			{
				printf("error: -mode expects sota|...|fleethive|echochamber|shadowledger|keyholesaw|choir|clockwork|heirloom|glasscannon|silentauction|oraclemirage|paleontology|doppelganger|driftcompass|twinflame|afterimage|claimpredator|dreamreplay|symmetrypoison|breadcrumb|quantumfanfic|dreamtime|mobius|negentropy|cagematch|stowaway|apocalypse\r\n");
				return false;
			}
		}
		else
		if (strcmp(argument, "-entropy140") == 0)
		{
			gMode = MODE_ENTROPY;
		}
		else
		if (strcmp(argument, "-linksolve") == 0)
		{
			gMode = MODE_LINK;
		}
		else
		if (strcmp(argument, "-lottery") == 0)
		{
			gMode = MODE_LOTTERY;
			if (ci < argc && argv[ci][0] != '-')
			{
				gLotteryWaves = atoi(argv[ci]);
				ci++;
			}
			else if (gLotteryWaves <= 0)
				gLotteryWaves = 8;
		}
		else
		if (strcmp(argument, "-lottery-ops") == 0)
		{
			gLotteryOps = (u64)strtoull(argv[ci], NULL, 10);
			ci++;
		}
		else
		if (strcmp(argument, "-lottery-fresh") == 0)
		{
			gLotteryKeepDp = false;
		}
		else
		if (strcmp(argument, "-tagtrace") == 0)
		{
			gTagTrace = atoi(argv[ci]) != 0;
			gTagTraceSet = true;
			ci++;
		}
		else
		if (strcmp(argument, "-varianceforge") == 0)
		{
			gVarianceForge = atoi(argv[ci]) != 0;
			gVarianceForgeSet = true;
			ci++;
		}
		else
		if (strcmp(argument, "-duallane") == 0)
		{
			gDualLane = atoi(argv[ci]) != 0;
			gDualLaneSet = true;
			ci++;
		}
		else
		if (strcmp(argument, "-T") == 0)
		{
			// -T start:end
			char* spec = argv[ci++];
			char* colon = strchr(spec, ':');
			if (!colon)
			{
				printf("error: -T expects start:end unix timestamps\r\n");
				return false;
			}
			*colon = 0;
			gEntropy.t_start = (u64)strtoull(spec, NULL, 10);
			gEntropy.t_end = (u64)strtoull(colon + 1, NULL, 10);
			*colon = ':';
			gEntropyTSet = true;
		}
		else
		if (strcmp(argument, "-entropy-model") == 0)
		{
			strncpy(gEntropy.model, argv[ci], sizeof(gEntropy.model) - 1);
			ci++;
		}
		else
		if (strcmp(argument, "-entropy-max") == 0)
		{
			gEntropy.max_candidates = (u64)strtoull(argv[ci], NULL, 10);
			ci++;
		}
		else
		if (strcmp(argument, "-entropy-depth") == 0)
		{
			gEntropy.bip32_depth = atoi(argv[ci]);
			ci++;
		}
		else
		if (strcmp(argument, "-mod") == 0)
		{
			gModM = (u64)strtoull(argv[ci], NULL, 10);
			ci++;
			gModUserSet = true;
			gLinkModEnabled = true;
			gLinkModM.Set(gModM);
		}
		else
		if (strcmp(argument, "-res") == 0)
		{
			gModR = (u64)strtoull(argv[ci], NULL, 10);
			ci++;
			gLinkModR.Set(gModR);
		}
		else
		if (strcmp(argument, "-streamtrio") == 0)
		{
			gStreamTrio = atoi(argv[ci]) != 0;
			gStreamTrioSet = true;
			ci++;
		}
		else
		if (strcmp(argument, "-l2pin") == 0)
		{
			gL2Pin = atoi(argv[ci]) != 0;
			gL2PinSet = true;
			ci++;
		}
		else
		if (strcmp(argument, "-warpdp") == 0)
		{
			gWarpDP = atoi(argv[ci]) != 0;
			gWarpDPSet = true;
			ci++;
		}
		else
		if (strcmp(argument, "-groupsweep") == 0)
		{
			gGroupSweep = atoi(argv[ci]) != 0;
			gGroupSweepSet = true;
			ci++;
		}
		else
		if (strcmp(argument, "-jumpdna") == 0)
		{
			gJumpDNA = atoi(argv[ci]) != 0;
			gJumpDNASet = true;
			ci++;
		}
		else
		if (strcmp(argument, "-jumpdna-gens") == 0)
		{
			gJumpDNA_Gens = atoi(argv[ci]);
			if (gJumpDNA_Gens < 1) gJumpDNA_Gens = 1;
			if (gJumpDNA_Gens > 40) gJumpDNA_Gens = 40;
			gJumpDNA = true;
			gJumpDNASet = true;
			ci++;
		}
		else
		if (strcmp(argument, "-jumpdna-load") == 0)
		{
			strncpy(gJumpDNA_LoadPath, argv[ci], sizeof(gJumpDNA_LoadPath) - 1);
			gJumpDNA = true;
			gJumpDNASet = true;
			ci++;
		}
		else
		if (strcmp(argument, "-jumpdna-save") == 0)
		{
			strncpy(gJumpDNA_SavePath, argv[ci], sizeof(gJumpDNA_SavePath) - 1);
			ci++;
		}
		else
		if (strcmp(argument, "-waveroulette") == 0)
		{
			gWaveRoulette = true;
			gMode = MODE_LOTTERY;
			if (gLotteryWaves <= 0) gLotteryWaves = 8;
		}
		else
		if (strcmp(argument, "-antiloop") == 0)
		{
			gAntiLoop = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-herdskew") == 0)
		{
			gHerdSkew = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-sobol") == 0)
		{
			gSobol = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-gravity") == 0)
		{
			gGravity = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-foundshield") == 0)
		{
			gFoundShield = atoi(argv[ci]) != 0;
			gFoundShieldSet = true;
			ci++;
		}
		else
		if (strcmp(argument, "-advise") == 0)
		{
			gAdvise = true;
			gMode = MODE_ADVISE;
		}
		else
		if (strcmp(argument, "-pocketradar") == 0 || strcmp(argument, "-pocket") == 0)
		{
			gPocketRadar = true;
			gMode = MODE_POCKET;
		}
		else
		if (strcmp(argument, "-modfan") == 0)
		{
			gModFan = atoi(argv[ci]);
			ci++;
			if (gModFan < 2) gModFan = 16;
		}
		else
		if (strcmp(argument, "-gaudry") == 0)
		{
			gGaudry = true;
		}
		else
		if (strcmp(argument, "-orbitresolve") == 0)
		{
			gOrbitResolve = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-side-max") == 0)
		{
			gSideMaxCand = (u64)strtoull(argv[ci], NULL, 10);
			ci++;
		}
		else
		if (strcmp(argument, "-slipstream") == 0)
		{
			gSlipstream = atoi(argv[ci]) != 0;
			gSlipstreamSet = true;
			ci++;
		}
		else
		if (strcmp(argument, "-chronos") == 0)
		{
			gChronos = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-phantom") == 0)
		{
			gPhantom = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-forecast") == 0)
		{
			gForecast = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-budget") == 0)
		{
			gBudget = true;
			gMode = MODE_BUDGET;
		}
		else
		if (strcmp(argument, "-mirrorworld") == 0)
		{
			gMirrorWorld = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-timecrystal") == 0)
		{
			gTimeCrystal = atoi(argv[ci]) != 0;
			ci++;
			if (ci < argc && argv[ci][0] != '-')
			{
				gTimeCrystalSeed = (u64)strtoull(argv[ci], NULL, 10);
				ci++;
			}
		}
		else
		if (strcmp(argument, "-jumppoison") == 0)
		{
			gJumpPoison = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-darkroom") == 0)
		{
			gDarkRoom = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-nearmiss") == 0)
		{
			gNearMiss = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-falsedawn") == 0)
		{
			gFalseDawn = atoi(argv[ci]) != 0;
			gFalseDawnSet = true;
			ci++;
		}
		else
		if (strcmp(argument, "-fleethive") == 0)
		{
			gFleetHive = true;
			gMode = MODE_FLEETHIVE;
		}
		else
		if (strcmp(argument, "-boneyard") == 0)
		{
			gBoneyard = true;
			gMode = MODE_BONEYARD;
		}
		else
		if (strcmp(argument, "-echochamber") == 0)
		{
			gEchoChamber = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-shadowledger") == 0)
		{
			gShadowLedger = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-shadow-mod") == 0)
		{
			gShadowMod = (u64)strtoull(argv[ci], NULL, 10);
			ci++;
		}
		else
		if (strcmp(argument, "-driftcompass") == 0)
		{
			gDriftCompass = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-keyholesaw") == 0)
		{
			gKeyholeSaw = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-twinflame") == 0)
		{
			gTwinFlame = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-afterimage") == 0)
		{
			gAfterimage = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-claimpredator") == 0)
		{
			gClaimPredator = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-dreamreplay") == 0)
		{
			gDreamReplay = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-symmetrypoison") == 0)
		{
			gSymmetryPoison = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-breadcrumb") == 0)
		{
			gBreadcrumb = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-quantumfanfic") == 0)
		{
			gQuantumFanfic = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-dreamtime") == 0)
		{
			gDreamtime = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-mobius") == 0)
		{
			gMobius = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-negentropy") == 0)
		{
			gNegentropy = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-cagematch") == 0)
		{
			gCageMatch = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-stowaway") == 0)
		{
			gStowaway = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-apocalypse") == 0)
		{
			gApocalypse = atoi(argv[ci]) != 0;
			ci++;
		}
		else
		if (strcmp(argument, "-glasscannon") == 0)
		{
			int v = 1;
			if (ci < argc && argv[ci][0] != '-')
			{
				v = atoi(argv[ci]);
				ci++;
			}
			if (v) gMode = MODE_GLASSCANNON;
		}
		else
		{
			printf("error: unknown option %s\r\n", argument);
			return false;
		}
	}

	if (gLoadFile[0])
	{
		if (!LoadCheckpointMeta(gLoadFile))
			return false;
	}

	// Autotune default ON for puzzle 140 / large pubkey solves when DP unset
	bool large_solve = !gPubKey.x.IsZero() && (gPuzzle == 140 || gRange >= 120);
	if (!gAutoTuneSet && large_solve)
		gAutoTune = true;

	if (!gPubKey.x.IsZero())
	{
		if (!gStartSet || !gRange)
		{
			printf("error: you must specify -dp/-range/-start (or -puzzle 140) with -pubkey\r\n");
			return false;
		}
		// DP may come from autotune later if unset
		if (!gDP && !gAutoTune)
		{
			printf("error: specify -dp or enable -autotune\r\n");
			return false;
		}
	}
	if (gTamesFileName[0] && !IsFileExist(gTamesFileName))
	{
		if (gMax == 0.0)
		{
			printf("error: you must also specify -max option to generate tames\r\n");
			return false;
		}
		gGenMode = true;
	}
	if (gCheckpointHours > 0 && !gSaveFile[0])
		strncpy(gSaveFile, "checkpoint.rck", sizeof(gSaveFile) - 1);
	return true;
}

int main(int argc, char* argv[])
{
#ifdef _DEBUG	
	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif

	printf("********************************************************************************\r\n");
	printf("*           RCKangaroo %s  (c) 2024 RetiredCoder + P140 fork        *\r\n", RCK_FORK_VERSION);
	printf("********************************************************************************\r\n\r\n");

	printf("This software is free and open-source: https://github.com/RetiredC\r\n");
	printf("It demonstrates fast GPU implementation of SOTA Kangaroo method for solving ECDLP\r\n");

#ifdef _WIN32
	printf("Windows version\r\n");
	SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE);
#else
	printf("Linux version\r\n");
	signal(SIGINT, UnixSignalHandler);
	signal(SIGTERM, UnixSignalHandler);
#endif

#ifdef DEBUG_MODE
	printf("DEBUG MODE\r\n\r\n");
#endif

	InitEc();
	NetHerd_InitDefaults(&gNetHerd);
	EntropyConfig_Defaults(&gEntropy);
	gDP = 0;
	gRange = 0;
	gStartSet = false;
	gTamesFileName[0] = 0;
	gMax = 0.0;
	gGenMode = false;
	gIsOpsLimit = false;
	memset(gGPUs_Mask, 1, sizeof(gGPUs_Mask));
	if (!ParseCommandLine(argc, argv))
		return 0;

	// Default: VarianceForge + DualLane + StreamTrio/L2Pin/WarpDP on with autotune
	if (!gVarianceForgeSet && gAutoTune)
		gVarianceForge = true;
	if (!gDualLaneSet)
		gDualLane = true;
	if (!gStreamTrioSet)
		gStreamTrio = true;
	if (!gL2PinSet)
		gL2Pin = true;
	if (!gWarpDPSet)
		gWarpDP = true;
	if (!gFoundShieldSet)
		gFoundShield = true;
	if (!gFalseDawnSet)
		gFalseDawn = true;
	if (!gSlipstreamSet)
		gSlipstream = gFoundShield; // Slipstream accompanies FoundShield by default
	if (!gJumpDNASet && gAutoTune)
		gJumpDNA = false; // opt-in; RUN bats enable explicitly
	PocketRadar_Defaults(&gPocketCfg);
	Inventions_Banner();

	// CPU-only / advise modes (no GPU required)
	if (gMode == MODE_ADVISE || gAdvise)
	{
		ModeAdvisorResult adv;
		double host_ram = GetSystemRamGB();
		double vram = 0;
		char gname[256] = "unknown";
		int sm_maj = 0, sm_min = 0;
		int gcnt = 0;
		cudaGetDeviceCount(&gcnt);
		if (gcnt > 0)
		{
			cudaDeviceProp dp;
			cudaGetDeviceProperties(&dp, 0);
			strncpy(gname, dp.name, sizeof(gname) - 1);
			vram = (double)dp.totalGlobalMem / (1024.0 * 1024.0 * 1024.0);
			sm_maj = dp.major; sm_min = dp.minor;
		}
		ModeAdvisor_Run(host_ram, vram, gname, sm_maj, sm_min, &adv);
		ModeAdvisor_Print(&adv);
		DeInitEc();
		return 0;
	}
	if (gMode == MODE_FLEETHIVE || gFleetHive)
	{
		RunFleetHive();
		DeInitEc();
		return 0;
	}
	if (gMode == MODE_BONEYARD || gBoneyard)
	{
		int rc = RunBoneYard();
		DeInitEc();
		return rc;
	}
	if (gMode == MODE_SEEDORACLE)
	{
		RunSeedOracle140(gSideMaxCand);
		DeInitEc();
		return 0;
	}
	if (gMode == MODE_ROSETTA)
	{
		RunPuzzleRosetta(gSideMaxCand);
		DeInitEc();
		return 0;
	}
	if (gMode == MODE_DELTACRYSTAL)
	{
		RunDeltaCrystal(&gLinkResult);
		DeInitEc();
		return 0;
	}
	if (gMode == MODE_MEMPOOLGHOST)
	{
		RunMempoolGhost(gSideMaxCand ? gSideMaxCand : 1500);
		DeInitEc();
		return 0;
	}
	if (gMode == MODE_BUDGET || gBudget)
	{
		RunEntropyBudgeter(true);
		DeInitEc();
		return 0;
	}
	if (gMode == MODE_NETHERD || gNetHerdDemo)
	{
		int rc = RunNetHerdDemo();
		DeInitEc();
		return rc;
	}
	if (gMode == MODE_ISOPATH)
	{
		int rc = RunIsoPathProbe();
		DeInitEc();
		return rc;
	}
	if (gMode == MODE_QUASIRHO)
	{
		RunQuasiRho(gModM, gModR);
		DeInitEc();
		return 0;
	}
	// ---- 3.6 echo-modes (finite runners) ----
	if (gMode == MODE_ECHOCHAMBER) { RunEchoChamber(gSideMaxCand); DeInitEc(); return 0; }
	if (gMode == MODE_SHADOWLEDGER) { RunShadowLedger(gShadowMod, gSideMaxCand); DeInitEc(); return 0; }
	if (gMode == MODE_KEYHOLESAW) { RunKeyholeSaw(gSideMaxCand ? gSideMaxCand : 64); DeInitEc(); return 0; }
	if (gMode == MODE_CHOIR) { RunPuzzleChoir(gSideMaxCand); DeInitEc(); return 0; }
	if (gMode == MODE_CLOCKWORK) { RunClockworkLie(gSideMaxCand); DeInitEc(); return 0; }
	if (gMode == MODE_HEIRLOOM) { RunHeirloomChain(gSideMaxCand); DeInitEc(); return 0; }
	if (gMode == MODE_GLASSCANNON) { RunGlassCannon(gSideMaxCand ? gSideMaxCand : 4); DeInitEc(); return 0; }
	if (gMode == MODE_SILENTAUCTION) { RunSilentAuction(gSideMaxCand ? gSideMaxCand : 8); DeInitEc(); return 0; }
	if (gMode == MODE_ORACLEMIRAGE) { RunOracleMirage(gSideMaxCand); DeInitEc(); return 0; }
	if (gMode == MODE_PALEONTOLOGY) { RunPaleontology(NULL); DeInitEc(); return 0; }
	if (gMode == MODE_DOPPELGANGER) { RunDoppelganger(gSideMaxCand); DeInitEc(); return 0; }
	if (gMode == MODE_DRIFTCOMPASS) { RunDriftCompassDemo(gSideMaxCand ? gSideMaxCand : 24); DeInitEc(); return 0; }
	if (gMode == MODE_TWINFLAME) { RunTwinFlame(gSideMaxCand); DeInitEc(); return 0; }
	if (gMode == MODE_AFTERIMAGE) { RunAfterimageDemo(gSideMaxCand ? gSideMaxCand : 100); DeInitEc(); return 0; }
	if (gMode == MODE_CLAIMPREDATOR) { RunClaimPredator(gSideMaxCand ? gSideMaxCand : 500); DeInitEc(); return 0; }
	if (gMode == MODE_DREAMREPLAY) { RunDreamReplay(gSideMaxCand ? gSideMaxCand : 40); DeInitEc(); return 0; }
	if (gMode == MODE_SYMMETRYPOISON) { RunSymmetryPoison(gSideMaxCand ? gSideMaxCand : 32); DeInitEc(); return 0; }
	if (gMode == MODE_BREADCRUMB) { RunBreadcrumbMosaic(gSideMaxCand); DeInitEc(); return 0; }
	if (gMode == MODE_QUANTUMFANFIC) { RunQuantumFanfic(gSideMaxCand ? gSideMaxCand : 8); DeInitEc(); return 0; }
	if (gMode == MODE_DREAMTIME) { RunDreamtimeWalk(gSideMaxCand); DeInitEc(); return 0; }
	if (gMode == MODE_MOBIUS) { RunMobiusHerd(); DeInitEc(); return 0; }
	if (gMode == MODE_NEGENTROPY) { RunNegentropyBudget(gSideMaxCand ? gSideMaxCand : 30); DeInitEc(); return 0; }
	if (gMode == MODE_CAGEMATCH) { RunCageMatch(gSideMaxCand ? gSideMaxCand : 16); DeInitEc(); return 0; }
	if (gMode == MODE_STOWAWAY) { RunStowaway(); DeInitEc(); return 0; }
	if (gMode == MODE_APOCALYPSE) { RunApocalypseSave(gSaveFile[0] ? gSaveFile : "checkpoint_p140.rck"); DeInitEc(); return 0; }
	// Flag-only without -mode: finite demos unless -max / kangaroo run requested
	if (gMode == MODE_SOTA && gMax <= 0.0 && !gGenMode)
	{
		bool echo_flag = gEchoChamber || gShadowLedger || gKeyholeSaw || gTwinFlame || gAfterimage
			|| gClaimPredator || gDreamReplay || gSymmetryPoison || gBreadcrumb || gQuantumFanfic
			|| gDreamtime || gMobius || gNegentropy || gCageMatch || gStowaway || gApocalypse || gDriftCompass;
		if (echo_flag)
		{
			if (gEchoChamber) { RunEchoChamber(gSideMaxCand); DeInitEc(); return 0; }
			if (gShadowLedger) { RunShadowLedger(gShadowMod, gSideMaxCand); DeInitEc(); return 0; }
			if (gKeyholeSaw) { RunKeyholeSaw(gSideMaxCand ? gSideMaxCand : 64); DeInitEc(); return 0; }
			if (gTwinFlame) { RunTwinFlame(gSideMaxCand); DeInitEc(); return 0; }
			if (gAfterimage) { RunAfterimageDemo(gSideMaxCand ? gSideMaxCand : 100); DeInitEc(); return 0; }
			if (gClaimPredator) { RunClaimPredator(gSideMaxCand ? gSideMaxCand : 500); DeInitEc(); return 0; }
			if (gDreamReplay) { RunDreamReplay(gSideMaxCand ? gSideMaxCand : 40); DeInitEc(); return 0; }
			if (gSymmetryPoison) { RunSymmetryPoison(gSideMaxCand ? gSideMaxCand : 32); DeInitEc(); return 0; }
			if (gBreadcrumb) { RunBreadcrumbMosaic(gSideMaxCand); DeInitEc(); return 0; }
			if (gQuantumFanfic) { RunQuantumFanfic(gSideMaxCand ? gSideMaxCand : 8); DeInitEc(); return 0; }
			if (gDreamtime) { RunDreamtimeWalk(gSideMaxCand); DeInitEc(); return 0; }
			if (gMobius) { RunMobiusHerd(); DeInitEc(); return 0; }
			if (gNegentropy) { RunNegentropyBudget(gSideMaxCand ? gSideMaxCand : 30); DeInitEc(); return 0; }
			if (gCageMatch) { RunCageMatch(gSideMaxCand ? gSideMaxCand : 16); DeInitEc(); return 0; }
			if (gStowaway) { RunStowaway(); DeInitEc(); return 0; }
			if (gApocalypse) { RunApocalypseSave(gSaveFile[0] ? gSaveFile : "checkpoint_p140.rck"); DeInitEc(); return 0; }
			if (gDriftCompass) { RunDriftCompassDemo(gSideMaxCand ? gSideMaxCand : 24); DeInitEc(); return 0; }
		}
	}
	if (gMode == MODE_ENTROPY)
	{
		RunEntropy140(&gEntropy);
		DeInitEc();
		return 0;
	}
	if (gMode == MODE_LINK)
	{
		RunLinkSolve(&gLinkResult);
		DeInitEc();
		return 0;
	}
	if (gMode == MODE_ARCHAEOLOGY)
	{
		RunArchaeology();
		DeInitEc();
		return 0;
	}
	if (gMode == MODE_HDLATTICE)
	{
		RunHDLattice(gSideMaxCand);
		DeInitEc();
		return 0;
	}
	if (gMode == MODE_KEYDELTA)
	{
		RunKeyDelta(&gLinkResult);
		DeInitEc();
		return 0;
	}
	if (gMode == MODE_PRNG)
	{
		RunPRNGMuseum(gSideMaxCand);
		DeInitEc();
		return 0;
	}
	if (gMode == MODE_PATTERN)
	{
		RunPatternHunt(gSideMaxCand);
		DeInitEc();
		return 0;
	}
	if (gMode == MODE_POCKET || gPocketRadar)
	{
		int rb = gRange_user_set ? (int)gRange : PUZZLE140_RANGE;
		PocketRadar_Run(&gPocketCfg, rb);
		if (gModFan)
			ModFan_Plan((u64)gModFan, gModM, gModR);
		DeInitEc();
		return 0;
	}
	if (gGaudry)
	{
		if (gLinkResult.count == 0)
			RunKeyDelta(&gLinkResult);
		GaudryLite_FromLink(&gLinkResult, &gGaudryBox);
		GaudryLite_Print(&gGaudryBox);
		// fall through to GPU if pubkey set, else exit
		if (gPubKey.x.IsZero() && gMode != MODE_SOTA && gMode != MODE_LOTTERY && gMode != MODE_HYBRID)
		{
			DeInitEc();
			return 0;
		}
	}
	if (gModFan && gMode != MODE_POCKET)
		ModFan_Plan((u64)gModFan, gModM, gModR);

	// Standalone SilentNetHerd (no pubkey): server listen or worker HELLO
	if (gNetHerd.enabled && gPubKey.x.IsZero() && gMode == MODE_SOTA && !gGenMode)
	{
		gNetHerd.role = gNetHerdRole;
		if (gNetHerd.is_server)
		{
			gNetHerd.demo = true;
			if (gSideMaxCand > 0 && gSideMaxCand < 600000)
				gNetHerd.demo_timeout_ms = (int)gSideMaxCand;
			else
				gNetHerd.demo_timeout_ms = 20000;
			if (!NetHerd_Start(&gNetHerd))
			{
				DeInitEc();
				return 1;
			}
			printf("NetHerd server running %d ms (Ctrl+C may not interrupt sleep; wait for timeout)...\r\n",
				gNetHerd.demo_timeout_ms);
			Sleep(gNetHerd.demo_timeout_ms + 300);
			NetHerd_Stop();
			DeInitEc();
			return 0;
		}
		else
		{
			int rc = NetHerd_WorkerHelloOnce(gNetHerd.host, gNetHerd.port, gNetHerdRole);
			DeInitEc();
			return rc;
		}
	}

	if (gMode == MODE_HYBRID)
	{
		printf("Hybrid mode: BSGS warm-up then SOTA handoff.\r\n");
		if (gPubKey.x.IsZero())
		{
			ApplyPuzzle(140);
		}
		EcPoint PntToSolve = gPubKey;
		if (!gStart.IsZero())
		{
			EcPoint PntOfs = ec.MultiplyG(gStart);
			PntOfs.y.NegModP();
			PntToSolve = ec.AddPoints(PntToSolve, PntOfs);
		}
		EcInt hint;
		HybridBSGS_Warmup(PntToSolve, gRange ? (int)gRange : 134, 1ull << 16, &hint);
		gMode = MODE_SOTA;
		printf("Continuing with SOTA kangaroo...\r\n");
	}

	InitGpus();

	if (!GpuCnt)
	{
		printf("No supported GPUs detected, exit\r\n");
		return 0;
	}

	if (gLoadFile[0])
	{
		if (!LoadCheckpointGpus(gLoadFile))
		{
			printf("FATAL: failed to load kangaroo states\r\n");
			return 0;
		}
	}

	// Autotune after GPUs known (do not override grid if resuming checkpoint)
	if (gAutoTune || !gDP)
	{
		int gi = GpuKangs[0]->CudaIndex;
		AutoTuneConfig(gi, gRange ? (int)gRange : 134, gProfile[0] ? gProfile : NULL,
			gDP_user_set ? (int)gDP : 0, gRamLimitGB, &gTune);
		PrintAutoTune(&gTune);
		if (!gDP_user_set)
			gDP = gTune.dp;
		if (gRamLimitGB <= 0)
			gRamLimitGB = gTune.ramlimit_gb;
		if (!gLoadCheckpoint)
		{
			for (int i = 0; i < GpuCnt; i++)
			{
				GpuKangs[i]->IsOldGpu = gTune.old_gpu_mode;
				GpuKangs[i]->OverrideBlockSize = gTune.block_size;
				GpuKangs[i]->OverrideGroupCnt = gTune.group_cnt;
			}
		}
	}

	if (gNetHerd.enabled)
		NetHerd_Start(&gNetHerd);

	pPntList = (u8*)malloc(MAX_CNT_LIST * GPU_DP_SIZE);
	pPntList2 = (u8*)malloc(MAX_CNT_LIST * GPU_DP_SIZE);
	TotalOps = 0;
	TotalSolved = 0;
	gTotalErrors = 0;
	IsBench = gPubKey.x.IsZero();

	if (!IsBench && !gGenMode)
	{
		printf("\r\nMAIN MODE (%s)\r\n\r\n",
			gMode == MODE_LOTTERY ? "lottery" : "sota");
		EcPoint PntToSolve, PntOfs;
		EcInt pk, pk_found;

		PntToSolve = gPubKey;
		if (!gStart.IsZero())
		{
			PntOfs = ec.MultiplyG(gStart);
			PntOfs.y.NegModP();
			PntToSolve = ec.AddPoints(PntToSolve, PntOfs);
		}

		char sx[100], sy[100];
		gPubKey.x.GetHexStr(sx);
		gPubKey.y.GetHexStr(sy);
		printf("Solving public key\r\nX: %s\r\nY: %s\r\n", sx, sy);
		gStart.GetHexStr(sx);
		printf("Offset: %s\r\n", sx);
		if (gModUserSet && gModM)
			printf("Link residue hint: k ≡ %llu (mod %llu) [host filter not yet hard-wired into kernel]\r\n",
				(unsigned long long)gModR, (unsigned long long)gModM);

		bool ok = false;
		if (gMode == MODE_LOTTERY)
			ok = SolveLotteryHerd(PntToSolve, gRange, gDP, &pk_found);
		else
			ok = SolvePoint(PntToSolve, gRange, gDP, &pk_found);

		if (!ok)
		{
			if (!gIsOpsLimit && !gStopRequested)
				printf("FATAL ERROR: SolvePoint failed\r\n");
			goto label_end;
		}
		pk_found.AddModP(gStart);
		EcPoint tmp = ec.MultiplyG(pk_found);
		if (!tmp.IsEqual(gPubKey))
		{
			printf("FATAL ERROR: SolvePoint found incorrect key\r\n");
			goto label_end;
		}
		char s[100];
		pk_found.GetHexStr(s);
		printf("\r\nPRIVATE KEY: %s\r\n\r\n", s);
		bool skip_results = false;
		Invention_OnHit(s, gPubKey, pk_found, gFalseDawn, gFoundShield, gSlipstream, gDarkRoom, &skip_results);
		if (!skip_results)
		{
			FILE* fp = fopen("RESULTS.TXT", "a");
			if (fp)
			{
				fprintf(fp, "PRIVATE KEY: %s\n", s);
				fclose(fp);
			}
			else
			{
				printf("WARNING: Cannot save the key to RESULTS.TXT!\r\n");
				while (1)
					Sleep(100);
			}
		}
		else
			printf("DarkRoom: skipped plaintext RESULTS.TXT\r\n");
	}
	else
	{
		if (gGenMode)
			printf("\r\nTAMES GENERATION MODE\r\n");
		else if (gMode == MODE_LOTTERY)
			printf("\r\nBENCHMARK + LOTTERYHERD MODE\r\n");
		else
			printf("\r\nBENCHMARK MODE\r\n");
		while (1)
		{
			EcInt pk, pk_found;
			EcPoint PntToSolve;

			if (!gRange)
				gRange = 78;
			if (!gDP)
				gDP = 16;

			pk.RndBits(gRange);
			PntToSolve = ec.MultiplyG(pk);

			bool ok;
			if (gMode == MODE_LOTTERY)
				ok = SolveLotteryHerd(PntToSolve, gRange, gDP, &pk_found);
			else
				ok = SolvePoint(PntToSolve, gRange, gDP, &pk_found);

			if (!ok)
			{
				if (!gIsOpsLimit && !gStopRequested)
					printf("FATAL ERROR: SolvePoint failed\r\n");
				break;
			}
			if (!pk_found.IsEqual(pk))
			{
				printf("FATAL ERROR: Found key is wrong!\r\n");
				break;
			}
			TotalOps += PntTotalOps;
			TotalSolved++;
			u64 ops_per_pnt = TotalOps / TotalSolved;
			double K = (double)ops_per_pnt / pow(2.0, gRange / 2.0);
			printf("Points solved: %d, average K: %.3f (with DP and GPU overheads)\r\n", TotalSolved, K);
			if (gMode == MODE_LOTTERY)
				break; // one lottery herd per process for smoke / controlled runs
		}
	}
label_end:
	NetHerd_Stop();
	for (int i = 0; i < GpuCnt; i++)
		delete GpuKangs[i];
	DeInitEc();
	free(pPntList2);
	free(pPntList);
}