Solving ECDLP with Kangaroos: Part 1 + 2 + RCKangaroo

[ee1234ee]

how to use it with RTX2070super, please, because I only have 2070, I am very interested in testing your work. I tried modifying the parameter settings but it failed.

As far as I remember these cards have only 64KB of shared memory.
Set JMP_CNT to 512 and change 17 to 16 in this line in KernelB:
u64* table = LDS + 8 * JMP_CNT + 17 * THREAD_X;
and recalculate LDS_SIZE_ constants.
I think it's enough, though may be I forgot something...
The main issue is not in compiling, but in optimizations, my code is not for 20xx and 30xx cards, so it won't work with good speed there.
That's why I don't want to support old cards: if I support them officially but not optimize you will blame me that they have bad speed.
But feel free to modify/optimize sources for your hardware

May I ask why, my 4060ti graphics card has a speed of just over 2000



CUDA devices: 1, CUDA driver/runtime: 12.6/12.5
GPU 0: NVIDIA GeForce RTX 4060 Ti, 16.00 GB, 34 CUs, cap 8.9, PCI 1, L2 size: 32768 KB
Total GPUs for work: 1
Solving point: Range 76 bits, DP 16, start...
SOTA method, estimated ops: 2^38.202, RAM for DPs: 0.367 GB. DP and GPU overheads not included!
Estimated DPs per kangaroo: 23.090.
GPU 0: allocated 1187 MB, 208896 kangaroos.
GPUs started...
MAIN: Speed: 2332 MKeys/s, Err: 0, DPs: 345K/4823K, Time: 0d:00h:00m, Est: 0d:00h:02m
MAIN: Speed: 2320 MKeys/s, Err: 0, DPs: 704K/4823K, Time: 0d:00h:00m, Est: 0d:00h:02m

[makekang]

how to use it with RTX2070super, please, because I only have 2070, I am very interested in testing your work. I tried modifying the parameter settings but it failed.

As far as I remember these cards have only 64KB of shared memory.
Set JMP_CNT to 512 and change 17 to 16 in this line in KernelB:
u64* table = LDS + 8 * JMP_CNT + 17 * THREAD_X;
and recalculate LDS_SIZE_ constants.
I think it's enough, though may be I forgot something...
The main issue is not in compiling, but in optimizations, my code is not for 20xx and 30xx cards, so it won't work with good speed there.
That's why I don't want to support old cards: if I support them officially but not optimize you will blame me that they have bad speed.
But feel free to modify/optimize sources for your hardware

Thank you very much. Following your suggestion, I modified LDS_SIZE_ constants and successfully ran it perfectly on my 2070. Thanks again for your artistic work. By comparing the test, it is faster to find the private key than JLP's code. Next, I will try to understand your code and optimize it with the help of Claude 3.5 to increase the speed. Maybe you have more good suggestions.

[MrGPBit]

@Etar how did you do everything to make your GTX 1660 work? Can you tell me all the changes and show me them? Many thanks

file: RCGpuCore.cu
line 285: u64* table = LDS + 8 * JMP_CNT + 16 * THREAD_X;
Line 99: if (deviceProp.major < 6)
file: defs.h
#define LDS_SIZE_A         (64 * 1024)
#define LDS_SIZE_B         (64 * 1024)
#define LDS_SIZE_C         (64 * 1024)
#define JMP_CNT            512
file: RCKangaroo.vcxproj
line 118: <CodeGeneration>compute_75,sm_75;compute_75,sm_75</CodeGeneration>
line 141: <CodeGeneration>compute_75,sm_75;compute_75,sm_75</CodeGeneration>

Code:

CUDA devices: 1, CUDA driver/runtime: 12.6/12.1
GPU 0: NVIDIA GeForce GTX 1660 SUPER, 6.00 GB, 22 CUs, cap 7.5, PCI 1, L2 size: 1536 KB
Total GPUs for work: 1

MAIN MODE

Solving public key
X: 29C4574A4FD8C810B7E42A4B398882B381BCD85E40C6883712912D167C83E73A
Y: 0E02C3AFD79913AB0961C95F12498F36A72FFA35C93AF27CEE30010FA6B51C53
Offset: 0000000000000000000000000000000000000000001000000000000000000000

