First time I got infinite waiting, so restarted and got this error.

$ ./profanity.x64 --matching dead

Mode: matching
Devices:
  GPU0: Intel(R) HD Graphics 630, 1610612736 bytes available, 24 compute units (precompiled = yes)
  GPU1: AMD Radeon Pro 560 Compute Engine, 4294967296 bytes available, 16 compute units (precompiled = yes)

Initializing OpenCL...
  Creating context...OK
  Loading kernel from binary...OK
  Building program...OK

Initializing devices...
  This can take a minute or two. The number of objects initialized on each
  device is equal to inverse-size * inverse-multiple. To lower
  initialization time (and memory footprint) I suggest lowering the
  inverse-multiple first. You can do this via the -I switch. Do note that
  this might negatively impact your performance.

std::runtime_error - kernel queueing failed during initilization (res = -45)

Downloaded the release, tried to run it, got this:

C:\Temp\profanity-v1.3-x64>profanity.exe --benchmark
Mode: benchmark
Target: Address
Devices:
  GPU0: GeForce GTX 1070, 8589934592 bytes available, 15 compute units (precompiled = no)
  GPU1: Ellesmere, 8589934592 bytes available, 36 compute units (precompiled = no)

Initializing OpenCL...
  Creating context...
C:\Temp\profanity-v1.3-x64>

I have tried using v1.21 on two different systems with the same results. One system has a GTX 1060, the other 1070Ti

If I don't issue the -I it hangs after "Initializing devices..." for 10+ minutes. I have to issue a low number for it to pass this, such as profanity.exe --skip GPU0 -I 900 --matching c1. If I do that, I get "warning: local work size abandoned on GPU1"

I'll get a status of mh/s (e.g. GPU1: 18.230 MH/s"), but no results, even for something really easy, like matching 2 characters.

Here's a screen shot - https://imgur.com/a/9rMmOTl

The generation becomes blazingly fast on nvidia! Unfortunatlely contract addresses are broken, see screenshot.

Hello,

I am trying to run profanity-v1.60 on my windows 10 Laptop, However I keep getting the following error:
The procedure entry point clCreateCommandQueueWithProperties could not be located in the dynamic link library

should I place in the project in a particular directory ? It's sitting in my Downloads folder for the Moment. At first I thought I'm missing OpenCL, but my drivers are up to date and clinfo returns the following:

