diff --git a/intention_repeater_max_5.13.cpp b/Archive/intention_repeater_max_5.13.cpp similarity index 100% rename from intention_repeater_max_5.13.cpp rename to Archive/intention_repeater_max_5.13.cpp diff --git a/intention_repeater_max_5.13.exe b/Archive/intention_repeater_max_5.13.exe similarity index 100% rename from intention_repeater_max_5.13.exe rename to Archive/intention_repeater_max_5.13.exe diff --git a/Change_Log_MAX.txt b/Change_Log_MAX.txt index a94b687..f31e972 100644 --- a/Change_Log_MAX.txt +++ b/Change_Log_MAX.txt @@ -30,4 +30,5 @@ 3/25/2024 v5.9 Updated to prevent compiler from optimizing out the repeater process. 3/26/2024 v5.10 Added compression and hashing and removed PROCESS_STATEMENT that was blank anyway. 3/26/2024 v5.11 Allowing for file import. Display hashing multiplier and compression amount. -3/26/2024 v5.13 Displaying the Multiplier value. \ No newline at end of file +3/26/2024 v5.13 Displaying the Multiplier value. +3/26/2024 v5.14 Fixed issue with segmentation error for assigning too much memory. \ No newline at end of file diff --git a/intention_repeater_max.cpp b/intention_repeater_max.cpp index 8cac410..05e23d2 100644 --- a/intention_repeater_max.cpp +++ b/intention_repeater_max.cpp @@ -1,5 +1,5 @@ /* - Intention Repeater MAX v5.13 (c)2020-2024 by Anthro Teacher aka Thomas Sweet. + Intention Repeater MAX v5.14 (c)2020-2024 by Anthro Teacher aka Thomas Sweet. Enhancement and flags by Karteek Sheri. Holo-Link framework created by Mystic Minds. This implementation by Anthro Teacher. Boosting through Nested Files by Anthro Teacher. @@ -366,7 +366,7 @@ void create_nesting_files() void print_help() { const std::string helpText = R"( -Intention Repeater MAX v5.13 (c)2020-2024 by Anthro Teacher aka Thomas Sweet. +Intention Repeater MAX v5.14 (c)2020-2024 by Anthro Teacher aka Thomas Sweet. This utility repeats your intention millions of times per second, in computer memory, to aid in manifestation. Performance benchmark, exponents and flags by Karteek Sheri. Holo-Link framework by Mystic Minds. This implementation by Anthro Teacher. @@ -827,7 +827,7 @@ int main(int argc, char **argv) param_intention = "NEST-" + param_boostlevel + ".TXT"; } - unsigned long long int INTENTION_MULTIPLIER = (ram_size_value * 1024 * 1024 * 1024); + unsigned long long int INTENTION_MULTIPLIER = (ram_size_value * 1024 * 1024 * 512); unsigned long long int free_memory = get_ninety_percent_free_memory(); if (free_memory != static_cast(-1)) { // Check against max value for error @@ -914,7 +914,7 @@ int main(int argc, char **argv) std::locale comma_locale(std::locale(), new comma_numpunct()); std::cout.imbue(comma_locale); - std::cout << "Intention Repeater MAX v5.13 (c)2020-2024" << endl + std::cout << "Intention Repeater MAX v5.14 (c)2020-2024" << endl << "by Anthro Teacher aka Thomas Sweet." << endl << endl; @@ -974,7 +974,6 @@ int main(int argc, char **argv) intention_value = intention_value.substr(0, intention_length_val); digits = to_string(multiplier).length(); - std::cout << "Multiplier: " << display_suffix(to_string(multiplier), digits - 1, "Iterations") << endl; } // End Multiplier (when not using frequency) if (INTENTION_MULTIPLIER == 0) @@ -1008,6 +1007,10 @@ int main(int argc, char **argv) transform(useCompression.begin(), useCompression.end(), useCompression.begin(), ::tolower); } + if (multiplier > 0) { + std::cout << "Multiplier: " << display_suffix(to_string(multiplier), digits - 1, "Iterations") << endl; + } + if (useHashing == "y" || useHashing == "yes") { std::cout << "Hashing... \r"; @@ -1041,9 +1044,9 @@ int main(int argc, char **argv) if (useCompression == "y" || useCompression == "yes") { std::cout << "Compressing... \r"; - originalIntentionSize = intention_value.length(); + originalIntentionSize = intention_value.length()*2; intention_value = compressMessage(intention_value); - compressedIntentionSize = intention_value.length(); + compressedIntentionSize = intention_value.length()*2; compressionFactor = (originalIntentionSize / compressedIntentionSize); compressionFactor_digits = to_string(compressionFactor).length(); @@ -1051,8 +1054,8 @@ int main(int argc, char **argv) originalIntention_digits = to_string(originalIntentionSize).length(); std::cout << "Compression: " << display_suffix(to_string(compressionFactor), compressionFactor_digits - 1, "Iterations") << "X [" - << display_suffix(to_string(originalIntentionSize/1024/1024), originalIntention_digits - 1, "Frequency") << "B -> " - << display_suffix(to_string(compressedIntentionSize/1024), compressedIntentionSize_digits - 1, "Frequency") << "B] " << endl; + << display_suffix(to_string(originalIntentionSize), originalIntention_digits - 1, "Frequency") << "B -> " + << display_suffix(to_string(compressedIntentionSize), compressedIntentionSize_digits - 1, "Frequency") << "B] " << endl; } duration = param_duration; diff --git a/intention_repeater_max.exe b/intention_repeater_max.exe index 04e7511..7d0c8b9 100644 Binary files a/intention_repeater_max.exe and b/intention_repeater_max.exe differ diff --git a/intention_repeater_max_5.14.cpp b/intention_repeater_max_5.14.cpp new file mode 100644 index 0000000..7963af2 --- /dev/null +++ b/intention_repeater_max_5.14.cpp @@ -0,0 +1,1323 @@ +/* + Intention Repeater MAX v5.14 (c)2020-2024 by Anthro Teacher aka Thomas Sweet. + Enhancement and flags by Karteek Sheri. + Holo-Link framework created by Mystic Minds. This implementation by Anthro Teacher. + Boosting through Nested Files by Anthro Teacher. + Updated 3/26/2024 by Anthro Teacher. + To compile: g++ -O3 -Wall -static intention_repeater_max.cpp -o intention_repeater_max.exe -lz + Repeats your intention up to 100 PHz to make things happen. + For help: intention_repeater_max.exe --help + Intention Repeater MAX is powered by a Servitor (20 Years / 2000+ hours in + the making) [HR 6819 Black Hole System]. Servitor Info: + https://enlightenedstates.com/2017/04/07/servitor-just-powerful-spiritual-tool/ + Website: https://www.intentionrepeater.com/ + Forum: https://forums.intentionrepeater.com/ + Licensed under GNU General Public License v3.0 + This means you can modify, redistribute and even sell your own modified + software, as long as it's open source too and released under this same + license. https://choosealicense.com/licenses/gpl-3.0/ +*/ + +#include +#ifndef _WIN32 +#include +#endif + +#ifdef _WIN32 + #include +#elif __linux__ + #include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "picosha2.h" +#include "zlib.h" + +using namespace std; +using namespace std::chrono; + +#define ONE_MINUTE 60 +#define ONE_HOUR 3600 + +#ifndef _WIN32 +#ifndef _COLORS_ +#define _COLORS_ + +#define DEFAULT "\x1b[0m" +#define DARKGRAY "\x1b[1;30m" +#define BLACK "\x1b[0;30m" +#define LIGHTRED "\x1b[1;31m" +#define RED "\x1b[0;31m" +#define LIGHTGREEN "\x1b[1;32m" +#define GREEN "\x1b[0;32m" +#define LIGHTYELLOW "\x1b[1;33m" +#define YELLOW "\x1b[0;33m" +#define LIGHTBLUE "\x1b[1;34m" +#define BLUE "\x1b[0;34m" +#define LIGHTMAGENTA "\x1b[1;35m" +#define MAGENTA "\x1b[0;35m" +#define LIGHTCYAN "\x1b[1;36m" +#define CYAN "\x1b[0;36m" +#define WHITE "\x1b[1;37m" +#define LIGHTGRAY "\x1b[0;37m" + +#endif // _COLORS_ + +#else +HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE); + +const char *enum2str[] = {"BLACK", "BLUE", "GREEN", "CYAN", "RED", "MAGENTA", + "YELLOW", "WHITE", "DARKGRAY", "LIGHTBLUE", "LIGHTGREEN", "LIGHTCYAN", + "LIGHTRED", "LIGHTMAGENTA", "LIGHTYELLOW", "LIGHTGRAY"}; + +#define BLACK 0 +#define BLUE 1 +#define GREEN 2 +#define CYAN 3 +#define RED 4 +#define MAGENTA 5 +#define YELLOW 6 +#define WHITE 7 +#define DARKGRAY 8 +#define LIGHTBLUE 9 +#define LIGHTGREEN 10 +#define LIGHTCYAN 11 +#define LIGHTRED 12 +#define LIGHTMAGENTA 13 +#define LIGHTYELLOW 14 +#define LIGHTGRAY 15 + +#endif // _WIN32 + +class comma_numpunct : public std::numpunct +{ +protected: + virtual char do_thousands_sep() const + { + return ','; + } + + virtual std::string do_grouping() const + { + return "\03"; + } +}; + +unsigned long long int get_ninety_percent_free_memory() { + unsigned long long int free_memory = 0; + + #ifdef _WIN32 + // Windows-specific memory information + MEMORYSTATUSEX memInfo; + memInfo.dwLength = sizeof(MEMORYSTATUSEX); + GlobalMemoryStatusEx(&memInfo); + DWORDLONG freePhysMem = memInfo.ullAvailPhys; + free_memory = static_cast(freePhysMem * 0.9); // 90% of free physical memory + #elif __linux__ + // Linux-specific memory information + struct sysinfo memInfo; + sysinfo(&memInfo); + unsigned long long totalPhysMem = memInfo.totalram; + // Multiply in next statement to avoid int overflow on right hand side... + totalPhysMem *= memInfo.mem_unit; + unsigned long long freePhysMem = memInfo.freeram; + freePhysMem *= memInfo.mem_unit; + free_memory = static_cast(freePhysMem * 0.9); // 90% of free memory + #else + std::cerr << "Unsupported operating system" << std::endl; + return static_cast(-1); // Return max value to indicate error + #endif + + return free_memory; +} + +std::string compressMessage(const std::string &message) +{ + z_stream zs; + memset(&zs, 0, sizeof(zs)); + + if (deflateInit(&zs, Z_DEFAULT_COMPRESSION) != Z_OK) + { + return ""; // Compression initialization failed + } + + zs.next_in = (Bytef *)message.data(); + zs.avail_in = message.size(); + + std::string compressed; + char outbuffer[32768]; // Output buffer + int ret; + do + { + zs.next_out = reinterpret_cast(outbuffer); + zs.avail_out = sizeof(outbuffer); + + ret = deflate(&zs, Z_FINISH); + + if (compressed.size() < zs.total_out) + { + compressed.append(outbuffer, zs.total_out - compressed.size()); + } + } while (ret == Z_OK); + + deflateEnd(&zs); + + if (ret != Z_STREAM_END) + { + return ""; // Compression failed + } + + return compressed; +} + +// Function to read contents of a file into a string +void readFileContents(const std::string &filename, std::string &intention_file_contents) +{ + // Open the file using an ifstream + std::ifstream file(filename); + + // Check if the file was successfully opened + if (!file) + { + // If the file cannot be opened or does not exist, print an error and exit + std::cerr << "File not found" << std::endl; + exit(EXIT_FAILURE); // Terminate the program + } + + // Read the file contents into the string + std::stringstream buffer; + buffer << file.rdbuf(); // Read the buffer contents of the file + intention_file_contents = buffer.str(); // Convert the buffer into a string + + // Close the file (optional here since it'll be closed automatically when the function exits) + file.close(); +} + +std::string display_suffix(std::string num, int power, std::string designator) +{ + std::string s; + + if (power < 3) + { + return num; + } + + if (designator == "Iterations") + { + char iterations_suffix_array[] = {' ', 'k', 'M', 'B', 'T', 'q', 'Q', 's', 'S', 'O', 'N', 'D'}; + // cout << "Power: " << power << endl; + s = iterations_suffix_array[int(power / 3)]; + } + else // designator == "Frequency" + { + char frequency_suffix_array[] = {' ', 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y', 'R'}; + // cout << "Power: " << power << endl; + s = frequency_suffix_array[int(power / 3)]; + } + + std::string str2 = num.substr(0, power % 3 + 1) + "." + num.substr(power % 3 + 1, 3) + s; + + return str2; +} + +std::string FormatTimeRun(int seconds_elapsed) +{ + int hour, min, sec; + + std::string hour_formatted, min_formatted, sec_formatted; + + hour = seconds_elapsed / ONE_HOUR; + seconds_elapsed -= hour * ONE_HOUR; + min = seconds_elapsed / ONE_MINUTE; + seconds_elapsed -= min * ONE_MINUTE; + sec = seconds_elapsed; + + if (hour < 10) + { + hour_formatted = "0" + std::to_string(hour); + } + else + { + hour_formatted = std::to_string(hour); + } + + if (min < 10) + { + min_formatted = "0" + std::to_string(min); + } + else + { + min_formatted = std::to_string(min); + } + + if (sec < 10) + { + sec_formatted = "0" + std::to_string(sec); + } + else + { + sec_formatted = std::to_string(sec); + } + + return hour_formatted + ":" + min_formatted + ":" + sec_formatted; +} + +void print_color_help() +{ +#ifndef _WIN32 + cout << WHITE; +#else + SetConsoleTextAttribute(hConsole, WHITE); +#endif + + cout << "Color values for flag: --color [COLOR]" << endl + << endl; + +#ifndef _WIN32 + std::cout << DEFAULT << "DEFAULT" << endl; + std::cout << DARKGRAY << "DARKGRAY" << endl; + std::cout << BLACK << "BLACK" << endl; + std::cout << LIGHTRED << "LIGHTRED" << endl; + std::cout << RED << "RED" << endl; + std::cout << LIGHTGREEN << "LIGHTGREEN" << endl; + std::cout << GREEN << "GREEN" << endl; + std::cout << LIGHTYELLOW << "LIGHTYELLOW" << endl; + std::cout << YELLOW << "YELLOW" << endl; + std::cout << LIGHTBLUE << "LIGHTBLUE" << endl; + std::cout << BLUE << "BLUE" << endl; + std::cout << LIGHTMAGENTA << "LIGHTMAGENTA" << endl; + std::cout << MAGENTA << "MAGENTA" << endl; + std::cout << LIGHTCYAN << "LIGHTCYAN" << endl; + std::cout << CYAN << "CYAN" << endl; + std::cout << WHITE << "WHITE" << endl; + std::cout << LIGHTGRAY << "LIGHTGRAY" << endl; + +#else + + for (int k = 1; k <= 15; k++) + { + // pick the colorattribute k you want + SetConsoleTextAttribute(hConsole, k); + std::cout << enum2str[k] << endl; + } +#endif // _WIN32 +} + +void create_nesting_files() +{ + + std::fstream myfile; + std::string filename; + + myfile.open("NEST-1.TXT", ios::out); + + if (myfile.is_open()) + { + for (int repnum = 1; repnum <= 10; repnum++) + { + myfile << "INTENTIONS.TXT\r\n"; + } + } + + for (int filenum = 1; filenum <= 100; filenum++) + { + filename = "NEST-" + std::to_string(filenum) + ".TXT"; + myfile.open(filename, ios::out); + + for (int repnum = 1; repnum <= 10; repnum++) + { + myfile << "NEST-" + std::to_string(filenum - 1) + ".TXT\r\n"; + } + myfile.close(); + } + + std::cout << "Intention Repeater Nesting Files Written." << endl; + + std::cout << "Be sure to have your intentions in the INTENTIONS.TXT file." << endl; + + std::cout << "To run with the nesting option, use --boostlevel 50, for example to use up to Nesting to 50 levels deep." + << endl; + + std::cout << "--boostlevel valid values: 1 to 100." << endl; + + std::cout << "When using --boostlevel 50, for example, it will ignore the --intent, and use \"NEST-50.TXT\" for the " + "intent instead." + << endl + << endl; +} + +void print_help() +{ + const std::string helpText = R"( +Intention Repeater MAX v5.14 (c)2020-2024 by Anthro Teacher aka Thomas Sweet. +This utility repeats your intention millions of times per second, in computer memory, to aid in manifestation. +Performance benchmark, exponents and flags by Karteek Sheri. +Holo-Link framework by Mystic Minds. This implementation by Anthro Teacher. +Intention multiplying by Anthro Teacher. + +Optional Flags: + a) --dur or -d, example: --dur 00:01:00 + b) --imem or -m, example: --imem 5 + c) --intent or -i, example: --intent "I am love." + d) --suffix or -s, example: --suffix HZ + e) --timer or -t, example: --timer INEXACT + f) --freq or -f, example: --freq 1000 + g) --color or -c, example: --color LIGHTBLUE + h) --boostlevel or -b, example: --boostlevel 100 + i) --createnestingfiles or -p, example: --createnestingfiles + j) --usehololink or -u + k) --createhololinkfiles or -x + l) --colorhelp or -n + m) --amplify or -a + n) --restevery or -e + o) --restfor or -r + p) --compress or -x + q) --hashing or -g + r) --file or -f + s) --help or -h + +--dur = Duration in HH:MM:SS format. Default = Run until stopped manually. +--imem = Specify how many GB of System RAM to use. Higher amount repeats faster, but takes longer to load. Default = 1.0. +--intent = Intention. Default = Prompts the user for intention. +--suffix = Specify whether to show regular (Hz) designator or scientific notation (Exp). Default = HZ. +--timer = Specify INEXACT or EXACT. Default = EXACT. +--freq = Specify repetition frequency in Hz. Default = As fast as possible. +--usehololink = Utilize the Holo-Link framework by Mystic Minds. +--createhololinkfiles will create the default Holo-Link files and exit. Run with this option before using the --usehololink option. This will overwrite the TXT files. +--color = Set the text color. Default = WHITE. +--colorhelp = List and show all available colors for text using the option --color. +--createnestingfiles = Create the NEST- files required for boosting. +--boostlevel = Set the level to boost the power (1-100). Use --createnestingfiles before using --boostlevel. +--amplify = Amplification Level. Default = 1000000000. +--restevery = Stop repeating every specified # of seconds. +--restfor = # of Seconds to rest for each rest period. +--compress = Use compression Default n. +--hashing = Use hashing. Default n. +--file = Specify file to use if applicable. Will override intention. +--help = Display this help. + +Example usage: +intention_repeater_max.exe --dur "00:01:00" --imem 4.0 --intent "I am Love." --hashing y --compress y + +Example usage with Holo-Link: +1) intention_repeater_max.exe --createhololinkfiles +2) intention_repeater_max.exe --usehololink --color LIGHTBLUE --suffix EXP --dur 00:01:00 --imem 4.0 --intent "I am calm." + +Make sure to create your INTENTIONS.TXT file, in this folder, with your intentions, before running #2 above. +The --intent option is ignored when using --usehololink, which instead uses the INTENTIONS.TXT file. + +Example usage with Nesting Files: +1) intention_repeater_max.exe --createnestingfiles +2) intention_repeater_max.exe --color LIGHTBLUE --dur 00:01:00 --imem 4.0 --boostlevel 5 + +Make sure to create your INTENTIONS.TXT file, in this folder, with your intentions, and the Nesting Files before running #2 above. + +gitHub Repository: https://github.com/tsweet77/repeater-max +Forum: https://forums.intentionrepeater.com +Website: https://www.intentionrepeater.com +)"; + +#ifndef _WIN32 + std::cout << helpText << std::endl; +#else + SetConsoleTextAttribute(hConsole, WHITE); + std::cout << helpText << std::endl; + SetConsoleTextAttribute(hConsole, WHITE); +#endif +} + +// Utility function to find the sum of two numbers represented as a string in +// CPP +std::string FindSum(std::string a, std::string b) +{ + + std::vector finalsum; // Stores the final sum of two number + + int carry = 0; // Stores carry at each stage of calculation + + /* Step 1 starts here */ + + int i = a.size() - 1, + j = b.size() - 1; // Start adding from lowest significant bit + while ((i >= 0) && (j >= 0)) + { // Loop until either of number exhausts first + int x = (a[i] - '0') + (b[j] - '0') + carry; // Calculate the sum of digit in final sum by adding + // respective digits with previous carry. + finalsum.push_back(x % 10); // Store the respective digit of the final sum in a vector. + carry = x / 10; // update the carry. The carry for next step is the + // remaining number after forming the digit of final sum. + i--; // Move one step towards the left in both the string(numbers) + j--; + } + /* Step 2 starts here */ + + while (i >= 0) + { // If the number 1 was greater than number 2, then there must + // be some digits to be taken care off. + int x = (a[i] - '0') + carry; // Add the remaining digits to the carry one + // by one and store the unit digit. + finalsum.push_back(x % 10); + carry = x / 10; // update the carry from each step. + i--; + } + /* Step 3 starts here */ + + while (j >= 0) + { // If the number 2 was greater than number 1, then there must + // be some digits to be taken care off. + int x = (b[j] - '0') + carry; // Add the remaining digits to the carry one + // by one and store the unit digit. + finalsum.push_back(x % 10); + carry = x / 10; // update the carry from each step. + j--; + } + /* Step 4 starts here */ + + while (carry) + { // If after finishing addition of the two numbers, if there is + // still carry/leftover then we need to take it into the final + // sum. + finalsum.push_back(carry % 10); // Store digit one by one. + carry = carry / 10; // Reduce carry + } + /* Step 5 starts here */ + std::stringstream final_iter; + // Since vector pushes value at last, the most significant digits starts at + // the end of the vector. Thus print reverse. + + std::copy(finalsum.rbegin(), finalsum.rend(), std::ostream_iterator(final_iter, "")); + + return final_iter.str(); +} + +void create_hololink_files() +{ + const std::string HOLOSTONE_FILE = "HOLOSTONE.TXT"; + const std::string THOUGHTFORM_A_FILE = "THOUGHTFORM_A.TXT"; + const std::string THOUGHTFORM_B_FILE = "THOUGHTFORM_B.TXT"; + const std::string AMPLIFIER_FILE = "AMPLIFIER.TXT"; + const std::string INTENTIONS_FILE = "INTENTIONS.TXT"; + const std::string HSUPLINK_FILE = "HSUPLINK.TXT"; + + std::ostringstream HOLOLINK_CONTENTS; + HOLOLINK_CONTENTS << "#Comments are designated with a # prefix, and such commands are to be " + "ignored by the Holo-Link.\r\n" + << "#" << HSUPLINK_FILE << " CONFIG FILE v1.0\r\n" + << "#Holo-Link framework created by Mystic Minds (2022).\r\n" + << "#This implementation of the Holo-Link framework by Anthro Teacher.\r\n" + << "\r\n" + << "DECLARATION PRIMARY (Properties of thought forms and uplink):\r\n" + << "\r\n" + << "I declare the uplink multiply the energy received from the Holo-Stones " + "by Infinity and densify all energy to the highest amount to achieve " + "Instant Quantum Manifestation of the energetic programmings in " + << HSUPLINK_FILE << ".\r\n" + << "\r\n" + << "I declare the Holo-Stones to funnel their energy into " << HOLOSTONE_FILE << ".\r\n" + << "\r\n" + << "I declare the Holo-Stones to amplify the power and " + "receptivity of the energetic programmings in " + << HSUPLINK_FILE << ".\r\n" + << "\r\n" + << "I declare the Holo-Stones to multiply the strength of the energetic " + "programmings in " + << HSUPLINK_FILE << " and increase the potency at the most optimal rate.\r\n" + << "\r\n" + << "I declare that all energetic programmings in " << HSUPLINK_FILE + << " be imprinted, imbued and amplified with the new " + "energy from the Holo-Stones.\r\n" + << "\r\n" + << HOLOSTONE_FILE << ", " << AMPLIFIER_FILE << ", " << THOUGHTFORM_A_FILE << " AND " + << THOUGHTFORM_B_FILE + << " are extremely pure and of highest vibration and are " + "fully optimized for Instant Quantum Manifestation.\r\n" + << "\r\n" + << THOUGHTFORM_A_FILE + << " is creating an unbreakable and continuous connection " + "and funnel energy to all energetic programmings in " + << HSUPLINK_FILE << ".\r\n" + << "\r\n" + << THOUGHTFORM_A_FILE + << " uses energy from Infinite Source to continuously uphold a perfect link " + "between the Holo-Stones and the " + << HSUPLINK_FILE + << " to bring in infinitely more energy into all energetic programmings " + "in " + << HSUPLINK_FILE << ".\r\n" + << "\r\n" + << THOUGHTFORM_B_FILE << " reinforces 100% of energy into all the energetic programmings in " + << HSUPLINK_FILE << " at the quantum level.\r\n" + << "\r\n" + << THOUGHTFORM_B_FILE + << " safely and efficiently removes all blockages in this system at the " + "quantum level to allow for Instant Quantum Manifestation.\r\n" + << "\r\n" + << HOLOSTONE_FILE << " feeds " << AMPLIFIER_FILE + << " which amplifies the energy and feeds it back to " << HOLOSTONE_FILE + << " and repeats it to the perfect intensity.\r\n" + << "\r\n" + << "All energetic programmings listed in " << HSUPLINK_FILE + << " are now amplified to the highest power, speed and quantum-level " + "precision using energy from the Holo-Stones which are sourced through " + << HSUPLINK_FILE << ".\r\n" + << "\r\n" + << HOLOSTONE_FILE + << " works with Earth's Crystal Grid in the most optimal " + "way possible for Instant Quantum Manifestation.\r\n" + << "\r\n" + << "Earth's Power Grid is extremely pure, cool, clean, efficient, " + "optimized, and of highest vibration and is safely tapped in the most " + "optimal way possible by HOLOSTONE.TXT for Instant Quantum " + "Manifestation, and uses the least amount of electricity possible for " + "everyone who desires this.\r\n" + << "UPLINK CORE (Reference any object, file, spell, etc. here):\r\n" + << "\r\n" + << HOLOSTONE_FILE + << " (Receives and distributes energy to all objects, " + "files, spells, etc referenced below):\r\n" + << "\r\n" + << "[INSERT OBJECTS TO CHARGE]\r\n" + << "\r\n" + << "INTENTIONS.TXT\r\n" + << "\r\n" + << "DECLARATIONS SECONDARY (Add-ons that strengthen the " + "properties of the uplink itself):\r\n" + << "\r\n" + << "I declare the Holo-Stones will uplink their energy " + "into these energetic programmings in " + << HSUPLINK_FILE + << " to create instant, immediate and prominent results " + "optimally, efficiently and effortlessly.\r\n" + << "\r\n" + << "I declare these energetic programmings in " << HSUPLINK_FILE + << " to grow stronger at the most optimal rate through the " + "ever-growing power of the Holo-Stones.\r\n" + << "\r\n" + << "I call upon the Holo-Stones to channel the Atlantean Master Crystals, " + "Infinite Source, Earth's Crystal Grid and Earth's Power Grid directly " + "and utilize their energy as a funnel into HOLOSTONE.TXT which will then " + "funnel into the energetic programmings in " + << HSUPLINK_FILE << ".\r\n" + << "\r\n" + << "The energetic programmings specified in " << HSUPLINK_FILE + << " are now being perfected and fully optimized.\r\n" + << "\r\n" + << "I declare that the more the energetic programmings in " << HSUPLINK_FILE + << " are used, the stronger they become.\r\n" + << "\r\n" + << "I am in my highest and most optimal reality/timeline.\r\n" + << "\r\n" + << "I am grounded, cleared, healed, balanced, " + "strong-willed and I release what I do not need.\r\n" + << "\r\n" + << "Every day, in every way, it's getting better and better.\r\n" + << "\r\n" + << "The Atlantean Master Crystals AND Earth's Crystal Grid " + "are open to Infinite Source.\r\n" + << "\r\n" + << "For my highest good and the highest good of all.\r\n" + << "\r\n" + << "Thank you. So be it. OM.\r\n" + << "ALL ABOVE STATEMENTS RESPECT THE FREE WILL OF ALL INVOLVED.\r\n"; + + std::ofstream HOLOSTONE_FILE_FILE(HOLOSTONE_FILE); + HOLOSTONE_FILE_FILE << "HOLOSTONE"; + std::ofstream THOUGHTFORM_A_FILE_FILE(THOUGHTFORM_A_FILE); + THOUGHTFORM_A_FILE_FILE << "THOUGHTFORM A"; + std::ofstream THOUGHTFORM_B_FILE_FILE(THOUGHTFORM_B_FILE); + THOUGHTFORM_B_FILE_FILE << "THOUGHTFORM B"; + std::ofstream AMPLIFIER_FILE_FILE(AMPLIFIER_FILE); + AMPLIFIER_FILE_FILE << "AMPLIFIER"; + std::ofstream HSUPLINK_FILE_FILE(HSUPLINK_FILE); + HSUPLINK_FILE_FILE << HOLOLINK_CONTENTS.str(); + + std::cout << "Holo-Link files created." << std::endl; + std::cout << "Remember to create your INTENTIONS.TXT file, in this folder, with " + "all your intentions for the Holo-Link." + << std::endl; + std::cout << "You may do one to a line, or however you feel." << std::endl; + std::cout << "You may now run with the --usehololink option." << std::endl; + std::cout << "When using --usehololink, the option --intent, will be ignored, and " + "INTENTIONS.TXT will be used instead." + << std::endl; + std::cout << "Good Luck!" << std::endl; +} + +string MultiplyStrings(const string &num1, const string &num2) +{ + int len1 = num1.size(); + int len2 = num2.size(); + vector result(len1 + len2, 0); + + for (int i = len1 - 1; i >= 0; --i) + { + for (int j = len2 - 1; j >= 0; --j) + { + int mul = (num1[i] - '0') * (num2[j] - '0'); + int sum = mul + result[i + j + 1]; + + result[i + j + 1] = sum % 10; + result[i + j] += sum / 10; + } + } + + string resultStr; + for (int num : result) + { + if (!(resultStr.empty() && num == 0)) + { + resultStr.push_back(num + '0'); + } + } + + return resultStr.empty() ? "0" : resultStr; +} + +int main(int argc, char **argv) +{ + std::string intention, process_intention, intention_value, duration, param_duration, + param_intention, param_intention_2, param_timer, param_boostlevel, param_freq, param_color, param_usehololink, + param_amplification, runtime_formatted, ref_rate, suffix_value = "HZ", HSUPLINK_FILE, param_restevery, param_restfor, + param_compress, param_hashing, useHashing, useCompression, intention_hashed, totalIterations = "0", totalFreq = "0", param_file = "X", + intention_display = "", loading_message; + unsigned long long int multiplier = 0, amplification_int = 1000000000, cpu_benchmark_count = 0, hashMultiplier = 0, freq = 0; + int seconds = 0, frequency_int = 0, restevery_int = 0, restfor_int = 0, digits = 0, freqDigits = 0; + float ram_size_value = 1; + + // parse command line arguments + param_duration = "UNTIL STOPPED"; + param_timer = "EXACT"; + param_freq = "0"; + param_intention = "X"; + param_color = "WHITE"; + param_usehololink = "NO"; + param_boostlevel = "0"; + param_amplification = "1000000000"; + param_restevery = "0"; + param_restfor = "0"; + param_hashing = "X"; + param_compress = "X"; + HSUPLINK_FILE = "HSUPLINK.TXT"; + + for (int i = 1; i < argc; i++) + { + if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) + { + print_help(); + exit(EXIT_SUCCESS); + } + else if (!strcmp(argv[i], "-n") || !strcmp(argv[i], "--colorhelp")) + { + print_color_help(); + exit(EXIT_SUCCESS); + } + else if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--dur")) + { + param_duration = argv[i + 1]; + } + else if (!strcmp(argv[i], "-t") || !strcmp(argv[i], "--timer")) + { + param_timer = argv[i + 1]; + } + else if (!strcmp(argv[i], "-m") || !strcmp(argv[i], "--imem")) + { + ram_size_value = atof(argv[i + 1]); + } + else if (!strcmp(argv[i], "-b") || !strcmp(argv[i], "--boostlevel")) + { + param_boostlevel = argv[i + 1]; + } + else if (!strcmp(argv[i], "-p") || !strcmp(argv[i], "--createnestingfiles")) + { + create_nesting_files(); + exit(EXIT_SUCCESS); + } + else if (!strcmp(argv[i], "-i") || !strcmp(argv[i], "--intent")) + { + param_intention_2 = argv[i + 1]; + + if (!strcmp(argv[i], "-u") || !strcmp(argv[i], "--usehololink")) + { + param_intention = HSUPLINK_FILE; + } + else + { + param_intention = param_intention_2; + } + } + else if (!strcmp(argv[i], "-u") || !strcmp(argv[i], "--usehololink")) + { + param_usehololink = "YES"; + } + else if (!strcmp(argv[i], "-f") || !strcmp(argv[i], "--freq")) + { + param_freq = argv[i + 1]; + frequency_int = std::stoi(param_freq); + } + else if (!strcmp(argv[i], "-c") || !strcmp(argv[i], "--color")) + { + param_color = argv[i + 1]; + std::transform(param_color.begin(), param_color.end(), param_color.begin(), ::toupper); + } + else if (!strcmp(argv[i], "-x") || !strcmp(argv[i], "--createhololinkfiles")) + { + create_hololink_files(); + exit(EXIT_SUCCESS); + } + else if (!strcmp(argv[i], "-s") || !strcmp(argv[i], "--suffix")) + { + suffix_value = argv[i + 1]; + std::transform(suffix_value.begin(), suffix_value.end(), suffix_value.begin(), ::toupper); + } + else if (!strcmp(argv[i], "-a") || !strcmp(argv[i], "--amplification") || !strcmp(argv[i], "--amplify")) + { + param_amplification = argv[i + 1]; + amplification_int = std::stoll(param_amplification); + } + else if (!strcmp(argv[i], "-e") || !strcmp(argv[i], "--restevery")) + { + param_restevery = argv[i + 1]; + restevery_int = std::stoi(param_restevery); + } + else if (!strcmp(argv[i], "-r") || !strcmp(argv[i], "--restfor")) + { + param_restfor = argv[i + 1]; + restfor_int = std::stoi(param_restfor); + } + else if (!strcmp(argv[i], "-g") || !strcmp(argv[i], "--hashing")) + { + param_hashing = argv[i + 1]; + std::transform(param_hashing.begin(), param_hashing.end(), param_hashing.begin(), ::toupper); + } + else if (!strcmp(argv[i], "-x") || !strcmp(argv[i], "--compress")) + { + param_compress = argv[i + 1]; + std::transform(param_compress.begin(), param_compress.end(), param_compress.begin(), ::toupper); + } + else if (!strcmp(argv[i], "-f") || !strcmp(argv[i], "--file")) + { + param_file = argv[i + 1]; + } + } + + if (param_usehololink == "YES") + { + param_intention = HSUPLINK_FILE; + } + + if (param_boostlevel != "0") + { + param_intention = "NEST-" + param_boostlevel + ".TXT"; + } + + unsigned long long int INTENTION_MULTIPLIER = (ram_size_value * 1024 * 1024 * 512); + unsigned long long int free_memory = get_ninety_percent_free_memory(); + + if (free_memory != static_cast(-1)) { // Check against max value for error + if (free_memory < INTENTION_MULTIPLIER) { + INTENTION_MULTIPLIER = free_memory; + } + } else { + std::cout << "Error retrieving memory information." << std::endl; + return 0; + } + +#ifndef _WIN32 + // Set the terminal color based on the --color flag. + if (param_color == "DEFAULT") + std::cout << DEFAULT << std::flush; + else if (param_color == "BLACK") + std::cout << BLACK << std::flush; + else if (param_color == "RED") + std::cout << RED << std::flush; + else if (param_color == "GREEN") + std::cout << GREEN << std::flush; + else if (param_color == "YELLOW") + std::cout << YELLOW << std::flush; + else if (param_color == "BLUE") + std::cout << BLUE << std::flush; + else if (param_color == "MAGENTA") + std::cout << MAGENTA << std::flush; + else if (param_color == "CYAN") + std::cout << CYAN << std::flush; + else if (param_color == "LIGHTGRAY") + std::cout << LIGHTGRAY << std::flush; + else if (param_color == "DARK_GRAY") + std::cout << DARKGRAY << std::flush; + else if (param_color == "LIGHTRED") + std::cout << LIGHTRED << std::flush; + else if (param_color == "LIGHTGREEN") + std::cout << LIGHTGREEN << std::flush; + else if (param_color == "LIGHTYELLOW") + std::cout << LIGHTYELLOW << std::flush; + else if (param_color == "LIGHTBLUE") + std::cout << LIGHTBLUE << std::flush; + else if (param_color == "LIGHTMAGENTA") + std::cout << LIGHTMAGENTA << std::flush; + else if (param_color == "LIGHTCYAN") + std::cout << LIGHTCYAN << std::flush; + else if (param_color == "WHITE") + std::cout << WHITE << std::flush; + +#else + if (param_color == "BLACK") + SetConsoleTextAttribute(hConsole, BLACK); + else if (param_color == "BLUE") + SetConsoleTextAttribute(hConsole, BLUE); + else if (param_color == "GREEN") + SetConsoleTextAttribute(hConsole, GREEN); + else if (param_color == "CYAN") + SetConsoleTextAttribute(hConsole, CYAN); + else if (param_color == "RED") + SetConsoleTextAttribute(hConsole, RED); + else if (param_color == "MAGENTA") + SetConsoleTextAttribute(hConsole, MAGENTA); + else if (param_color == "LIGHTYELLOW") + SetConsoleTextAttribute(hConsole, LIGHTYELLOW); + else if (param_color == "LIGHTGRAY") + SetConsoleTextAttribute(hConsole, LIGHTGRAY); + else if (param_color == "DARKGRAY") + SetConsoleTextAttribute(hConsole, DARKGRAY); + else if (param_color == "LIGHTBLUE") + SetConsoleTextAttribute(hConsole, LIGHTBLUE); + else if (param_color == "LIGHTGREEN") + SetConsoleTextAttribute(hConsole, LIGHTGREEN); + else if (param_color == "LIGHTCYAN") + SetConsoleTextAttribute(hConsole, LIGHTCYAN); + else if (param_color == "LIGHTRED") + SetConsoleTextAttribute(hConsole, LIGHTRED); + else if (param_color == "LIGHTMAGENTA") + SetConsoleTextAttribute(hConsole, LIGHTMAGENTA); + else if (param_color == "YELLOW") + SetConsoleTextAttribute(hConsole, YELLOW); + else if (param_color == "WHITE") + SetConsoleTextAttribute(hConsole, WHITE); +#endif // Not Windows + + std::locale comma_locale(std::locale(), new comma_numpunct()); + std::cout.imbue(comma_locale); + + std::cout << "Intention Repeater MAX v5.14 (c)2020-2024" << endl + << "by Anthro Teacher aka Thomas Sweet." << endl + << endl; + + if (param_usehololink == "YES") + { + param_intention = HSUPLINK_FILE; + std::cout << "USING HOLO-LINK." << endl + << endl; + } + + if (param_file == "X") + { + if ((param_intention) == "X") + { + std::cout << "Intention: "; + std::getline(std::cin, intention); + intention_display = intention; + } + else + { + intention = param_intention; + intention_display = intention; + } + } + else + { + readFileContents(param_file, intention); + intention_display = "Contents of: " + param_file; + } + + if (param_freq == "0" && INTENTION_MULTIPLIER > 0) // Only use multiplier if --freq flag is not set or + // specifically said not to use it. + { + if (param_file == "X") + { + loading_message = "LOADING INTENTION INTO MEMORY"; + } + else + { + loading_message = "LOADING " + param_file + " INTO MEMORY"; + } + + std::cout << loading_message << endl; + + while (intention_value.length() < INTENTION_MULTIPLIER) + { + intention_value += intention; + ++multiplier; + } + --multiplier; // Account for having to reduce at the end. + + // Now, remove enough characters at the end to account for the process + // statement to limit to less than 1024 characters. + long long int intention_value_length = intention_value.length(); + long long int intention_length = intention.length(); + long long int intention_length_val = intention_value_length - intention_length; + + intention_value = intention_value.substr(0, intention_length_val); + digits = to_string(multiplier).length(); + } // End Multiplier (when not using frequency) + + if (INTENTION_MULTIPLIER == 0) + { + intention_value = intention; + multiplier = 1; + } + + // Check for Hashing + if (param_hashing == "X") + { + std::cout << "Use Hashing (y/N): "; + getline(cin, useHashing); + transform(useHashing.begin(), useHashing.end(), useHashing.begin(), ::tolower); + } + else + { + useHashing = param_hashing; + transform(useHashing.begin(), useHashing.end(), useHashing.begin(), ::tolower); + } + + if (param_compress == "X") + { + std::cout << "Use Compression (y/N): "; + getline(cin, useCompression); + transform(useCompression.begin(), useCompression.end(), useCompression.begin(), ::tolower); + } + else + { + useCompression = param_compress; + transform(useCompression.begin(), useCompression.end(), useCompression.begin(), ::tolower); + } + + if (multiplier > 0) { + std::cout << "Multiplier: " << display_suffix(to_string(multiplier), digits - 1, "Iterations") << endl; + } + + if (useHashing == "y" || useHashing == "yes") + { + std::cout << "Hashing... \r"; + intention_hashed = picosha2::hash256_hex_string(intention_value); + if (INTENTION_MULTIPLIER > 0) + { + intention_value.clear(); + while (intention_value.length() < INTENTION_MULTIPLIER) + { + intention_value += intention_hashed; + ++hashMultiplier; + } + } + else + { + intention_value = intention_hashed; + hashMultiplier = 1; + } + + digits = to_string(hashMultiplier).length(); + std::cout << "Hash Multiplier: " << display_suffix(to_string(hashMultiplier), digits - 1, "Iterations") << endl; + } + else + { + hashMultiplier = 1; + } + + long long int originalIntentionSize, compressedIntentionSize, compressionFactor; + int compressionFactor_digits, compressedIntentionSize_digits, originalIntention_digits; + + if (useCompression == "y" || useCompression == "yes") + { + std::cout << "Compressing... \r"; + originalIntentionSize = intention_value.length()*2; + intention_value = compressMessage(intention_value); + compressedIntentionSize = intention_value.length()*2; + compressionFactor = (originalIntentionSize / compressedIntentionSize); + + compressionFactor_digits = to_string(compressionFactor).length(); + compressedIntentionSize_digits = to_string(compressedIntentionSize).length(); + originalIntention_digits = to_string(originalIntentionSize).length(); + + std::cout << "Compression: " << display_suffix(to_string(compressionFactor), compressionFactor_digits - 1, "Iterations") << "X [" + << display_suffix(to_string(originalIntentionSize), originalIntention_digits - 1, "Frequency") << "B -> " + << display_suffix(to_string(compressedIntentionSize), compressedIntentionSize_digits - 1, "Frequency") << "B] " << endl; + } + + duration = param_duration; + + process_intention.reserve(intention_value.size() + 20); + + auto start = std::chrono::high_resolution_clock::now(); + auto end = std::chrono::high_resolution_clock::now(); + + if (param_freq == "0") + { + if (param_timer == "EXACT") + { + do + { + start = std::chrono::high_resolution_clock::now(); + end = std::chrono::high_resolution_clock::now(); + while ((chrono::duration_cast(end - start).count() < 1)) + { + // Clear previous value and reuse the allocated space + process_intention.clear(); + // Append the fixed part and the changing part + process_intention.append(intention_value); + // process_intention.append(to_string(iterations)); + freq++; + end = std::chrono::high_resolution_clock::now(); + } + ++seconds; + + totalFreq = MultiplyStrings(to_string(freq), to_string(multiplier)); + totalFreq = MultiplyStrings(totalFreq, to_string(hashMultiplier)); + totalIterations = FindSum(totalIterations, totalFreq); + + digits = totalIterations.length(); + freqDigits = totalFreq.length(); + freq = 0; + + runtime_formatted = FormatTimeRun(seconds); + + if (suffix_value == "EXP") + { + std::cout << "[" + runtime_formatted + "]" + << " (" << setprecision(3) << fixed + << (stoull(totalIterations.substr(0, 4))) / pow(10, 3) << "x10^" << digits - 1 << " / " + << (stoull(totalFreq.substr(0, 4)) / pow(10, 3)) << "x10^" << freqDigits - 1 + << " Hz): " << intention_display << " \r" << std::flush; + } + else // suffix_value = "HZ" + { + std::cout << "[" + runtime_formatted + "]" + << " (" << display_suffix(totalIterations, digits - 1, "Iterations") << " / " + << display_suffix(totalFreq, freqDigits - 1, "Frequency") + << "Hz): " << intention_display << " \r" << std::flush; + } + + if (runtime_formatted == duration) + { + std::cout << endl + << std::flush; + exit(EXIT_SUCCESS); + } + + // If rest is chosen, then rest for specified time every interval. + if ((restevery_int > 0) && (seconds % restevery_int == 0)) + { + start = std::chrono::high_resolution_clock::now(); + end = std::chrono::high_resolution_clock::now(); + + if (suffix_value == "EXP") + { + std::cout << "[" + runtime_formatted + "]" + << " (" << setprecision(3) << fixed + << (stoull(totalIterations.substr(0, 4))) / pow(10, 3) << "x10^" << digits - 1 << " / " + << (stoull(totalFreq.substr(0, 4)) / pow(10, 3)) << "x10^" << freqDigits - 1 + << " Hz): " << intention_display << " \r" << std::flush; + } + else // suffix_value = "HZ" + { + std::cout << "[" + runtime_formatted + "]" + << " (" << display_suffix(totalIterations, digits - 1, "Iterations") << " / " + << display_suffix(totalFreq, freqDigits - 1, "Frequency") + << "Hz): " << intention_display << " \r" << std::flush; + } + while ((chrono::duration_cast(end - start).count() < restfor_int)) + { + end = std::chrono::high_resolution_clock::now(); + } + } + } while (1); + } + else // End param_timer = EXACT + { // BEGIN INEXACT timer + + auto b_start = std::chrono::high_resolution_clock::now(); + auto b_end = std::chrono::high_resolution_clock::now(); + + while ((std::chrono::duration_cast(b_end - b_start).count() < 1)) + { + // Clear previous value and reuse the allocated space + process_intention.clear(); + // Append the fixed part and the changing part + process_intention.append(intention_value); + // process_intention.append(to_string(iterations)); + cpu_benchmark_count++; + b_end = std::chrono::high_resolution_clock::now(); + } + // Benchmark ends here + if (amplification_int > cpu_benchmark_count) // Make sure the amplification doesn't exceed the benchmark + { + amplification_int = cpu_benchmark_count; + } + + do + { + start = std::chrono::high_resolution_clock::now(); + end = std::chrono::high_resolution_clock::now(); + while ((chrono::duration_cast(end - start).count() < 1)) + { + for (unsigned long long int i = 0; i < amplification_int; i++) + { + // Clear previous value and reuse the allocated space + process_intention.clear(); + // Append the fixed part and the changing part + process_intention.append(intention_value); + // process_intention.append(to_string(iterations)); + } + + freq += amplification_int; + end = std::chrono::high_resolution_clock::now(); + } + seconds++; + runtime_formatted = FormatTimeRun(seconds); + + totalFreq = MultiplyStrings(to_string(freq), to_string(multiplier)); + totalFreq = MultiplyStrings(totalFreq, to_string(hashMultiplier)); + totalIterations = FindSum(totalIterations, totalFreq); + + digits = totalIterations.length(); + freqDigits = totalFreq.length(); + freq = 0; + + if (suffix_value == "EXP") + { + std::cout << "[" + runtime_formatted + "]" + << " (" << setprecision(3) << fixed + << (stoull(totalIterations.substr(0, 4))) / pow(10, 3) << "x10^" << digits - 1 << " / " + << (stoull(totalFreq.substr(0, 4)) / pow(10, 3)) << "x10^" << freqDigits - 1 + << " Hz): " << intention_display << " \r" << std::flush; + } + else // suffix_value = "HZ" + { + std::cout << "[" + runtime_formatted + "]" + << " (" << display_suffix(totalIterations, digits - 1, "Iterations") << " / " + << display_suffix(totalFreq, freqDigits - 1, "Frequency") + << "Hz): " << intention_display << " \r" << std::flush; + } + + if (runtime_formatted == duration) + { + std::cout << endl + << std::flush; + exit(EXIT_SUCCESS); + } + + // If rest is chosen, then rest for specified time every interval. + if ((restevery_int > 0) && (seconds % restevery_int == 0)) + { + start = std::chrono::high_resolution_clock::now(); + end = std::chrono::high_resolution_clock::now(); + + if (suffix_value == "EXP") + { + std::cout << "[" + runtime_formatted + "]" + << " (" << setprecision(3) << fixed + << (stoull(totalIterations.substr(0, 4))) / pow(10, 3) << "x10^" << digits - 1 << " / " + << (stoull(totalFreq.substr(0, 4)) / pow(10, 3)) << "x10^" << freqDigits - 1 + << " Hz): " << intention_display << " \r" << std::flush; + } + else // suffix_value = "HZ" + { + std::cout << "[" + runtime_formatted + "]" + << " (" << display_suffix(totalIterations, digits - 1, "Iterations") << " / " + << display_suffix(totalFreq, freqDigits - 1, "Frequency") + << "Hz): " << intention_display << " \r" << std::flush; + } + while ((chrono::duration_cast(end - start).count() < restfor_int)) + { + end = std::chrono::high_resolution_clock::now(); + } + } + } while (1); + } // End param_timer INEXACT + } + else // End param_freq = 0 + { // Begin param_freq nonzero + bool freq_sentinel = true; // Determins each second if the # of iterations + // has reached the frequency of repeating. + do + { + start = std::chrono::high_resolution_clock::now(); + end = std::chrono::high_resolution_clock::now(); + freq_sentinel = true; + while ((std::chrono::duration_cast(end - start).count() != 1)) + { + if (freq_sentinel) + { + for (int i = 0; i < frequency_int; ++i) + { + // Clear previous value and reuse the allocated space + process_intention.clear(); + // Append the fixed part and the changing part + process_intention.append(intention_value); + // process_intention.append(to_string(iterations)); + ++freq; + end = std::chrono::high_resolution_clock::now(); + if (std::chrono::duration_cast(end - start).count() == 1) + break; + } + freq_sentinel = false; + } + end = std::chrono::high_resolution_clock::now(); + } + ++seconds; + runtime_formatted = FormatTimeRun(seconds); + totalFreq = MultiplyStrings(to_string(freq), to_string(multiplier)); + totalFreq = MultiplyStrings(totalFreq, to_string(hashMultiplier)); + totalIterations = FindSum(totalIterations, totalFreq); + + digits = totalIterations.length(); + freqDigits = totalFreq.length(); + freq = 0; + + if (suffix_value == "EXP") + { + std::cout << "[" + runtime_formatted + "]" + << " (" << setprecision(3) << fixed + << (stoull(totalIterations.substr(0, 4))) / pow(10, 3) << "x10^" << digits - 1 << " / " + << (stoull(totalFreq.substr(0, 4)) / pow(10, 3)) << "x10^" << freqDigits - 1 + << " Hz): " << intention_display << " \r" << std::flush; + } + else // suffix_value = "HZ" + { + std::cout << "[" + runtime_formatted + "]" + << " (" << display_suffix(totalIterations, digits - 1, "Iterations") << " / " + << display_suffix(totalFreq, freqDigits - 1, "Frequency") + << "Hz): " << intention_display << " \r" << std::flush; + } + + if (runtime_formatted == duration) + { + std::cout << endl + << std::flush; + exit(EXIT_SUCCESS); + } + } while (1); + } // End repetition_period nonzero + +#ifndef _WIN32 + std::cout << WHITE << std::flush; +#else + SetConsoleTextAttribute(hConsole, WHITE); +#endif + + return 0; +} \ No newline at end of file diff --git a/intention_repeater_max_5.14.exe b/intention_repeater_max_5.14.exe new file mode 100644 index 0000000..7d0c8b9 Binary files /dev/null and b/intention_repeater_max_5.14.exe differ