Solving point: Range 84 bits, DP 16, start...
SOTA method, estimated ops: 2^42.202, RAM for DPs: 3.062 GB. DP and GPU overheads not included!
Estimated DPs per kangaroo: 570.958.
GPU 0: allocated 772 MB, 135168 kangaroos.
GPUs started...
MAIN: Speed: 599 MKeys/s, Err: 0, DPs: 88K/77175K, Time: 0d:00h:00m:10s, Est: 0d:02h:20m:43s

file: RCGpuCore.cu
Line 99 looks like this
SubModP(tmp, x, jmp_x);

If you replace it with
if (deviceProp.major < 6)

This error occurs when creating:
RCGpuCore.cu(99): error: identifier "deviceProp" is undefined
     if (deviceProp.major < 6)
         ^

1 error detected in the compilation of "RCGpuCore.cu".
make: *** [Makefile:26: RCGpuCore.o] Error 2

Did you make a mistake?

Thank you for your effort

[Etar]

Did you make a mistake?

I use visual studio. Oh, sorry it is in file RCKangaroo.cpp line 99 (changed previous post)

Code:

if (deviceProp.major < 6)
{
			printf("GPU %d - not supported, skip\r\n", i);
			continue;
}

I also made other changes, which is probably why the line numbers don't match. But you can easily find the lines you need, because I didn't add anything new, I just changed it.

[RetiredCoder]

That's why I don't want to support old cards: if I support them officially but not optimize you will blame me that they have bad speed.
But feel free to modify/optimize sources for your hardware

I'll be honest, your kangaroo finds the key faster than mine or jlp. Yes, the speed shows less, but in the end it finds it much faster.
Works even on 1660 super (~600Mkeys/s).
Thanks for sharing.

You can improve it in many ways.
For example, since L2 is useless for old cards, disable setting persistent part of L2 and set
#define PNT_GROUP_CNT      32
and change these lines in KernelB:

Code:

		//calc original kang_ind
		u32 tind = (THREAD_X + gr_ind2 * BLOCK_SIZE); //0..3071
		u32 warp_ind = tind / (32 * PNT_GROUP_CNT / 2); // 0..7	
		u32 thr_ind = (tind / 4) % 32; //index in warp 0..31
		u32 g8_ind = (tind % (32 * PNT_GROUP_CNT / 2)) / 128; // 0..2
		u32 gr_ind = 2 * (tind % 4); // 0, 2, 4, 6

May I ask why, my 4060ti graphics card has a speed of just over 2000
CUDA devices: 1, CUDA driver/runtime: 12.6/12.5
GPU 0: NVIDIA GeForce RTX 4060 Ti, 16.00 GB, 34 CUs, cap 8.9, PCI 1, L2 size: 32768 KB
Total GPUs for work: 1
Solving point: Range 76 bits, DP 16, start...
SOTA method, estimated ops: 2^38.202, RAM for DPs: 0.367 GB. DP and GPU overheads not included!
Estimated DPs per kangaroo: 23.090.
GPU 0: allocated 1187 MB, 208896 kangaroos.
GPUs started...
MAIN: Speed: 2332 MKeys/s, Err: 0, DPs: 345K/4823K, Time: 0d:00h:00m, Est: 0d:00h:02m
MAIN: Speed: 2320 MKeys/s, Err: 0, DPs: 704K/4823K, Time: 0d:00h:00m, Est: 0d:00h:02m

Do you expect better speed? Why? 4090 has 128 CUs, 4060ti only 34.

[MrGPBit]

That's why I don't want to support old cards: if I support them officially but not optimize you will blame me that they have bad speed.
But feel free to modify/optimize sources for your hardware

I'll be honest, your kangaroo finds the key faster than mine or jlp. Yes, the speed shows less, but in the end it finds it much faster.
Works even on 1660 super (~600Mkeys/s).
Thanks for sharing.

You can improve it in many ways.
For example, since L2 is useless for old cards, disable setting persistent part of L2 and set
#define PNT_GROUP_CNT      48
and change these lines in KernelB:

Code:

		//calc original kang_ind
		u32 tind = (THREAD_X + gr_ind2 * BLOCK_SIZE); //0..3071
		u32 warp_ind = tind / (32 * PNT_GROUP_CNT / 2); // 0..7	
		u32 thr_ind = (tind / 4) % 32; //index in warp 0..31
		u32 g8_ind = (tind % (32 * PNT_GROUP_CNT / 2)) / 128; // 0..2
		u32 gr_ind = 2 * (tind % 4); // 0, 2, 4, 6