Platform #0: Intel(R) OpenCL
 +-- Device #0:        Intel(R) Core(TM) i5-3210M CPU @ 2.50GHz
 `-- Device #1: Intel(R) HD Graphics 4000

I have also tried copying the OpenCL.DLL folder from C:\WINDOWS\system32 to the project's directory, but nothing changed.

Any help would be appreciated,
have a good day :)

Hello- upon launching profanity, it exits immediately. I'm on windows launching through cmd- it doesn't matter what command I use, it exits immediately regardless:

I did have something else running on my main gpu when I grabbed the screenshot, though this issue happens even if I do not.

Hi dear johguse, every time I run the program it founds not exactly what I want but a false positive results.

the same unedequate results, every time, I run it for 2 days, for 1 hour, for 10 minutes -the same false results both with --matching 8071dbef07eefe7eXXXXXXXXXXXXXXXXXXXXXXXX or --matching 8071dbef07eefe7e, this means something like "worldbeforeethereum", I have tried 10 other matches but no luck.
1)Johguse could you please change program code for giving out any results he found. Even if he founds thousand and millions resuls for example --matching 103e777888, and precompile a windows version, please?
2)Could you plase add function write results to output.txt file?
I am using Win10, 1050Ti, driver 445.87.
Thanks for your attension!

root@vanity-v3:/home/ubuntu/profanity# ./profanity.x64 --mirror
Mode: mirror
Target: Address
Devices:
GPU0: NVIDIA GeForce RTX 3090, 25447170048 bytes available, 82 compute units (precompiled = yes)
GPU1: NVIDIA GeForce RTX 3090, 25447170048 bytes available, 82 compute units (precompiled = yes)
GPU2: NVIDIA GeForce RTX 3090, 25447170048 bytes available, 82 compute units (precompiled = yes)
GPU3: NVIDIA GeForce RTX 3090, 25447170048 bytes available, 82 compute units (precompiled = yes)

Initializing OpenCL...
Creating context...OK
Loading kernel from binary...OK
Building program...OK

Initializing devices...
This should take less than a minute. The number of objects initialized on each
device is equal to inverse-size * inverse-multiple. To lower
initialization time (and memory footprint) I suggest lowering the
inverse-multiple first. You can do this via the -I switch. Do note that
this might negatively impact your performance.

GPU2 initialized
GPU1 initialized
GPU0 initialized
GPU3 initialized

Initialization time: 1 seconds
Running...
Always verify that a private key generated by this program corresponds to the
public key printed by importing it to a wallet of your choice. This program
like any software might contain bugs and it does by design cut corners to
improve overall performance.

Time: 1s Score: 5 Private: 0x63352c83768d3ae0c504b3de6492c918f673b90d4c295d7013176b9310a87d43 Address: 0x131803eb92088afff9b44b9ffa2c90147d48a9ea
Time: 1s Score: 6 Private: 0xa0bf184912ff4894af252b7817a136db853ac2d7c9654b6db45fb497e8727b18 Address: 0xd3d64f69d32b70a94c4aa4c49a7c9360e904d929
Time: 2s Score: 7 Private: 0x80fe37f9c1ff4f75825565e5bed29a6c698236c83ba7b961dc97796495173216 Address: 0x4910bb791656d3fac2fbbf2caf3795699d1a657e
Time: 2s Score: 8 Private: 0x80fe37f9c1df6ef0825565e5bed29a6c698236c83ba7b961dc97796495173273 Address: 0xa183e9040d0d76826299992628670fac51c17efc
Total: 2.380 GH/s - GPU0: 593.115 MH/s GPU1: 596.846 MH/s GPU2: 593.115 MH/s GPU3: 596.846 MH/s

First of all, performance is pretty cool and MacBook Air M1 not started throttling and heating even after few minutes of bruteforcing private keys at speed 46 MH/s.

The only my concern is about 8 cores. It seems OpenCL discovered 8 CPU cores and not discovered another 8 GPU cores:

There are some improvements since latest binary release, e.g. --contract option support #15.
Please make a new binary release for Windows with those features.

windows 10 pro didn't work well and reinstalled. The black screen is coming and closing. rx580 video card drivers are up to date. What is missing? ethereum miner 30-32 mhs. Thanks for help.

I can't run the program on my computer ASUS with RTX 2060, i put benchmark -s 0 to avoid graphic card but the last version 1.60 of profanity doesn't work. Could someone addd a new vanity ethereum gpu version ?

$ ./profanity.x64 --contract --leading 0
Mode: leading
Target: Contract
Devices:
  GPU0: Intel(R) Gen9 HD Graphics NEO, 26831257600 bytes available, 48 compute units (precompiled = no)

Initializing OpenCL...
  Creating context...OK
  Compiling kernel...OK
  Building program...OK
  Saving program...OK

Initializing devices...
  This should take less than a minute. The number of objects initialized on each
  device is equal to inverse-size * inverse-multiple. To lower
  initialization time (and memory footprint) I suggest lowering the
  inverse-multiple first. You can do this via the -I switch. Do note that
  this might negatively impact your performance.

  GPU0 initialized

Initialization time: 44 seconds
Running...
  Always verify that a private key generated by this program corresponds to the
  public key printed by importing it to a wallet of your choice. This program
  like any software might contain bugs and it does by design cut corners to
  improve overall performance.

  Time:    46s Score:  7 Private: __________ Contract: ___________
  Time:   535s Score:  8 Private: __________ Contract: _____________
Total: inf H/s - GPU0: inf H/s

It shows H/s before finding the first key. Then it just shows "inf H/s". It's working though. It's using lots of CPU and after 535 seconds printed a second key. I think this is just a minor issue.

• sorry for image, I didn't figure out how to copy stuff from the cmd on these windows machines...

Dowload the precompiled profanity, it works fine, but self-compiled ones didn't:

Downloaded binary

$ ls /opt/profanity/
cache-opencl.255.131072  keccak.cl  profanity.cl  profanity.exe  profanity.x64
$ ./profanity.x64 --contract --leading 0
Mode: leading
Target: Contract
Devices:
  GPU0: GeForce RTX 2070 SUPER, 8368685056 bytes available, 40 compute units (precompiled = yes)

Initializing OpenCL...
  Creating context...OK
  Loading kernel from binary...OK
  Building program...OK

Initializing devices...
  This should take less than a minute. The number of objects initialized on each
  device is equal to inverse-size * inverse-multiple. To lower
  initialization time (and memory footprint) I suggest lowering the
  inverse-multiple first. You can do this via the -I switch. Do note that
  this might negatively impact your performance.

  Time:     4s Score:  6 Private: 0x6dcc6899b87ba18be41132538f6389f483b6c5290bae53c6a7047a0c934a85d7 Contract: 0x000000908fc0063710a6b5089e6921a0f020479a

Self-compiled:

$ sudo apt install nvidia-opencl-dev  ocl-icd-opencl-dev opencl-headers
$ make
g++ -c -std=c++11 -Wall -mmmx -O2 -mcmodel=large   Dispatcher.cpp -o Dispatcher.o
In file included from /usr/include/CL/cl.h:32,
                 from Dispatcher.hpp:14,
                 from Dispatcher.cpp:1:
/usr/include/CL/cl_version.h:34:104: note: #pragma message: cl_version.h: CL_TARGET_OPENCL_VERSION is not defined. Defaulting to 220 (OpenCL 2.2)
   34 | #pragma message("cl_version.h: CL_TARGET_OPENCL_VERSION is not defined. Defaulting to 220 (OpenCL 2.2)")
      |                                                                                                        ^
Dispatcher.cpp: In static member function ‘static _cl_command_queue* Dispatcher::Device::createQueue(_cl_context*&, _cl_device_id*&)’:
Dispatcher.cpp:84:34: warning: converting to non-pointer type ‘cl_command_queue_properties’ {aka ‘long unsigned int’} from NULL [-Wconversion-null]
   84 |  cl_command_queue_properties p = NULL;
      |                                  ^~~~
Dispatcher.cpp: In member function ‘void Dispatcher::addDevice(cl_device_id, size_t, size_t)’:
Dispatcher.cpp:165:113: warning: ‘new’ of type ‘Dispatcher::Device’ with extended alignment 32 [-Waligned-new=]
  165 |  Device * pDevice = new Device(*this, m_clContext, m_clProgram, clDeviceId, worksizeLocal, m_size, index, m_mode);
      |                                                                                                                 ^
Dispatcher.cpp:165:113: note: uses ‘void* operator new(std::size_t)’, which does not have an alignment parameter
Dispatcher.cpp:165:113: note: use ‘-faligned-new’ to enable C++17 over-aligned new support
Dispatcher.cpp: In function ‘void printResult(cl_ulong4, cl_ulong, result, cl_uchar, const std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long int, std::ratio<1, 1000000000> > >&, const Mode&)’:
Dispatcher.cpp:29:13: note: the ABI for passing parameters with 32-byte alignment has changed in GCC 4.6
   29 | static void printResult(cl_ulong4 seed, cl_ulong round, result r, cl_uchar score, const std::chrono::time_point<std::chrono::steady_clock> & timeStart, const Mode & mode) {
      |             ^~~~~~~~~~~
g++ -c -std=c++11 -Wall -mmmx -O2 -mcmodel=large   Mode.cpp -o Mode.o
In file included from /usr/include/CL/cl.h:32,
                 from Mode.hpp:9,
                 from Mode.cpp:1:
/usr/include/CL/cl_version.h:34:104: note: #pragma message: cl_version.h: CL_TARGET_OPENCL_VERSION is not defined. Defaulting to 220 (OpenCL 2.2)
   34 | #pragma message("cl_version.h: CL_TARGET_OPENCL_VERSION is not defined. Defaulting to 220 (OpenCL 2.2)")
      |                                                                                                        ^
g++ -c -std=c++11 -Wall -mmmx -O2 -mcmodel=large   precomp.cpp -o precomp.o
In file included from /usr/include/CL/cl.h:32,
                 from types.hpp:10,
                 from precomp.hpp:4,
                 from precomp.cpp:1:
/usr/include/CL/cl_version.h:34:104: note: #pragma message: cl_version.h: CL_TARGET_OPENCL_VERSION is not defined. Defaulting to 220 (OpenCL 2.2)
   34 | #pragma message("cl_version.h: CL_TARGET_OPENCL_VERSION is not defined. Defaulting to 220 (OpenCL 2.2)")
      |                                                                                                        ^
g++ -c -std=c++11 -Wall -mmmx -O2 -mcmodel=large   profanity.cpp -o profanity.o
In file included from /usr/include/CL/cl.h:32,
                 from profanity.cpp:16:
/usr/include/CL/cl_version.h:34:104: note: #pragma message: cl_version.h: CL_TARGET_OPENCL_VERSION is not defined. Defaulting to 220 (OpenCL 2.2)
   34 | #pragma message("cl_version.h: CL_TARGET_OPENCL_VERSION is not defined. Defaulting to 220 (OpenCL 2.2)")
      |                                                                                                        ^
g++ -c -std=c++11 -Wall -mmmx -O2 -mcmodel=large   SpeedSample.cpp -o SpeedSample.o
g++ Dispatcher.o Mode.o precomp.o profanity.o SpeedSample.o -s -lOpenCL -mcmodel=large -o profanity.x64
$ ./profanity.x64 --contract --leading 0
Mode: leading
Target: Contract
Devices:
  GPU0: GeForce RTX 2070 SUPER, 8368685056 bytes available, 40 compute units (precompiled = yes)

Initializing OpenCL...
  Creating context...OK
  Loading kernel from binary...OK
  Building program...OK

std::runtime_error - failed to create kernel "profanity_init"

./profanity.x64 --leading 0

Mode: leading
Target: Address
Devices:
  GPU0: Intel(R) UHD Graphics 630, 1610612736 bytes available, 24 compute units (precompiled = no)
  GPU1: AMD Radeon Pro 5500M Compute Engine, 4278190080 bytes available, 24 compute units (precompiled = no)

Initializing OpenCL...
  Creating context...OK
  Compiling kernel...OK
  Building program...OK
  Saving program...OK

Initializing devices...
  This should take less than a minute. The number of objects initialized on each
  device is equal to inverse-size * inverse-multiple. To lower
  initialization time (and memory footprint) I suggest lowering the
  inverse-multiple first. You can do this via the -I switch. Do note that
  this might negatively impact your performance.

  GPU1 initialized
  GPU0 initialized

Initialization time: 98 seconds
Running...
  Always verify that a private key generated by this program corresponds to the
  public key printed by importing it to a wallet of your choice. This program
  like any software might contain bugs and it does by design cut corners to
  improve overall performance.

  Time:    99s Score:  5 Private: 0x89f61b1ec4eb6f10febc6b60bc4d6ad9fd92bb6b34b0928eb3bc6ed0a754c7c3 Address: 0x0000040330a2a2d9ac73363c253d61e2cbfe23f5
  Time:    99s Score:  6 Private: 0x2a5287598ee65bb33b4db28aadf26b4122e94de11d6d2e26c8018821832720eb Address: 0x000000a5714ec98568c661e2be88eb789b007c18
  Time:   109s Score:  7 Private: 0x2a5287598f0f46b53b4db28aadf26b4122e94de11d6d2e26c80188218327216d Address: 0x00000003ae1d96d6b8a6801532e6942ea9fd0cb7
^Ctal: 39.783 MH/s - GPU0: 4.689 MH/s GPU1: 35.094 MH/s

But it seems these private keys are not matching vanity addresses.

Should it work on my GPU?

gkucmierz@Grzegorzs-MBP profanity % ./profanity.x64 --matching dead          
Mode: matching
Target: Address
Devices:
  GPU0: Iris Pro, 1610612736 bytes available, 40 compute units (precompiled = no)
  GPU1: GeForce GT 750M, 2147483648 bytes available, 2 compute units (precompiled = no)

Initializing OpenCL...
  Creating context...OK
  Compiling kernel...OK
  Building program...OK
  Saving program...OK

Initializing devices...
  This should take less than a minute. The number of objects initialized on each
  device is equal to inverse-size * inverse-multiple. To lower
  initialization time (and memory footprint) I suggest lowering the
  inverse-multiple first. You can do this via the -I switch. Do note that
  this might negatively impact your performance.

zsh: abort      ./profanity.x64 --matching dead

The score is 39 at maximum, which is buggy if you want an address with score 40.

For example, when you run./profanity.x64 --numbers to generate all-digits addresses, you can get an address with 39 digits (score = 39) easily. But you can never get score 40.

On a Ubuntu set up, I can tell that opencl-c-headers are needed but not sure what other packages are required for compiling. Thanks.

Does LHR gpu suffer from reduced speed compared to the NON-LHR of the same gpu model?

Hiya.

Is it possible to find checksum addresses (case sensitive)?
Like https://vanity-eth.tk/ does but with the ability to use GPU's rather than in the browser?

Thank you!

RUSSIAN: для тестирования я запустил на 1050ti. Решил замерить скорость. Но выводимые значения не совпадают с реальностью.
G.Translate: for testing I ran on 1050ti. Decided to measure the speed. But the displayed values do not coincide with reality.

Time: 9s Score: 7 Private:
0xffdf844f2239a711d1045ddb57fb41de75cf39ad0cd835d39a3c2a97409c0ef1 Public: 0xfffffff9aae9efc692ba12004feb285b9b98ca21
Time: 69s Score: 8 Private: 0xffdf844f223aef57d1045ddb57fb41de75cf39ad0cd835d39a3c2a97409c1298 Public: 0xffffffffe3a94a1c80aa9bf609ebd232b4517f8c

69 - 9 = 60 seconds

c1298 - c0ef1 = 3A7 or 935

935/60 = 15 combination / second

How?

Needed validation

I'm trying to run it in Windows 11, and its crashing as per attached ss. Kindly let me know if you've any suggestions to make it work.

This is legitimately the simplest possible use case, but it does not seem possible. ./profanity --leading only reads a single first character, i.e. --leading ABC might return stuff like aaaaaa42f....

Advice? Is there any way to just tell the program I want an address beginning with an arbitrary string?

Hello I am getting a segmentation fault after running for a few hours. Using 8x 2080 TI's.
Using the args ./profianity.x64 --leading 0
On ubuntu 18.04
Anyone know?

Trying to run profanity.exe from precompiled releases, but following error happened.

C:\Users\Incrediblez7>E:\profanity-v1.60-x64.zip\profanity.exe --leading f
Mode: leading
Target: Address
Devices:
  GPU0: GeForce RTX 2070 SUPER, 8589934592 bytes available, 40 compute units (precompiled = yes)

Initializing OpenCL...
  Creating context...OK
  Loading kernel from binary...OK
  Building program...OK

std::runtime_error - failed to create kernel "profanity_init"

could documentation be provided to build from source including project dependencies on windows 10 system

This tool is fantastic for finding gas efficient ethereum addresses and I typically use it with the form of .\profanity --leading 0 for this purpose.

This outputs addresses like:
0x0000...
0x00000..
0x000000000...
All of which save significant amounts of gas through long term use.
However, gas efficiency on eth addresses is also driven through zero-bytes, not just leading zeros.

It'd be incredible if there were a scoring mechanism based on this premise of finding zero-bytes anywhere throughout the address, rather than just the beginning.

For example
Score | Address
4 | 0x00000000.....
5 | 0x000000004124001232.....
6 | 0x00000041002400120032.....
9 | 0x00000000410024001200320000...

As I run through the .\profanity --leading 0 program, I wonder how many addresses with more zero-bytes are skipped over.

For more reading on this:
https://medium.com/coinmonks/on-efficient-ethereum-addresses-3fef0596e263

I'm trying to run it in Windows 11, and its crashing as per attached ss. Kindly let me know if you've any suggestions to make it work.

https://github.com/ethereum/EIPs/blob/master/EIPS/eip-55.md

Hi, could you elaborate on how private keys are being generated and brute forced? It seems like a reliable random number generator std::mt19937_64 is being fully initialized by unsigned int (https://en.cppreference.com/w/cpp/numeric/random/random_device), which could make it less reliable:

Seems like brute-forcing 2^32 seeds, each for a few seconds on top-notch hardware could expose some keys with 5-6-7 mined symbol.

Hi there, this seems like a simple problem, not sure if I'm doing something wrong, when I run profanity in Windows 10 command prompt using for instance: profanity --matching aXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX I only ever get 1 result while hashing at 60M hashes. The one result I get also always shows up before the speed starts getting displayed.

If feels like there is a line feed missing after displaying results, causing the carriage return of the Speed to overwrite any found matches.

Any ideas ? Thanks

I intend to add a feature that would allow you to specify that the address you are targeting is the contract created by the private key's zeroth transaction. This would be equivalent to the --contract feature in https://github.com/MyEtherWallet/VanityEth, and is useful for mining vanity addresses recommended by EIP-1167.

Hi! I just found this linked on StackOverflow and this looks like a really cool project!
When I try to find an address, I sadly get this error:

C:\profanity>profanity.exe --leading 0
Mode: leading
Devices:
        GPU0: GeForce GTX 1070, 8589934592 bytes available, 15 compute units (precompiled = yes)

Initializing OpenCL...
        Creating context...OK
        Loading kernel from binary...OK
        Building program...OK

std::runtime_error - kernel queueing failed (res = -54)

I also tried the first version:

Mode: benchmark
Devices:
        GPU0: GeForce GTX 1070, 8589934592 bytes available, 15 compute units
                CL_DEVICE_MAX_CONSTANT_ARGS = 9
                CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE = 65536
                CL_DEVICE_MAX_PARAMETER_SIZE = 4352

Initializing OpenCL...
        Creating context...OK
        Compiling kernel...OK
        Building program...-11

build log:
<kernel>:116:31: error: array initializer must be an initializer list
__constant bignum bn_zero = { 0 };
                              ^
<kernel>:671:16: warning: incompatible pointer types initializing '__attribute__((address_space(16776963))) ulong *const __attribute__((address_space(16776963)))' (aka '__attribute__((address_space(16776963))) unsigned long *const __attribute__((address_space(16776963)))') with an expression of type 'ulong __attribute__((address_space(16776963))) (*)[25]'
        ulong * const st = &pHash->q;
                      ^    ~~~~~~~~~
<kernel>:759:20: error: array initializer must be an initializer list
        bignum monter = { 0xe90a1, 0x7a2, 0x1, 0 };
                          ^
<kernel>:849:20: error: array initializer must be an initializer list
        bignum monter = { 0xe90a1, 0x7a2, 0x1, 0 };
                          ^
<kernel>:892:20: error: array initializer must be an initializer list
        bignum monter = { 0xe90a1, 0x7a2, 0x1, 0 };
                          ^

I'm currently rocking a gtx1070 + ryzen 7 1700X, I can test this with 2 rx480s later

Hello,
Can you implement a match against a given list?

Example.

address.txt
0x0000000000000000000000000000000000000001
0x0000000000000000000000000000000000000002

-a address.txt

Leading zero should be optional

Are you planning to add this option
-i inputfile: Get list of prefixes to search from specified file

similar to Vanitysearch ?

Hi, I am running the pre-compiled program and also my manually built version on ubuntu-18.04 with RTX3080.

NVIDIA-SMI 470.74       Driver Version: 470.74       CUDA Version: 11.4

However, devices cannot be detected when running the program.

$ ./profanity.x64 --contract tract --leading 0 
tract --leading 0
Target: Contract    
Devices: 

Does anyone ever met this problem before?

It'd be nice if it were possible to mine addresses for CREATE2. CREATE2 computes addresses based on keccak256(0xff + creator_address + salt + keccak256(initcode)), which means it doesn't require any ECDSA ops, which should make mining much faster. salt is always 32 bytes.

The command line could take the creator address and init code hash, and try salts.

I don't know openCL, but I'd happily pay a modest bounty for this feature.

Love the project!

However, when I run it on my local machine with a GTX 1050 3gb, for release 1.11 I get the following error:

warning: local work size abandoned on GPU0
std::runtime_error - kernel queueing failed (res = -4)

any thoughts?

HI,

how much time would you estimate for full custom address 40 characters ?
I have 4x2080ti 124gb ram 1tb nvme ssd xeon processor

Thank you =)

Hello,

Can you implement a start-end range for the given private key?

Example:

-r 1-10000
-r fff - fffffffffffff

I got this issue on RTX 2060 : std::runtime_error - failed to create kernel "profanity_begin" even when i put -s 0 to avoid wrong graphic just to keep rtx 2060

The current contract flag only uses the 0th nonce to check if a match is found but it would speed up a lot if you were to allow up to N nonces to be generated before generating a new wallet address to check.

When I do profanity --matching deadc0ffee, I expect for the program to continue to run this until it gets to an address starting with deadc0ffee. However, when I do it, I get a result where instantly at the beginning I get the address 0xdead1fff924c5c01c3ca6661c9b0f5acef2d785f for example with a score of 3, which doesn't make sense because it has 7 characters matching. I also instantly get an address similar to 0xdeadc0b9ee10326cc21bc3fc835d6ca778b96da4, where two characters in a row are incorrect and it has a score of 4. No matter how long I run it after this, I never get another address or an address with more characters matching. What is happening where two characters are not being generated?

  Time:    29s Score:  5 Private: 0x3729ecb8967a1c2d24ad6a40cddba81fbc052e7478c28f156e580a6dd7f6e99f Address: 0x00000e364391609e72d61305631147f117350c1b
  Time:    30s Score:  7 Private: 0x3729ecb896a5548c24ad6a40cddba81fbc052e7478c28f156e580a6dd7f6e9a3 Address: 0x00000006fc03f831db616390e014ebee26bb0ce3
  Time:    47s Score:  8 Private: 0x3729ecb8968a602d24ad6a40cddba81fbc052e7478c28f156e580a6dd7f6ea57 Address: 0x000000002b788945a91b4357c0ccc59515e4f7cd

It is generating not correct addresses on this card:

Intel UHD Graphics 630

I propose to add option Minimum Print Score which is minimum threshold score to print result.

That would be very usefull.

I've tried to run some of the Profanity .cpp files using g++ from the terminal on Mac OS but encountered errors. Is there a way to run this code on a Mac Book Pro?

for example, keep outputting at score=15 until score=16 is achieved