May I ask why, my 4060ti graphics card has a speed of just over 2000
CUDA devices: 1, CUDA driver/runtime: 12.6/12.5
GPU 0: NVIDIA GeForce RTX 4060 Ti, 16.00 GB, 34 CUs, cap 8.9, PCI 1, L2 size: 32768 KB
Total GPUs for work: 1
Solving point: Range 76 bits, DP 16, start...
SOTA method, estimated ops: 2^38.202, RAM for DPs: 0.367 GB. DP and GPU overheads not included!
Estimated DPs per kangaroo: 23.090.
GPU 0: allocated 1187 MB, 208896 kangaroos.
GPUs started...
MAIN: Speed: 2332 MKeys/s, Err: 0, DPs: 345K/4823K, Time: 0d:00h:00m, Est: 0d:00h:02m
MAIN: Speed: 2320 MKeys/s, Err: 0, DPs: 704K/4823K, Time: 0d:00h:00m, Est: 0d:00h:02m

Do you expect better speed? Why? 4090 has 128 CUs, 4060ti only 34.

Hello, can you tell me in which file you can find L2 and what you have to deactivate?
Thank you

I found it GpuKang.cpp that
Is that right there?

//allocate gpu mem
   //L2   
   int L2size = KangCnt * (3 * 32);
   total_mem += L2size;
   err = cudaMalloc((void**)&Kparams.L2, L2size);
   if (err != cudaSuccess)
   {
      printf("GPU %d, Allocate L2 memory failed: %s\n", CudaIndex, cudaGetErrorString(err));
      return false;
   }

[RetiredCoder]

Hello, can you tell me in which file you can find L2 and what you have to deactivate?
Thank you
I found it GpuKang.cpp that
Is that right there?

No, it's "cudaStreamSetAttribute".
Be careful with modifications if you don't know what you are doing exactly. The algorithm is not so straight as the classic one, for example, if you damage loop handling it will work for small ranges but fail for high ranges.

[ee1234ee]

No, it's "cudaStreamSetAttribute".
Be careful with modifications if you don't know what you are doing exactly. The algorithm is not so straight as the classic one, for example, if you damage loop handling it will work for small ranges but fail for high ranges.

Discovered a problem
I didn't modify your source code, I ran it directly using the program you compiled
However, after running for a period of time, a large number of errors occurred.

DPs buffer overflow，some points lost, increase DP value!
DPs buffer overflow，some points lost, increase DP value!
DPs buffer overflow，some points lost, increase DP value!

At the beginning, it was normal, but the error message above kept appearing. May I ask why?

[RetiredCoder]

Discovered a problem
I didn't modify your source code, I ran it directly using the program you compiled
However, after running for a period of time, a large number of errors occurred.
DPs buffer overflow，some points lost, increase DP value!
DPs buffer overflow，some points lost, increase DP value!
DPs buffer overflow，some points lost, increase DP value!
At the beginning, it was normal, but the error message above kept appearing. May I ask why?

Yes, if parameters are not optimal, in some cases it will show you a warning.
In this case you should increase "-dp" option value, DB is growing and CPU cannot add so many DPs every second.

[Lolo54]

Hello would anyone be able to adapt it to RTX 20xx series and compile it for windows?

[RetiredCoder]

Hello would anyone be able to adapt it to RTX 20xx series and compile it for windows?

Yes, some people already took my code optimized for 40xx, compiled it on 1xxx/20xx/30xx and said that it's slow, completely unexpected behavior
However, you can find instructions how to compile in this thread.

[b0dre]

Hello would anyone be able to adapt it to RTX 20xx series and compile it for windows?

Yes, some people already took my code optimized for 40xx, compiled it on 1xxx/20xx/30xx and said that it's slow, completely unexpected behavior
However, you can find instructions how to compile in this thread.

I really appreciate it. I prioritize faster results over raw speed, as they are not the same thing.
Thks

[whanau]

I am trying to get the code to run on my humble GEFORCE 1060
I have made etar's modifications and get this.
CUDA devices: 1, CUDA driver/runtime: 12.2/12.0
GPU 0: NVIDIA GeForce GTX 1060 6GB, 5.93 GB, 10 CUs, cap 6.1, PCI 83, L2 size: 1536 KB
Total GPUs for work: 1

BENCHMARK MODE

Solving point: Range 78 bits, DP 16, start...
SOTA method, estimated ops: 2^39.202, RAM for DPs: 0.547 GB. DP and GPU overheads not included!
Estimated DPs per kangaroo: 157.013.
GPU 0, cuSetGpuParams failed: invalid argument!
GPU 0 Prepare failed
GPUs started...
BENCH: Speed: 125829 MKeys/s, Err: 0, DPs: 0K/9646K, Time: 0d:00h:00m, Est: 0d:00h:00m

How can I fix the GPU 0, cuSetGpuParams failed: invalid argument! error?

Thank you.

[hskun]

I appreciate it for your great work!
It work fine for my A3000 and it more faster than JPL about 30%!
Will you work for the client/server version the next step?
Thanks.

Code:

CUDA devices: 1, CUDA driver/runtime: 12.5/12.5
GPU 0: NVIDIA RTX A3000 Laptop GPU, 5.70 GB, 32 CUs, cap 8.6, PCI 1, L2 size: 3072 KB
Total GPUs for work: 1

MAIN MODE

Solving public key
X: 145D2611C823A396EF6712CE0F712F09B9B4F3135E3E0AA3230FB9B6D08D1E16
Y: 667A05E9A1BDD6F70142B66558BD12CE2C0F9CBC7001B20C8A6A109C80DC5330
Offset: 0000000000000000000000000000004000000000000000000000000000000000

Solving point: Range 135 bits, DP 16, start...
SOTA method, estimated ops: 2^67.202, RAM for DPs: 96468992.188 GB. DP and GPU overheads not included!
Estimated DPs per kangaroo: 13171233041.067.
GPU 0: allocated 1118 MB, 196608 kangaroos.
GPUs started...
MAIN: Speed: 969 MKeys/s, Err: 0, DPs: 141K/2589569785738K, Time: 0d:00h:00m, Est: 2027075d:23h:50m
MAIN: Speed: 959 MKeys/s, Err: 0, DPs: 288K/2589569785738K, Time: 0d:00h:00m, Est: 2048213d:09h:16m
MAIN: Speed: 957 MKeys/s, Err: 0, DPs: 435K/2589569785738K, Time: 0d:00h:00m, Est: 2052493d:20h:58m
MAIN: Speed: 957 MKeys/s, Err: 0, DPs: 582K/2589569785738K, Time: 0d:00h:00m, Est: 2052493d:20h:58m
MAIN: Speed: 955 MKeys/s, Err: 0, DPs: 724K/2589569785738K, Time: 0d:00h:00m, Est: 2056792d:06h:58m
MAIN: Speed: 955 MKeys/s, Err: 0, DPs: 871K/2589569785738K, Time: 0d:00h:01m, Est: 2056792d:06h:58m
MAIN: Speed: 954 MKeys/s, Err: 0, DPs: 1018K/2589569785738K, Time: 0d:00h:01m, Est: 2058948d:06h:10m

[COBRAS]

I appreciate it for your great work!
It work fine for my A3000 and it more faster than JPL about 30%!
Will you work for the client/server version the next step?
Thanks.

Code:

CUDA devices: 1, CUDA driver/runtime: 12.5/12.5
GPU 0: NVIDIA RTX A3000 Laptop GPU, 5.70 GB, 32 CUs, cap 8.6, PCI 1, L2 size: 3072 KB
Total GPUs for work: 1

MAIN MODE

Solving public key
X: 145D2611C823A396EF6712CE0F712F09B9B4F3135E3E0AA3230FB9B6D08D1E16
Y: 667A05E9A1BDD6F70142B66558BD12CE2C0F9CBC7001B20C8A6A109C80DC5330
Offset: 0000000000000000000000000000004000000000000000000000000000000000

Solving point: Range 135 bits, DP 16, start...
SOTA method, estimated ops: 2^67.202, RAM for DPs: 96468992.188 GB. DP and GPU overheads not included!
Estimated DPs per kangaroo: 13171233041.067.
GPU 0: allocated 1118 MB, 196608 kangaroos.
GPUs started...
MAIN: Speed: 969 MKeys/s, Err: 0, DPs: 141K/2589569785738K, Time: 0d:00h:00m, Est: 2027075d:23h:50m
MAIN: Speed: 959 MKeys/s, Err: 0, DPs: 288K/2589569785738K, Time: 0d:00h:00m, Est: 2048213d:09h:16m
MAIN: Speed: 957 MKeys/s, Err: 0, DPs: 435K/2589569785738K, Time: 0d:00h:00m, Est: 2052493d:20h:58m
MAIN: Speed: 957 MKeys/s, Err: 0, DPs: 582K/2589569785738K, Time: 0d:00h:00m, Est: 2052493d:20h:58m
MAIN: Speed: 955 MKeys/s, Err: 0, DPs: 724K/2589569785738K, Time: 0d:00h:00m, Est: 2056792d:06h:58m
MAIN: Speed: 955 MKeys/s, Err: 0, DPs: 871K/2589569785738K, Time: 0d:00h:01m, Est: 2056792d:06h:58m
MAIN: Speed: 954 MKeys/s, Err: 0, DPs: 1018K/2589569785738K, Time: 0d:00h:01m, Est: 2058948d:06h:10m

A3000 slow then 4090

[Hax1337]

Hi all,

first of all thanks for RetiredCoder for his research and work and providing it to the community!

I am new here but followed all the posts already for a while and trying to get my head around it

I got a dumb question, its mentioned the theres no workload tooling, but lets say i have 2 machines I can run, can I split the worklod e.g. as sample take puzzle #85.
Do I just split the range parameter as well as the start point?

[b0dre]

Hi all,

first of all thanks for RetiredCoder for his research and work and providing it to the community!

I am new here but followed all the posts already for a while and trying to get my head around it

I got a dumb question, its mentioned the theres no workload tooling, but lets say i have 2 machines I can run, can I split the worklod e.g. as sample take puzzle #85.
Do I just split the range parameter as well as the start point?

Your question isn’t dumb at all! Yes, if you're running a workload like solving puzzle #85 and have multiple machines to use, splitting the range and start point is a common approach to divide the workload.

How it works:
Range Parameter:
If the puzzle involves iterating over a range of numbers or states, you can split that range across the machines. For instance, if the range is [0, 100], you could let:

Machine 1 handle [0, 49]
Machine 2 handle [50, 100]
Start Point:
If there's a start parameter involved, ensure each machine knows where to begin for its portion of the range.

Independent Processing:
Make sure that each machine can independently process its assigned range without depending on results from the other. This ensures no overlap or missed parts.

Steps to Implement:
Divide the workload logically based on the problem's parameters (e.g., ranges or chunks of input data).
Ensure the start and end points for each machine are mutually exclusive.
If the workload has side effects or shared state, manage synchronization carefully (e.g., use locks or shared memory if needed, or avoid shared state altogether).
Example:
Assuming puzzle #85 involves calculating something over a range [0, 1000]:

On Machine 1, run the code with start=0 and end=499.
On Machine 2, run the code with start=500 and end=1000.
This approach scales well as long as:

The problem is divisible.
The results from one range don’t depend on another range.
Let me know if you'd like more detailed help with setting up the splitting logic!

[Hax1337]

Hi all,

first of all thanks for RetiredCoder for his research and work and providing it to the community!

I am new here but followed all the posts already for a while and trying to get my head around it

I got a dumb question, its mentioned the theres no workload tooling, but lets say i have 2 machines I can run, can I split the worklod e.g. as sample take puzzle #85.
Do I just split the range parameter as well as the start point?

Your question isn’t dumb at all! Yes, if you're running a workload like solving puzzle #85 and have multiple machines to use, splitting the range and start point is a common approach to divide the workload.

How it works:
Range Parameter:
If the puzzle involves iterating over a range of numbers or states, you can split that range across the machines. For instance, if the range is [0, 100], you could let:

Machine 1 handle [0, 49]
Machine 2 handle [50, 100]
Start Point:
If there's a start parameter involved, ensure each machine knows where to begin for its portion of the range.

Independent Processing:
Make sure that each machine can independently process its assigned range without depending on results from the other. This ensures no overlap or missed parts.

Steps to Implement:
Divide the workload logically based on the problem's parameters (e.g., ranges or chunks of input data).
Ensure the start and end points for each machine are mutually exclusive.
If the workload has side effects or shared state, manage synchronization carefully (e.g., use locks or shared memory if needed, or avoid shared state altogether).
Example:
Assuming puzzle #85 involves calculating something over a range [0, 1000]:

On Machine 1, run the code with start=0 and end=499.
On Machine 2, run the code with start=500 and end=1000.
This approach scales well as long as:

The problem is divisible.
The results from one range don’t depend on another range.
Let me know if you'd like more detailed help with setting up the splitting logic!

Thanks for the fast response, and yes maybe I need more clarity on the splitting. I started to get my head around the details just 2 weeks ago and sometimes there comes a lot of questionmarks.

Lets assume with puzzle #81, I got the private key range in 100000000000000000000:1ffffffffffffffffffff

So if I have one machine only I would do:

Code:

RCKangaroo.exe -dp 16 -range 80 -start 100000000000000000000 -pubkey 351e605fac813965951ba433b7c2956bf8ad95ce

And for 2 machines, would I split the range in half, which would be: 17fffffffffffffffffff

Machine 1:

Code:

RCKangaroo.exe -dp 16 -range 80 -start 100000000000000000000 -pubkey 351e605fac813965951ba433b7c2956bf8ad95ce

Machine 2:

Code:

RCKangaroo.exe -dp 16 -range 80 -start 180000000000000000000 -pubkey 351e605fac813965951ba433b7c2956bf8ad95ce

With the range I am not sure about.
I did not find the "END" parameter you mentioned in the RCKangaroo, and im sure it works with the range parameter to determine "the end"

[b0dre]

Hi all,

first of all thanks for RetiredCoder for his research and work and providing it to the community!

I am new here but followed all the posts already for a while and trying to get my head around it

I got a dumb question, its mentioned the theres no workload tooling, but lets say i have 2 machines I can run, can I split the worklod e.g. as sample take puzzle #85.
Do I just split the range parameter as well as the start point?

Your question isn’t dumb at all! Yes, if you're running a workload like solving puzzle #85 and have multiple machines to use, splitting the range and start point is a common approach to divide the workload.

How it works:
Range Parameter:
If the puzzle involves iterating over a range of numbers or states, you can split that range across the machines. For instance, if the range is [0, 100], you could let:

Machine 1 handle [0, 49]
Machine 2 handle [50, 100]
Start Point:
If there's a start parameter involved, ensure each machine knows where to begin for its portion of the range.

Independent Processing:
Make sure that each machine can independently process its assigned range without depending on results from the other. This ensures no overlap or missed parts.

Steps to Implement:
Divide the workload logically based on the problem's parameters (e.g., ranges or chunks of input data).
Ensure the start and end points for each machine are mutually exclusive.
If the workload has side effects or shared state, manage synchronization carefully (e.g., use locks or shared memory if needed, or avoid shared state altogether).
Example:
Assuming puzzle #85 involves calculating something over a range [0, 1000]:

On Machine 1, run the code with start=0 and end=499.
On Machine 2, run the code with start=500 and end=1000.
This approach scales well as long as:

The problem is divisible.
The results from one range don’t depend on another range.
Let me know if you'd like more detailed help with setting up the splitting logic!

Thanks for the fast response, and yes maybe I need more clarity on the splitting. I started to get my head around the details just 2 weeks ago and sometimes there comes a lot of questionmarks.

Lets assume with puzzle #81, I got the private key range in 100000000000000000000:1ffffffffffffffffffff

So if I have one machine only I would do:

Code:

RCKangaroo.exe -dp 16 -range 80 -start 100000000000000000000 -pubkey 351e605fac813965951ba433b7c2956bf8ad95ce

And for 2 machines, would I split the range in half, which would be: 17fffffffffffffffffff

Machine 1:

Code:

RCKangaroo.exe -dp 16 -range 80 -start 100000000000000000000 -pubkey 351e605fac813965951ba433b7c2956bf8ad95ce

Machine 2:

Code:

RCKangaroo.exe -dp 16 -range 80 -start 180000000000000000000 -pubkey 351e605fac813965951ba433b7c2956bf8ad95ce

With the range I am not sure about.
I did not find the "END" parameter you mentioned in the RCKangaroo, and im sure it works with the range parameter to determine "the end"

RCKangaroo supports only the start of the range, but this is not an issue. You can simply split the range into multiple pieces depending on how many machines you have. For example, if the key range is from 100000000000000000000 to 1ffffffffffffffffffff, and you split the range into two parts, it would look like:

Machine 1:

Code:

Start at 100000000000000000000

Machine 2:

Code:

Start at 100800000000000000000

"Don't worry about the end of the range, as some machines will find the key before reaching the end."

PD: You can use AI to create a Python tool that splits the hex range.

[kTimesG]

Whenever I see a post going like "splitting the range is a good idea and not an issue at all" after all the uncountable and obvious proofs to the contrary, I do 50 pushups, to compensate for the 41% extra steps required to solve the same problem in 2 ranges.