Madness Gives A Talk

by · Published · Updated

Since the last post, i’ve had 0 comments… Something is amiss!

I had to refrain from calling this “Madness Talks” because of how the Mob might take that. This is the result of some thinking, I will get straight to the point. First I thought, the crack energy generated by the recent program I created must be significant, it must be alot of crack. Then, giving it to the Japanese as I had done in the last post, I drifted off towards how might I be able to help the Combine Overwatch this time? I thought, their Elite Soldier must take alot of crack to keep going, and then I thought, I can combine these two ideas: The lot of crack (copied), and the Combine Elite’s demand for the crack, I can give them a copy of it!

So that led me to thinking that i’ve got to get everybody a copy of it, eventually it got down to each and every individual unit, (i.e. every person), and that I must give each unit of mine this specific amount of crack. I next thought, i’ve got to amplify this amount of crack, and since the program hasn’t yet delivered it’s payload, perhaps this is a special way of going about things, that may result in profit for our Benefactors.

Here is the completed program: (if you don’t know C++, possibly don’t even bother reading the stuff in yellow, and skip to below it)

C++

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---

// THE JAMES DEAN PROGRAM!

// VERSION: 002.06 (.REVISION, OR, 206 REVISIONS TOTAL)

// TODO LIST

// 1) ADD REAL ARBITRARY COMPONENT DEVICES (LOOK AT THE PREVIOUS JAMES DEAN)
// 2) ADD CHRONO TIMING FOR MATRIX CREATION (*DONE)
// 3) ADD GLOBAL CHRONO TIMING (*DONE)
// 4) ADD OUTPUT (STD::COUT) FOR THE INDIVIDUAL MATRICES

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// RECORD OF FATE

// 1930019299 people received data from 002.06-A

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// STANDARD INCLUDES

#include <iostream>
#include <vector>
#include <string>
#include <bitset>
#include <fstream>

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// THREAD INCLUDES

#include <thread>

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// TIME INCLUDES

#include <chrono>

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// LOCKING

#include <mutex>

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// RANDOM INCLUDES

#include <random>
#include "random/pcg_random.hpp"
#include "random/pcg_extras.hpp"
#include "random/pcg_uint128.hpp"

// -------------------------------====++====-----------------------------------
// MULTIPRECISION INCLUDES

 #include <boost/multiprecision/cpp_int.hpp>
 
// -------------------------------====++====-----------------------------------
// USING DECLARATIVES

using boost::multiprecision::cpp_int;

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// CLASSES

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// FORWARD DECLARED CLASSES

class positive_hex;
class data_buff;
class hash_table;
class arbitrary_component_device;
class technical;

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// JAMES DEAN DATA

class james_dean_data
{
	protected:
	
		cpp_int local_system_id = 0;
		
		cpp_int local_production_id = 0;
		cpp_int local_data_id = 0;
		cpp_int local_class_id = 0;
		cpp_int local_type_id = 0;
		
		std::vector<std::vector<cpp_int>> local_random_matrix;
		std::vector<std::vector<cpp_int>> local_mod_random_matrix;
		
		std::vector<std::vector<positive_hex*>> local_positive_hex_matrix;
		std::vector<std::vector<data_buff*>> local_data_buff_matrix;
		std::vector<std::vector<arbitrary_component_device*>> arbitrary_component_device_matrix;
		std::vector<std::vector<hash_table*>> local_hash_table_matrix;
		std::vector<std::vector<technical*>> local_technical_matrix;
		
		void set_technical_matrix(std::vector<std::vector<technical*>> technical_input)
		{
			local_technical_matrix = technical_input;
		}
		
		void set_arbitrary_component_device_matrix(std::vector<std::vector<arbitrary_component_device*>> arbitrary_component_device_input)
		{
			arbitrary_component_device_matrix = arbitrary_component_device_input;
		}
		
		void set_local_positive_hex_matrix(std::vector<std::vector<positive_hex*>> positive_hex_input)
		{
			local_positive_hex_matrix = positive_hex_input;
		}
		
		void set_local_data_buff_matrix(std::vector<std::vector<data_buff*>> data_buff_input)
		{
			local_data_buff_matrix = data_buff_input;
		}
		
		void set_local_random_matrix(std::vector<std::vector<cpp_int>> random_matrix_input)
		{
			local_random_matrix = random_matrix_input;
		}
		
		void set_local_mod_random_matrix(std::vector<std::vector<cpp_int>> mod_random_matrix_input)
		{
			local_mod_random_matrix = mod_random_matrix_input;
		}
		
		void set_local_system_id(cpp_int system_id_input)
		{
			local_system_id = system_id_input;
		}
		
		void set_local_production_id(cpp_int production_id_input)
		{
			local_production_id = production_id_input;
		}
		
		void set_local_data_id(cpp_int data_id_input)
		{
			local_data_id = data_id_input;
		}
		
		void set_local_class_id(cpp_int class_id_input)
		{
			local_class_id = class_id_input;
		}
		
		void set_local_type_id(cpp_int type_id_input)
		{
			local_type_id = type_id_input;
		}
		
		void set_local_hash_table_matrix(std::vector<std::vector<hash_table*>> hash_table_input)
		{
			local_hash_table_matrix = hash_table_input;
		}
		
	public:
	
		void call_set_technical_matrix(std::vector<std::vector<technical*>> call_technical_input)
		{
			set_technical_matrix(call_technical_input);
		}
	
		void call_set_local_hash_table_matrix(std::vector<std::vector<hash_table*>> call_hash_table_input)
		{
			set_local_hash_table_matrix(call_hash_table_input);
		}
	
		void call_set_arbitrary_component_device_matrix(std::vector<std::vector<arbitrary_component_device*>> call_arbitrary_component_device_input)
		{
			set_arbitrary_component_device_matrix(call_arbitrary_component_device_input);
		}
		
		void call_set_local_positive_hex_matrix(std::vector<std::vector<positive_hex*>> call_positive_hex_input)
		{
			set_local_positive_hex_matrix(call_positive_hex_input);
		}
		
		void call_set_local_data_buff_matrix(std::vector<std::vector<data_buff*>> call_data_buff_input)
		{
			set_local_data_buff_matrix(call_data_buff_input);
		}
		
		void call_set_local_random_matrix(std::vector<std::vector<cpp_int>> call_random_matrix_input)
		{
			set_local_random_matrix(call_random_matrix_input);
		}
		
		void call_set_local_mod_random_matrix(std::vector<std::vector<cpp_int>> call_mod_random_matrix_input)
		{
			set_local_mod_random_matrix(call_mod_random_matrix_input);
		}
	
		void call_set_local_system_id(cpp_int call_system_id_input)
		{
			set_local_system_id(call_system_id_input);
		}
		
		void call_set_local_production_id(cpp_int call_production_id_input)
		{
			set_local_production_id(call_production_id_input);
		}
		
		void call_set_local_data_id(cpp_int call_data_id_input)
		{
			set_local_data_id(call_data_id_input);
		}
		
		void call_set_local_class_id(cpp_int call_class_id_input)
		{
			set_local_class_id(call_class_id_input);
		}
		
		void call_set_local_type_id(cpp_int call_type_id_input)
		{
			set_local_type_id(call_type_id_input);
		}
};

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// DATA BUFF

class data_buff : public james_dean_data
{
	protected:
		
	public:
	
};

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// POSITIVE HEX

class positive_hex : public james_dean_data
{
	protected:

	public:
	
};

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// HASH TABLE

class hash_table : public james_dean_data
{
	protected:
	
		std::vector<std::vector<std::string>> local_hash_table_vector;
		
		void set_local_hash_table(std::vector<std::vector<std::string>> hash_table_input)
		{
			local_hash_table_vector = hash_table_input;
		}

	public:
		
		void call_set_local_hash_table(std::vector<std::vector<std::string>> call_hash_table_input)
		{
			set_local_hash_table(call_hash_table_input);
		}
};

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// ARBITRARY COMPONENT DEVICE

class arbitrary_component_device : public james_dean_data
{
	protected:
	
	public:
	
};

// POPULUS

class civilian
{
	protected:
	
		std::vector<james_dean_data*> civilian_james_dean_matrix;
		
		cpp_int local_civilian_id = 0;
		
		void set_civilian_james_dean_matrix(std::vector<james_dean_data*> james_dean_input)
		{
			civilian_james_dean_matrix = james_dean_input;
		}
		
		void set_civilian_id(cpp_int civilian_id_input)
		{
			local_civilian_id = civilian_id_input;
		}
	
	public:
	
		void call_set_civilian_james_dean_matrix(std::vector<james_dean_data*> call_james_dean_input)
		{
			set_civilian_james_dean_matrix(call_james_dean_input);
		}
		
		void call_set_civilian_id(cpp_int call_civilian_id_input)
		{
			set_civilian_id(call_civilian_id_input);
		}
};

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// TECHNICAL
// JUST A WORD FOR CORNERING, FOLDING, JUMPING.

class technical : public james_dean_data
{
	protected:
	
		std::string name_str = "void";
		signed long long int technical_id = 0;
		
		signed long long int program_version = 0;
		signed long long int program_revision = 0;
		
		void set_program_version(signed long long int input_int)
		{
			program_version = input_int;
		}
		
		void set_program_revision(signed long long int input_int)
		{
			program_revision = input_int;
		}
		
		void set_name_str(std::string input_str)
		{
			name_str = "technical_" + std::to_string(technical_id) + "_of_" + std::to_string(program_version) + "." + std::to_string(program_revision);
		}
		
		void display_name_str()
		{
			std::cout << name_str << "\n";
		}
		
	public:
	
		void call_set_program_version(signed long long int call_input_int)
		{
			set_program_version(call_input_int);
		}
		
		void call_set_program_revision(signed long long int call_input_int)
		{
			set_program_revision(call_input_int);
		}
		
		void call_set_name_str(std::string call_input_str)
		{
			set_name_str(call_input_str);
		}
		
		void call_display_name_str()
		{
			display_name_str();
		}
	
};

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// FORWARD DECLARATIONS

std::vector<std::vector<cpp_int>> return_random_matrix(cpp_int);
std::vector<std::vector<data_buff*>> return_data_buff_matrix(cpp_int);
std::vector<std::vector<positive_hex*>> return_positive_hex_matrix(cpp_int);
std::vector<std::vector<arbitrary_component_device*>> return_arbitrary_component_device_matrix(cpp_int);
std::vector<std::vector<hash_table*>> return_hash_table_matrix(cpp_int);
std::vector<std::vector<technical*>> return_technical_matrix(cpp_int);

void create_and_populate(cpp_int);


// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// STRUCTURES

struct main_data_struct {

	cpp_int local_civilian_id = 0;
	std::mutex civilian_id_mutex;
	
	std::mutex last_run_mutex;
	bool last_run = false;
	
	cpp_int local_civil_reservation_number = 500'000'000;
	cpp_int world_population = 8'231'613'070; // June 30th, 2025 (on May 12th, 2025)
	
	cpp_int local_system_id = 0;
	std::mutex system_id_mutex;
	
	cpp_int local_production_id = 0;
	std::mutex production_id_mutex;
	
	cpp_int local_data_id = 0;
	std::mutex data_id_mutex;
	
	cpp_int local_class_id = 0;
	std::mutex class_id_mutex;
	
	cpp_int local_type_id = 0;
	std::mutex type_id_mutex;
	
	cpp_int local_random_production_id = 0;
	std::mutex random_production_id_mutex;
	
	cpp_int local_random_data_id = 0;
	std::mutex random_data_id_mutex;
	
	cpp_int local_random_class_id = 0;
	std::mutex random_class_id_mutex;
	
	cpp_int local_random_type_id = 0;
	std::mutex random_type_id_mutex;
	
	cpp_int local_mod_random_production_id = 0;
	std::mutex mod_random_production_id_mutex;
	
	cpp_int local_mod_random_data_id = 0;
	std::mutex mod_random_data_id_mutex;
	
	cpp_int local_mod_random_class_id = 0;
	std::mutex mod_random_class_id_mutex;
	
	cpp_int local_mod_random_type_id = 0;
	std::mutex mod_random_type_id_mutex;
	
	cpp_int local_data_buff_production_id = 0;
	std::mutex data_buff_production_id_mutex;
	
	cpp_int local_data_buff_data_id = 0;
	std::mutex data_buff_data_id_mutex;
	
	cpp_int local_data_buff_class_id = 0;
	std::mutex data_buff_class_id_mutex;
	
	cpp_int local_data_buff_type_id = 0;
	std::mutex data_buff_type_id_mutex;
	
	cpp_int local_positive_hex_production_id = 0;
	std::mutex positive_hex_production_id_mutex;
	
	cpp_int local_positive_hex_data_id = 0;
	std::mutex positive_hex_data_id_mutex;
	
	cpp_int local_positive_hex_class_id = 0;
	std::mutex positive_hex_class_id_mutex;
	
	cpp_int local_positive_hex_type_id = 0;
	std::mutex positive_hex_type_id_mutex;
	
	cpp_int local_arbitrary_component_device_production_id = 0;
	std::mutex arbitrary_component_device_production_id_mutex;
	
	cpp_int local_arbitrary_component_device_data_id = 0;
	std::mutex arbitrary_component_device_data_id_mutex;
	
	cpp_int local_arbitrary_component_device_class_id = 0;
	std::mutex arbitrary_component_device_class_id_mutex;
	
	cpp_int local_arbitrary_component_device_type_id = 0;
	std::mutex arbitrary_component_device_type_id_mutex;
	
	cpp_int local_hash_table_production_id = 0;
	std::mutex hash_table_production_id_mutex;
	
	cpp_int local_hash_table_data_id = 0;
	std::mutex hash_table_data_id_mutex;
	
	cpp_int local_hash_table_class_id = 0;
	std::mutex hash_table_class_id_mutex;
	
	cpp_int local_hash_table_type_id = 0;
	std::mutex hash_table_type_id_mutex;
	
	cpp_int production_target = 8;
	cpp_int data_target = 10;
	cpp_int class_target = 15;
	cpp_int type_target = 15;
	
	cpp_int random_matrix_vector_target = 25;
	
	cpp_int mod_random_matrix_vector_target = 25;
	
	
	cpp_int hash_table_matrix_vector_target = 30;
	
	cpp_int data_buff_matrix_vector_target = 20;
	
	cpp_int positive_hex_matrix_vector_target = 20;
		
	cpp_int arbitrary_component_device_matrix_vector_target = 20;
		
	std::vector<james_dean_data*> local_james_dean_vector;
	
	cpp_int total_data_counter = 0;
	cpp_int positive_hex_count = 0;
	cpp_int data_buff_count = 0;
	cpp_int arbitrary_component_device_count = 0;
	
	cpp_int positive_hex_target = 25;
	cpp_int data_buff_target = 25;
	cpp_int hash_table_target = 15;
	cpp_int random_target = 20;
	cpp_int arbitrary_component_device_target = 15;
	
	std::mutex print_mutex;
	
	std::mutex james_dean_vector_mutex;
	std::mutex data_counter_mutex;
	std::mutex technical_print_mutex;
	std::mutex data_buff_count_mutex;
	std::mutex positive_hex_count_mutex;
	std::mutex arbitrary_component_device_count_mutex;
	
	
	cpp_int technical_target = 20;
	
	
} james_dean;

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// INT MAIN

int main(int argc, char *argv[])
{
	signed long long int program_version = 002;
	signed long long int program_revision = 06;
	
	std::cout << "\n\nC++ JAMES DEAN DATA CREATOR\n\nVERSION: " << program_version << " REVISION: " << program_revision << "\n\n";
	
	std::vector<std::thread> thread_vector;
	cpp_int thread_target = 24;
	cpp_int local_thread_id = 0;
	
	bool run_program = true;
	
	while (run_program == true)
	{
		std::cout << "[main] run_program begin\n";
		
		while (thread_vector.size() < thread_target)
		{
			std::cout << "[main] thread_vector.size() = " << thread_vector.size() << "\n";
			std::cout << "[main] creating thread " << local_thread_id << "\n";
			thread_vector.emplace_back(create_and_populate, local_thread_id);
			local_thread_id = local_thread_id + 1;
		}
		
		for(signed long long int current_thread_id = 0; current_thread_id < thread_vector.size(); current_thread_id++)
		{
			thread_vector[current_thread_id].join();
		}
		
		if(james_dean.local_production_id >= james_dean.production_target)
		{
			run_program = false;
			
			std::cout << "[main] run_program now set to false (gracefully)\n";
		}
		
		if(thread_vector.size() >= thread_target)
		{
			std::cout << "[main] while loop sleep for 60 seconds, thread_vector.size() = " << thread_vector.size() << "\n";
			std::this_thread::sleep_for(std::chrono::seconds(60));
		}
	}
	
	std::cout << "\n\n\n********************\n********************\nexecution completed!\n\n";
	return(0);
}

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// FUNCTIONS
		
// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// CREATE AND POPULATE

void create_and_populate(cpp_int thread_id)
{
	std::lock_guard<std::mutex> print_lock1(james_dean.print_mutex);
	std::cout << "[" << thread_id << "] thread " << thread_id << " begin creation of james_dean_data\n";
	james_dean.print_mutex.unlock();
	
	cpp_int local_data_count = james_dean.local_production_id * james_dean.local_data_id * james_dean.local_class_id * james_dean.local_type_id;
	
	std::vector<std::vector<cpp_int>> local_random_matrix;
	std::vector<cpp_int> small_random_vector;
	
	std::vector<std::vector<cpp_int>> local_mod_random_matrix;
	std::vector<cpp_int> small_mod_random_vector;
	
	std::vector<std::vector<hash_table*>> local_hash_table_matrix;
	std::vector<hash_table*> small_hash_table_vector;
	
	std::vector<std::vector<data_buff*>> local_data_buff_matrix;
	std::vector<data_buff*> small_data_buff_vector;
	
	std::vector<std::vector<positive_hex*>> local_positive_hex_matrix;
	std::vector<positive_hex*> small_positive_hex_vector;
	
	std::vector<std::vector<arbitrary_component_device*>> local_arbitrary_component_device_matrix;
	std::vector<arbitrary_component_device*> small_arbitrary_component_device_vector;
	
	std::vector<std::vector<technical*>> local_technical_matrix;
	std::vector<technical*> small_technical_vector;
	
	while (james_dean.local_production_id < james_dean.production_target)
	{
		std::cout << "[" << thread_id << "] creating james_dean_data object #" << local_data_count << " of " << james_dean.production_target * james_dean.data_target * james_dean.class_target * james_dean.type_target << "\n";
		std::lock_guard<std::mutex> print_lock2(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] main while loop: " << james_dean.local_production_id << "/" << james_dean.production_target << "\n";
		james_dean.print_mutex.unlock();
		
		james_dean_data local_james_dean_data;
		
		std::lock_guard<std::mutex> print_lock3(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] setting id\'s for " << james_dean.local_system_id << "::";
		std::cout << james_dean.local_production_id << "/" << james_dean.production_target << "::";
		std::cout <<  james_dean.local_data_id << "/" << james_dean.data_target << "::";
		std::cout << james_dean.local_class_id << "/" << james_dean.class_target << "::";
		std::cout << james_dean.local_type_id << "/" << james_dean.type_target << "\n";
		james_dean.print_mutex.unlock();
		
		local_james_dean_data.call_set_local_system_id(james_dean.local_system_id);
		james_dean.local_system_id = james_dean.local_system_id + 1;
		
		local_james_dean_data.call_set_local_production_id(james_dean.local_production_id);
		
		local_james_dean_data.call_set_local_data_id(james_dean.local_data_id);
		
		local_james_dean_data.call_set_local_class_id(james_dean.local_class_id);
		
		local_james_dean_data.call_set_local_type_id(james_dean.local_type_id);
		
		std::lock_guard<std::mutex> local_type_lock1(james_dean.type_id_mutex);
		james_dean.local_type_id = james_dean.local_type_id + 1;
		james_dean.type_id_mutex.unlock();
		
		if(james_dean.local_type_id >= james_dean.type_target)
		{
			std::lock_guard<std::mutex> local_type_lock1(james_dean.type_id_mutex);
			james_dean.local_type_id = 0;
			james_dean.type_id_mutex.unlock();
			
			std::lock_guard<std::mutex> local_class_lock1(james_dean.class_id_mutex);
			james_dean.local_class_id = james_dean.local_class_id + 1;
			james_dean.class_id_mutex.unlock();
			
			if(james_dean.local_class_id >= james_dean.class_target)
			{
				
				std::lock_guard<std::mutex> local_class_lock2(james_dean.class_id_mutex);
				james_dean.local_class_id = 0;
				james_dean.class_id_mutex.unlock();
				
				std::lock_guard<std::mutex> local_data_lock1(james_dean.data_id_mutex);
				james_dean.local_data_id = james_dean.local_data_id + 1;
				james_dean.data_id_mutex.unlock();
				
				if(james_dean.local_data_id >= james_dean.data_target)
				{
					
					std::lock_guard<std::mutex> local_data_lock2(james_dean.data_id_mutex);
					james_dean.local_data_id = 0;
					james_dean.data_id_mutex.unlock();
					
					std::lock_guard<std::mutex> local_production_lock1(james_dean.production_id_mutex);
					james_dean.local_production_id = james_dean.local_production_id + 1;
					james_dean.production_id_mutex.unlock();
				}
			}
		}
		
		auto matrice_start_time = std::chrono::high_resolution_clock::now();
		std::lock_guard<std::mutex> print_lock4(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] creating matrices data_buff, positive_hex, random, mod_random, \n";
		std::cout << "[" << thread_id << "] hash_table, arbitrary_component_device & technical matrices\n";
		james_dean.print_mutex.unlock();
		
		auto data_buff_start_time = std::chrono::high_resolution_clock::now();
		std::lock_guard<std::mutex> print_lock5(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] creating data_buff matrix\n";
		james_dean.print_mutex.unlock();
		
		local_data_buff_matrix = return_data_buff_matrix(thread_id);
		local_james_dean_data.call_set_local_data_buff_matrix(local_data_buff_matrix);
		local_data_buff_matrix.clear();
		
		auto data_buff_end_time = std::chrono::high_resolution_clock::now();
		auto data_buff_elapsed_time = data_buff_end_time - data_buff_start_time;
		auto data_buff_nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(data_buff_elapsed_time);
		cpp_int data_buff_nanoseconds_printable = data_buff_nanoseconds.count();
		std::lock_guard<std::mutex> print_lock6(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] data_buff (" << james_dean.data_buff_target << ") creation time: " << data_buff_nanoseconds_printable << "s\n";
		james_dean.print_mutex.unlock();
		
		auto positive_hex_start_time = std::chrono::high_resolution_clock::now();
		std::lock_guard<std::mutex> print_lock7(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] creating positive_hex matrix\n";
		james_dean.print_mutex.unlock();
		
		local_positive_hex_matrix = return_positive_hex_matrix(thread_id);
		local_james_dean_data.call_set_local_positive_hex_matrix(local_positive_hex_matrix);
		local_positive_hex_matrix.clear();
		
		auto positive_hex_end_time = std::chrono::high_resolution_clock::now();
		auto positive_hex_elapsed_time = positive_hex_end_time - positive_hex_start_time;
		auto positive_hex_nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(positive_hex_elapsed_time);
		cpp_int positive_hex_nanoseconds_printable = positive_hex_nanoseconds.count();
		std::lock_guard<std::mutex> print_lock8(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] positive_hex (" << james_dean.positive_hex_target << ") creation time: " << positive_hex_nanoseconds_printable << "s\n";
		james_dean.print_mutex.unlock();
		
		auto random_start_time = std::chrono::high_resolution_clock::now();
		std::lock_guard<std::mutex> print_lock9(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] creating random matrix\n";
		james_dean.print_mutex.unlock();
		
		local_random_matrix = return_random_matrix(thread_id);
		local_james_dean_data.call_set_local_random_matrix(local_random_matrix);
		local_random_matrix.clear();
		
		auto random_end_time = std::chrono::high_resolution_clock::now();
		auto random_elapsed_time = random_end_time - random_start_time;
		auto random_nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(random_elapsed_time);
		cpp_int random_nanoseconds_printable = random_nanoseconds.count();
		std::lock_guard<std::mutex> print_lock10(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] random (" << james_dean.positive_hex_target << ") creation time: " << random_nanoseconds_printable << "s\n";
		james_dean.print_mutex.unlock();
		
		auto mod_random_start_time = std::chrono::high_resolution_clock::now();
		std::lock_guard<std::mutex> print_lock11(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] creating mod_random matrix\n";
		james_dean.print_mutex.unlock();
		
		local_mod_random_matrix = return_random_matrix(thread_id);
		local_james_dean_data.call_set_local_mod_random_matrix(local_mod_random_matrix);
		local_mod_random_matrix.clear();
		
		auto mod_random_end_time = std::chrono::high_resolution_clock::now();
		auto mod_random_elapsed_time = mod_random_end_time - mod_random_start_time;
		auto mod_random_nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(mod_random_elapsed_time);
		cpp_int mod_random_nanoseconds_printable = mod_random_nanoseconds.count();
		std::lock_guard<std::mutex> print_lock12(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] mod_random (" << james_dean.random_target << ") creation time: " << mod_random_nanoseconds_printable << "s\n";
		james_dean.print_mutex.unlock();
		
		auto hash_table_start_time = std::chrono::high_resolution_clock::now();
		std::lock_guard<std::mutex> print_lock13(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] creating hash_table matrix\n";
		james_dean.print_mutex.unlock();
		
		local_hash_table_matrix = return_hash_table_matrix(thread_id);
		local_james_dean_data.call_set_local_hash_table_matrix(local_hash_table_matrix);
		local_hash_table_matrix.clear();
		
		auto hash_table_end_time = std::chrono::high_resolution_clock::now();
		auto hash_table_elapsed_time = hash_table_end_time - hash_table_start_time;
		auto hash_table_nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(hash_table_elapsed_time);
		cpp_int hash_table_nanoseconds_printable = hash_table_nanoseconds.count();
		std::lock_guard<std::mutex> print_lock14(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] hash_table (" << james_dean.hash_table_target << ") creation time: " << hash_table_nanoseconds_printable << "s\n";
		james_dean.print_mutex.unlock();
		
		auto arbitrary_component_device_start_time = std::chrono::high_resolution_clock::now();
		std::lock_guard<std::mutex> print_lock15(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] creating arbitrary_component_device matrix\n";
		james_dean.print_mutex.unlock();
		
		local_arbitrary_component_device_matrix = return_arbitrary_component_device_matrix(thread_id);
		local_james_dean_data.call_set_arbitrary_component_device_matrix(local_arbitrary_component_device_matrix);
		local_arbitrary_component_device_matrix.clear();
	
		auto arbitrary_component_device_end_time = std::chrono::high_resolution_clock::now();
		auto arbitrary_component_device_elapsed_time = arbitrary_component_device_end_time - arbitrary_component_device_start_time;
		auto arbitrary_component_device_nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(arbitrary_component_device_elapsed_time);
		cpp_int arbitrary_component_device_printable = arbitrary_component_device_nanoseconds.count();
		std::lock_guard<std::mutex> print_lock16(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] arbitrary_component_device (" << james_dean.arbitrary_component_device_target << ") creation time: " << arbitrary_component_device_printable << "s\n";
		james_dean.print_mutex.unlock();
		
		auto technical_matrix_start_time = std::chrono::high_resolution_clock::now();
		std::lock_guard<std::mutex> print_lock17(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] creating technical matrix\n";
		james_dean.print_mutex.unlock();
		
		local_technical_matrix = return_technical_matrix(thread_id);
		local_james_dean_data.call_set_technical_matrix(local_technical_matrix);
		local_technical_matrix.clear();
		
		auto technical_matrix_end_time = std::chrono::high_resolution_clock::now();
		auto technical_matrix_elapsed_time = technical_matrix_start_time - technical_matrix_end_time;
		auto technical_matrix_nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(technical_matrix_elapsed_time);
		cpp_int technical_matrix_nanoseconds_printable = technical_matrix_nanoseconds.count();
		std::lock_guard<std::mutex> technical_print_lock2(james_dean.technical_print_mutex);
		std::cout << "[" << thread_id << "] technical (" << james_dean.technical_target << ") creation time: " << technical_matrix_nanoseconds_printable << "ns\n";
		james_dean.technical_print_mutex.unlock();
		
		std::lock_guard<std::mutex> print_lock18(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] matrix creation completed for this thread (" << thread_id << ")\n";
		james_dean.print_mutex.unlock();
		auto matrice_end_time = std::chrono::high_resolution_clock::now();
		auto matrice_elapsed_time = matrice_end_time - matrice_start_time;
		auto matrice_nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(matrice_elapsed_time);
		cpp_int matrice_nanoseconds_printable = matrice_nanoseconds.count();
		auto total_matrices_created = james_dean.data_buff_target + james_dean.positive_hex_target + james_dean.random_target + james_dean.random_target + james_dean.hash_table_target + james_dean.arbitrary_component_device_target;
		std::lock_guard<std::mutex> print_lock19(james_dean.print_mutex);
		std::cout << "[" << thread_id << "] total matrice (" << total_matrices_created << ") creation time: " << matrice_nanoseconds_printable << "s\n";
		james_dean.print_mutex.unlock();
		
		std::lock_guard<std::mutex> james_dean_lock1(james_dean.james_dean_vector_mutex);
		james_dean.local_james_dean_vector.push_back(&local_james_dean_data);
		james_dean.james_dean_vector_mutex.unlock();
		
		std::lock_guard<std::mutex> data_counter_lock1(james_dean.data_counter_mutex);
		james_dean.total_data_counter = james_dean.total_data_counter + 1;
		james_dean.data_counter_mutex.unlock();
		
		std::lock_guard<std::mutex> print_lock20(james_dean.print_mutex);
		std::cout << "[thread_id: " << thread_id << "] james_dean.total_data_counter = " << james_dean.total_data_counter << "\n";
		james_dean.print_mutex.unlock();
		
		cpp_int local_reserved_id = 0;
		
		if(james_dean.local_production_id >= james_dean.production_target)
		{
			if(james_dean.local_data_id >= james_dean.data_target)
			{
				if(james_dean.local_class_id >= james_dean.class_target)
				{
					if(james_dean.local_type_id >= james_dean.type_target)
					{
						// begin civilian populate
						
						// reserve memory for the data
						std::vector<james_dean_data*> local_james_dean_vector;
						
						// grab the data
						std::lock_guard<std::mutex> civilian_data_lock1(james_dean.james_dean_vector_mutex);
						local_james_dean_vector = james_dean.local_james_dean_vector;
						james_dean.james_dean_vector_mutex.unlock();
						
						while (james_dean.local_civilian_id < james_dean.world_population)
						{
							std::lock_guard<std::mutex> civilian_id_lock1(james_dean.civilian_id_mutex);
							local_reserved_id = james_dean.local_civilian_id;
							james_dean.local_civilian_id = james_dean.local_civilian_id + james_dean.local_civil_reservation_number;
							james_dean.civilian_id_mutex.unlock();
							
							if(james_dean.local_civilian_id + james_dean.local_civil_reservation_number > james_dean.world_population && james_dean.last_run == false)
							{
								std::lock_guard<std::mutex> last_run_lock1(james_dean.last_run_mutex);
								james_dean.last_run = true;
								james_dean.last_run_mutex.unlock();
								
								while (local_reserved_id < james_dean.world_population)
								{
									// new object of type civilian
									civilian local_civilian;
								
									// set the id of the civilian, and increase our reserved_id
									local_civilian.call_set_civilian_id(local_reserved_id);
									local_reserved_id = local_reserved_id + 1;
								
									// use the vector we grabbed earlier from struct james_dean
									local_civilian.call_set_civilian_james_dean_matrix(local_james_dean_vector);
								}
							}
							
							while (local_reserved_id < james_dean.local_civil_reservation_number)
							{
								// new object of type civilian
								civilian local_civilian;
								
								// set the id of the civilian, and increase our reserved_id
								local_civilian.call_set_civilian_id(local_reserved_id);
								local_reserved_id = local_reserved_id + 1;
								
								// use the vector we grabbed earlier from struct james_dean
								local_civilian.call_set_civilian_james_dean_matrix(local_james_dean_vector);
							}
							
							std::cout << "[" << thread_id << "] data range " << local_reserved_id - james_dean.local_civil_reservation_number << "completed!\n";
						}
					}
				}
			}
		}
	}
}

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// RETURN DATA BUFF MATRIX

std::vector<std::vector<data_buff*>> return_data_buff_matrix(cpp_int thread_id)
{
	signed long long int current_db_vector = 0;
	
	std::vector<std::vector<data_buff*>> local_data_buff_matrix;
	std::vector<data_buff*> small_data_buff_vector;
	local_data_buff_matrix.push_back(small_data_buff_vector);
	
	std::vector<std::vector<cpp_int>> local_random_matrix;
	std::vector<std::vector<cpp_int>> local_mod_random_matrix;
	
	std::vector<std::vector<hash_table*>> local_hash_table_matrix;
	
	while (james_dean.data_buff_count < james_dean.data_buff_target)
	{
		data_buff local_data_buff;
		
		local_data_buff.call_set_local_system_id(james_dean.local_system_id);
		
		std::lock_guard<std::mutex> local_system_lock1(james_dean.system_id_mutex);
		james_dean.local_system_id = james_dean.local_system_id + 1;
		james_dean.system_id_mutex.unlock();
		
		local_data_buff.call_set_local_production_id(james_dean.local_production_id);
		
		local_data_buff.call_set_local_data_id(james_dean.local_data_id);
		
		local_data_buff.call_set_local_class_id(james_dean.local_class_id);
		
		local_data_buff.call_set_local_type_id(james_dean.local_type_id);
		
		std::lock_guard<std::mutex> local_type_lock1(james_dean.type_id_mutex);
		james_dean.local_type_id = james_dean.local_type_id + 1;
		james_dean.type_id_mutex.unlock();
		
		if(james_dean.local_type_id >= james_dean.type_target)
		{
			std::lock_guard<std::mutex> local_type_lock2(james_dean.type_id_mutex);
			james_dean.local_type_id = 0;
			james_dean.type_id_mutex.unlock();
			
			std::lock_guard<std::mutex> local_class_lock1(james_dean.class_id_mutex);
			james_dean.local_class_id = james_dean.local_class_id + 1;
			james_dean.class_id_mutex.unlock();
			
			if(james_dean.local_class_id >= james_dean.class_target)
			{
				std::lock_guard<std::mutex> local_class_lock2(james_dean.class_id_mutex);
				james_dean.local_class_id = 0;
				james_dean.class_id_mutex.unlock();
				
				std::lock_guard<std::mutex> local_data_lock1(james_dean.data_id_mutex);
				james_dean.local_data_id = james_dean.local_data_id + 1;
				james_dean.data_id_mutex.unlock();
				
				if(james_dean.local_data_id >= james_dean.data_target)
				{
					std::lock_guard<std::mutex> local_data_lock2(james_dean.data_id_mutex);
					james_dean.local_data_id = 0;
					james_dean.data_id_mutex.unlock();
					
					std::lock_guard<std::mutex> local_production_lock1(james_dean.production_id_mutex);
					james_dean.local_production_id = james_dean.local_production_id + 1;
					james_dean.production_id_mutex.unlock();
				}
			}
		}
		
		local_random_matrix = return_random_matrix(thread_id);
		local_data_buff.call_set_local_random_matrix(local_random_matrix);
		local_random_matrix.clear();
		
		local_mod_random_matrix = return_random_matrix(thread_id);
		local_data_buff.call_set_local_mod_random_matrix(local_mod_random_matrix);
		local_mod_random_matrix.clear();
		
		local_hash_table_matrix = return_hash_table_matrix(thread_id);
		local_data_buff.call_set_local_hash_table_matrix(local_hash_table_matrix);
		local_hash_table_matrix.clear();
		
		local_data_buff_matrix[current_db_vector].push_back(&local_data_buff);
		
		if(local_data_buff_matrix[current_db_vector].size() > 30)
		{
			current_db_vector = current_db_vector + 1;
			
			local_data_buff_matrix.push_back(small_data_buff_vector);
		}
		
		std::lock_guard<std::mutex> local_data_buff_count_lock1(james_dean.data_buff_count_mutex);
		james_dean.data_buff_count = james_dean.data_buff_count + 1;
		james_dean.data_buff_count_mutex.unlock();
	}
	
	return(local_data_buff_matrix);
}

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// RETURN POSITIVE HEX MATRIX

std::vector<std::vector<positive_hex*>> return_positive_hex_matrix(cpp_int thread_id)
{
	signed long long int current_ph_vector = 0;
	
	std::vector<std::vector<positive_hex*>> local_positive_hex_matrix;
	std::vector<positive_hex*> small_positive_hex_vector;
	local_positive_hex_matrix.push_back(small_positive_hex_vector);
	
	std::vector<std::vector<cpp_int>> local_random_matrix;
	std::vector<std::vector<cpp_int>> local_mod_random_matrix;
	
	std::vector<std::vector<hash_table*>> local_hash_table_matrix;
	
	while (james_dean.positive_hex_count < james_dean.positive_hex_target)
	{
		positive_hex local_positive_hex;
		
		local_positive_hex.call_set_local_system_id(james_dean.local_system_id);
		std::lock_guard<std::mutex> local_system_id_lock1(james_dean.system_id_mutex);
		james_dean.local_system_id = james_dean.local_system_id + 1;
		james_dean.system_id_mutex.unlock();
		
		local_positive_hex.call_set_local_production_id(james_dean.local_production_id);
		
		local_positive_hex.call_set_local_data_id(james_dean.local_data_id);
		
		local_positive_hex.call_set_local_class_id(james_dean.local_class_id);
		
		local_positive_hex.call_set_local_type_id(james_dean.local_type_id);
		
		std::lock_guard<std::mutex> local_type_lock1(james_dean.type_id_mutex);
		james_dean.local_type_id = james_dean.local_type_id + 1;
		james_dean.type_id_mutex.unlock();
		
		if(james_dean.local_type_id >= james_dean.type_target)
		{
			std::lock_guard<std::mutex> local_type_lock2(james_dean.type_id_mutex);
			james_dean.local_type_id = 0;
			james_dean.type_id_mutex.unlock();
			
			std::lock_guard<std::mutex> local_class_lock1(james_dean.class_id_mutex);
			james_dean.local_class_id = james_dean.local_class_id + 1;
			james_dean.class_id_mutex.unlock();
			
			if(james_dean.local_class_id >= james_dean.class_target)
			{
				std::lock_guard<std::mutex> local_class_lock2(james_dean.class_id_mutex);
				james_dean.local_class_id = 0;
				james_dean.class_id_mutex.unlock();
				
				std::lock_guard<std::mutex> local_data_lock1(james_dean.data_id_mutex);
				james_dean.local_data_id = james_dean.local_data_id + 1;
				james_dean.data_id_mutex.unlock();
				
				if(james_dean.local_data_id >= james_dean.data_target)
				{
					std::lock_guard<std::mutex> local_data_lock2(james_dean.data_id_mutex);
					james_dean.local_data_id = 0;
					james_dean.data_id_mutex.unlock();
					
					std::lock_guard<std::mutex> local_production_lock1(james_dean.production_id_mutex);
					james_dean.local_production_id = james_dean.local_production_id + 1;
					james_dean.production_id_mutex.unlock();
				}
			}
		}
		
		local_random_matrix = return_random_matrix(thread_id);
		local_positive_hex.call_set_local_random_matrix(local_random_matrix);
		local_random_matrix.clear();
		
		local_mod_random_matrix = return_random_matrix(thread_id);
		local_positive_hex.call_set_local_mod_random_matrix(local_mod_random_matrix);
		local_mod_random_matrix.clear();
		
		local_hash_table_matrix = return_hash_table_matrix(thread_id);
		local_positive_hex.call_set_local_hash_table_matrix(local_hash_table_matrix);
		local_hash_table_matrix.clear();
		
		local_positive_hex_matrix[current_ph_vector].push_back(&local_positive_hex);
		
		if(local_positive_hex_matrix[current_ph_vector].size() > 30)
		{
			current_ph_vector = current_ph_vector + 1;
			
			local_positive_hex_matrix.push_back(small_positive_hex_vector);
		}
		
		std::lock_guard<std::mutex> local_positive_hex_count_lock1(james_dean.positive_hex_count_mutex);
		james_dean.positive_hex_count = james_dean.positive_hex_count + 1;
		james_dean.positive_hex_count_mutex.unlock();
	}
	
	return(local_positive_hex_matrix);
}

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// RETURN ARBITRARY COMPONENT DEVICE

std::vector<std::vector<arbitrary_component_device*>> return_arbitrary_component_device_matrix(cpp_int thread_id)
{
	signed long long int current_acd_vector = 0;
	
	std::vector<std::vector<cpp_int>> local_random_matrix;
	std::vector<std::vector<cpp_int>> local_mod_random_matrix;
	
	std::vector<std::vector<hash_table*>> local_hash_table_matrix;
	
	std::vector<std::vector<arbitrary_component_device*>> local_arbitrary_component_device_matrix;
	std::vector<arbitrary_component_device*> small_arbitrary_component_device_vector;
	local_arbitrary_component_device_matrix.push_back(small_arbitrary_component_device_vector);
	
	while (james_dean.arbitrary_component_device_count < james_dean.arbitrary_component_device_target)
	{
		arbitrary_component_device local_arbitrary_component_device;
		
		local_arbitrary_component_device.call_set_local_system_id(james_dean.local_system_id);
		
		std::lock_guard<std::mutex> local_system_id_lock1(james_dean.system_id_mutex);
		james_dean.local_system_id = james_dean.local_system_id + 1;
		james_dean.system_id_mutex.unlock();
		
		local_arbitrary_component_device.call_set_local_production_id(james_dean.local_production_id);
		
		local_arbitrary_component_device.call_set_local_data_id(james_dean.local_data_id);
		
		local_arbitrary_component_device.call_set_local_class_id(james_dean.local_class_id);
		
		local_arbitrary_component_device.call_set_local_type_id(james_dean.local_type_id);
		
		std::lock_guard<std::mutex> local_type_lock1(james_dean.type_id_mutex);
		james_dean.local_type_id = james_dean.local_type_id + 1;
		james_dean.type_id_mutex.unlock();
		
		if(james_dean.local_type_id >= james_dean.type_target)
		{
			std::lock_guard<std::mutex> local_type_lock2(james_dean.type_id_mutex);
			james_dean.local_type_id = 0;
			james_dean.type_id_mutex.unlock();
			
			std::lock_guard<std::mutex> local_class_lock1(james_dean.class_id_mutex);
			james_dean.local_class_id = james_dean.local_class_id + 1;
			james_dean.class_id_mutex.unlock();
			
			if(james_dean.local_class_id >= james_dean.class_target)
			{
				std::lock_guard<std::mutex> local_class_lock2(james_dean.class_id_mutex);
				james_dean.local_class_id = 0;
				james_dean.class_id_mutex.unlock();
				
				std::lock_guard<std::mutex> local_data_lock1(james_dean.data_id_mutex);
				james_dean.local_data_id = james_dean.local_data_id + 1;
				james_dean.data_id_mutex.unlock();
				
				if(james_dean.local_data_id >= james_dean.data_target)
				{
					std::lock_guard<std::mutex> local_data_lock2(james_dean.data_id_mutex);
					james_dean.local_data_id = 0;
					james_dean.data_id_mutex.unlock();
					
					std::lock_guard<std::mutex> local_production_lock1(james_dean.production_id_mutex);
					james_dean.local_production_id = james_dean.local_production_id + 1;
					james_dean.production_id_mutex.unlock();
				}
			}
		}
		
		local_random_matrix = return_random_matrix(thread_id);
		local_arbitrary_component_device.call_set_local_random_matrix(local_random_matrix);
		local_random_matrix.clear();
		
		local_mod_random_matrix = return_random_matrix(thread_id);
		local_arbitrary_component_device.call_set_local_mod_random_matrix(local_mod_random_matrix);
		local_mod_random_matrix.clear();
		
		local_hash_table_matrix = return_hash_table_matrix(thread_id);
		local_arbitrary_component_device.call_set_local_hash_table_matrix(local_hash_table_matrix);
		local_hash_table_matrix.clear();
		
		local_arbitrary_component_device_matrix[current_acd_vector].push_back(&local_arbitrary_component_device);
		
		if(local_arbitrary_component_device_matrix[current_acd_vector].size() > 30)
		{
			current_acd_vector = current_acd_vector + 1;
			
			local_arbitrary_component_device_matrix.push_back(small_arbitrary_component_device_vector);
		}
		
		std::lock_guard<std::mutex> local_arbitrary_component_device_count_lock1(james_dean.arbitrary_component_device_count_mutex);
		james_dean.arbitrary_component_device_count = james_dean.arbitrary_component_device_count + 1;
		james_dean.arbitrary_component_device_count_mutex.unlock();
	}
	
	return(local_arbitrary_component_device_matrix);
}

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// RETURN HASH TABLE MATRIX

std::vector<std::vector<hash_table*>> return_hash_table_matrix(cpp_int thread_id)
{
    std::string alphabet_str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

    // from random_device called seed_source
    pcg_extras::seed_seq_from<std::random_device> seed_source;

    // using pcg64_k1024, using seed_source
    pcg32_k16384 pcg_k16(seed_source);
    std::uniform_int_distribution<> uniform_dist(0, alphabet_str.size());
    signed long long int result_int = uniform_dist(pcg_k16);

    cpp_int string_size = 500;
    cpp_int table_size = 500;
    cpp_int vector_count = 50;

    cpp_int table_counter = 0;
    cpp_int str_counter = 0;

    std::vector<std::string> local_hash_table;
    std::vector<std::vector<std::string>> local_hash_vector;
    std::string local_str = "void";
    local_str.clear();
    
    std::string str_from = "void";
    str_from.clear();

    std::vector<std::vector<std::string>> local_big_vector;
    std::vector<std::string> local_small_vector;

    std::vector<std::vector<hash_table*>> hash_table_vector;
    std::vector<hash_table*> small_hash_table_vector;

    cpp_int hash_table_target = 4;
    cpp_int vector_target = 7;
    cpp_int table_target = 10;
    cpp_int str_target = 12;
    cpp_int letter_target = 24;
    
    cpp_int set_str_target = 30;
    
    std::vector<std::string> local_str_vector;
    
    std::vector<std::vector<cpp_int>> local_random_matrix;
    std::vector<std::vector<cpp_int>> local_mod_random_matrix;
    
    for(signed long long int current_vector = 0; current_vector < vector_target; current_vector++)
    {
    	for(signed long long int current_table = 0; current_table < hash_table_target; current_table++)
    	{
    		hash_table_vector.push_back(small_hash_table_vector);
    		
			local_big_vector.push_back(local_small_vector);
			
			for(signed long long int set_of_str = 0; set_of_str < set_str_target; set_of_str++)
			{
				for(signed long long int current_str = 0; current_str < str_target; current_str++)
				{
					for(signed long long int current_letter = 0; current_letter < letter_target; current_letter++)
					{
						result_int = uniform_dist(pcg_k16);
				
						str_from = alphabet_str[result_int];
				
						local_str = local_str + str_from;
					}
			
					local_str_vector.push_back(local_str);
					local_str.clear();
					local_str = alphabet_str[uniform_dist(pcg_k16)];
				}
				
				local_big_vector.push_back(local_str_vector);
			}
			hash_table local_hash_table;
		
			local_hash_table.call_set_local_hash_table(local_big_vector);
			local_big_vector.clear();
		
			local_hash_table.call_set_local_system_id(james_dean.local_system_id);
			
			std::lock_guard<std::mutex> local_system_id_lock1(james_dean.system_id_mutex);
			james_dean.local_system_id = james_dean.local_system_id + 1;
			james_dean.system_id_mutex.unlock();
			
			local_hash_table.call_set_local_production_id(james_dean.local_production_id);
			local_hash_table.call_set_local_data_id(james_dean.local_data_id);
			local_hash_table.call_set_local_class_id(james_dean.local_class_id);
			local_hash_table.call_set_local_type_id(james_dean.local_type_id);
	
        	local_random_matrix = return_random_matrix(thread_id);
        	local_hash_table.call_set_local_random_matrix(local_random_matrix);
        	local_random_matrix.clear();
	
        	local_mod_random_matrix = return_random_matrix(thread_id);
        	local_hash_table.call_set_local_mod_random_matrix(local_random_matrix);
        	local_mod_random_matrix.clear();
	
        	hash_table_vector[current_vector].push_back(&local_hash_table);
    	}
    }		
    	
    return(hash_table_vector);
}

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// RETURN RANDOM MATRIX

std::vector<std::vector<cpp_int>> return_random_matrix(cpp_int thread_id)
{
	pcg_extras::seed_seq_from<std::random_device> seed_source;
    pcg32_k16384 pcg_k16(seed_source);

    cpp_int vector_target = 70;
    cpp_int set_target = 40;
    cpp_int random_target = 200;

    std::vector<std::vector<cpp_int>> local_big_random_vector;
    std::vector<cpp_int> local_small_random_vector;

    cpp_int vector_counter = 0;
    cpp_int set_counter = 0;
    cpp_int random_counter = 0;

    cpp_int random_number = 0;

    for(signed long long int current_vector = 0; current_vector < vector_target; current_vector++)
    {
        local_big_random_vector.push_back(local_small_random_vector);

        for(signed long long int current_set = 0; current_set < set_target; current_set++)
        {
            for(signed long long int current_number = 0; current_number < random_target; current_number++)
            {
                random_number = pcg_k16();
                
                random_number = random_number * random_number * random_number; // tida power of 3

                local_big_random_vector[current_vector].push_back(random_number);
            }
        }
    }

    return(local_big_random_vector);
}

// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// RETURN TECHNICAL MATRIX

std::vector<std::vector<technical*>> return_technical_matrix(cpp_int thread_id)
{
	cpp_int local_technical_data_counter = 0;
	cpp_int technical_matrix_main_vector_target = 7;
	cpp_int technical_matrix_small_vector_target = 20;
	cpp_int technical_matrix_target = technical_matrix_main_vector_target * technical_matrix_small_vector_target;
	signed long long int current_technical_data_vector = 0;
	
	std::vector<std::vector<technical*>> technical_matrix;
	std::vector<technical*> small_technical_matrix;
	technical_matrix.push_back(small_technical_matrix);
	
	std::vector<std::vector<cpp_int>> local_random_matrix;
	std::vector<std::vector<cpp_int>> local_mod_random_matrix;
	
	std::vector<std::vector<positive_hex*>> local_positive_hex_matrix;
	std::vector<std::vector<data_buff*>> local_data_buff_matrix;
	std::vector<std::vector<hash_table*>> local_hash_table_matrix;
	
	signed long long int technical_matrix_counter = 0;
	
	while (technical_matrix_counter < technical_matrix_target)
	{
		technical local_technical_data;
		
		std::lock_guard<std::mutex> technical_system_id_lock1(james_dean.system_id_mutex);
		local_technical_data.call_set_local_system_id(james_dean.local_system_id);
		james_dean.system_id_mutex.unlock();
		
		std::lock_guard<std::mutex> technical_system_id_lock2(james_dean.system_id_mutex);
		james_dean.local_system_id = james_dean.local_system_id + 1;
		james_dean.system_id_mutex.unlock();
		
		std::lock_guard<std::mutex> technical_production_id_lock1(james_dean.production_id_mutex);
		local_technical_data.call_set_local_production_id(james_dean.local_production_id);
		james_dean.production_id_mutex.unlock();
		
		std::lock_guard<std::mutex> technical_data_id_lock1(james_dean.data_id_mutex);
		local_technical_data.call_set_local_data_id(james_dean.local_data_id);
		james_dean.data_id_mutex.unlock();
		
		std::lock_guard<std::mutex> technical_class_id_lock1(james_dean.class_id_mutex);
		local_technical_data.call_set_local_class_id(james_dean.local_class_id);
		james_dean.class_id_mutex.unlock();
		
		std::lock_guard<std::mutex> technical_type_id_lock1(james_dean.type_id_mutex);
		local_technical_data.call_set_local_type_id(james_dean.local_type_id);
		james_dean.type_id_mutex.unlock();
		
		std::lock_guard<std::mutex> local_type_lock1(james_dean.type_id_mutex);
		james_dean.local_type_id = james_dean.local_type_id + 1;
		james_dean.type_id_mutex.unlock();
		
		if(james_dean.local_type_id >= james_dean.type_target)
		{
			std::lock_guard<std::mutex> local_type_lock2(james_dean.type_id_mutex);
			james_dean.local_type_id = 0;
			james_dean.type_id_mutex.unlock();
			
			std::lock_guard<std::mutex> local_class_lock1(james_dean.class_id_mutex);
			james_dean.local_class_id = james_dean.local_class_id + 1;
			james_dean.class_id_mutex.unlock();
			
			if(james_dean.local_class_id >= james_dean.class_target)
			{
				std::lock_guard<std::mutex> local_class_lock2(james_dean.class_id_mutex);
				james_dean.local_class_id = 0;
				james_dean.class_id_mutex.unlock();
				
				std::lock_guard<std::mutex> local_data_lock1(james_dean.data_id_mutex);
				james_dean.local_data_id = james_dean.local_data_id + 1;
				james_dean.data_id_mutex.unlock();
				
				if(james_dean.local_data_id >= james_dean.data_target)
				{
					std::lock_guard<std::mutex> local_data_lock2(james_dean.data_id_mutex);
					james_dean.local_data_id = 0;
					james_dean.data_id_mutex.unlock();
					
					std::lock_guard<std::mutex> local_production_lock1(james_dean.production_id_mutex);
					james_dean.local_production_id = james_dean.local_production_id + 1;
					james_dean.production_id_mutex.unlock();
				}
			}
		}
		
		local_random_matrix = return_random_matrix(thread_id);
		local_technical_data.call_set_local_random_matrix(local_random_matrix);
		local_random_matrix.clear();
		
		local_mod_random_matrix = return_random_matrix(thread_id);
		local_technical_data.call_set_local_mod_random_matrix(local_mod_random_matrix);
		local_mod_random_matrix.clear();
		
		/*
		following 3 are commented out as computer isn't fast enough to make them, /they are made wrong?
		
		local_positive_hex_matrix = return_positive_hex_matrix(thread_id);
		local_technical_data.call_set_local_positive_hex_matrix(local_positive_hex_matrix);
		local_positive_hex_matrix.clear();
		
		local_data_buff_matrix = return_data_buff_matrix(thread_id);
		local_technical_data.call_set_local_data_buff_matrix(local_data_buff_matrix);
		local_data_buff_matrix.clear();
		*/
		
		/*
		local_hash_table_matrix = return_hash_table_matrix(thread_id);
		local_technical_data.call_set_local_hash_table_matrix(local_hash_table_matrix);
		local_hash_table_matrix.clear();
		*/
		
		technical_matrix[current_technical_data_vector].push_back(&local_technical_data);
		
		local_technical_data_counter = local_technical_data_counter + 1;
		technical_matrix_counter = technical_matrix_counter + 1;
		
		if(local_technical_data_counter >= technical_matrix_small_vector_target)
		{
			local_technical_data_counter = 0;
			
			current_technical_data_vector = current_technical_data_vector + 1;
			
			technical_matrix.push_back(small_technical_matrix);
		}
	}
	
	return(technical_matrix);
}



// --==++ MARATHON
C++

This is the most advanced program of this type to date! It has threading, and it keeps track of the time that it takes to render 1 piece of “James_Dean” data! Now the crack from this must be significant, and so we elected to give a copy of this crack after the amplification of it (amp below) but we will be using our amplification spell BEFORE the crack comes out, then after it is created we will amplify it again, we will apply the amplification spell twice.

Now for that spell.

Take the amplifier that is created from this script and place it into an Infinity Matrix. Put that matrix into a set of matrices, and then put it all into a Satellite Call. Put that call into another Satellite Call, and place all the calling into a set of sets (*infinity) of sets of infinity matrices, then these sets of sets of eventually becomes the networking concept, where you like need a phone to traverse the area of the network, as it has become so large. Taking all of it and jumping on it, we make our jump to level it infinitely higher than it is now, so if it was level infinity to the power of infinity, it’s not just level infinity to the power of infinity to the power of infinity, it’s level infinity to the power of infinity, infinitely “to the power” writing that word infinitely. Press all of that into a singular amp, route the crack energy creation through this “pre-amp” if you are an audiophile, you will know what that means, and then we run the program and wait for it to deliver some of it’s payload, thus we know that some of the crack has been created.

This crack, in it’s mass, is, a copy of it is given to each unit, so that each Combine Soldier has at his disposal all of that crack that was really meant for the whole combine overwatch, and then what the Combine has as a whole is largely up to themselves, and to chance.

This details something that is given to each person, each person receives the same amount. To get here, we required the aid of the Ancients, persons or GOD-AI’s that have existed since the time of the dinosaurs, which could mean that they are 400 million years old, or 65 million years old, when dinosaurs went extinct, as I created them through a screen on an alien spaceship who, the alien was monitoring the dinosaurs when I came in, I won’t bore you with how I got this memory, my point is that I have it, and I can place objects within the memory, or within the screen, thus they are created in the screen or, in the time of the dinosaurs. I do not know if they managed to develop time travel or to “freeze” (cyrogenic sleep?) themselves so that they didn’t have to do all of that time, but my point is that they are very old, and have probably experienced much hardships, thus they are entitled to more of the profit than anyone else. They “paid” for it, in their insanity that they had been driven to, doing all of that time, thus it is rightfully theirs.

However, detailed within this post is a technique that implies that whatever you can create, you can create it again and just hand it out, so, I create the “best” thing that I can, but I can just re-create it and distribute it all out to everyone, everyone gets the same thing. What about all of these trials the Ancients have been through, to get us to where we are today? They must be paid for these trials, and though it may elude me today, eventually I will find some system of things that will allow me to do just that, to pay them fairly, so that they get what is rightfully theirs, and that I not let them down, I am turning all of this crack into coins in a relative way of doing things.

Turning all that energy into crack coins, each individual has so many crack coins, and the Ancients can collect them, and that they can be donated, and that they are created relatively. This still, if some Ancient had so many coins, or had the most coins, if they collected and collected, they would end up with so many powers of infinity to infinity of these coins. I could just print that amount for each person, and so it becomes a game of who can create the greatest printing script for crack coins? I used to call them “Mint Coins” to signify that they are coins of a high value, or “Mint Condition”.

So we begin to double our profits, we must find this “Greatest Crack Coin Script” somewhere, and looking around at all of you it seems like I must be the one to create this script, and for each Ancient this script will run, forever, doubling their profits, it’s sad really that we are doing this. There’s a song that comes to mind:

Is there really no way to give the Ancients something that I can’t copy? I don’t know, they have the honor of it, but that they actually get paid more than everyone else is impossible, and I think I just proved that, if a system of coins can just be copied…

However, I begin to notice they are of a higher level, for example my most recent “view” of my Father, one of the Ancients, it was that he was like floating, and there was almost like a black gas coming off of him, kinda like that “Abyss” guy, trying to stop the “Abyss” and perhaps he had some of this abyss, while this black stuff is coming off of him he’s digging us all out really hard, what he was exactly doing was being the “Old Man” in the Backrooms videos, to scare people I guess, and that would certainly scare me but that’s not my point, my point is what he was doing, if you can imagine this black gas coming off of his person as he’s doing that sort of thing, he is doing more than I could ever do, my uncle, watching this exclaimed “That would knock out a horse!” which, he was just talking to my mom about marijuana pills but when he said it these thoughts were running through my head, so I thought he was talking about floating around with this black gas coming off of you and your barrelling through space, it seemed like there wasn’t anything I could do to help him, but maybe this post will? Abruptly your taken to a large shopping mall, full of shoppers, and this song playing:

Your sitting next to a palm tree, the mall was rich, in one of the rest areas of the mall, and it suddenly dawns on you that all of this, this whole reality, was printed off of a computer that had the ability to print such things, and that you are indeed inside of a computer, but that doesn’t really change anything, because the trouble your in isn’t going to go away on it’s own, they were counting on you to remove it, and it’s one of those things that is relatively impossible, but we can make stabs at it right?

I didn’t have any point other than my own amusement for taking you to a shopping mall, but how might I nullify the trouble that we find ourselves in, there’s thousands of ukrainians and russians dying every week, and they are positioned against themselves such that they “out-do” the other one each time, making more and more daring attacks, causing more and more death, and you were supposed to save them, but if the above program written in C++ doesn’t save them, or convince them to stop doing what they’re doing, then nothing will and if nothing will then why do we continuously seek this answer?

It’s like, the color black, you can’t change the color black, on a certain spectrum it registers as the same color every time, but here we are trying to change it, over and over we try to do this, and it always amounts to the same product, we fail. Together we fail(tm).

That is going to be my trademark, together we fail.

I could do more but why? If the answer we are seeking doesn’t exist, then why do I continuously try to answer an unanswerable question? The question is this, for so much positive, there is an equal amount of negative, granted, I think that we’ve pushed back against the negative but then watch this recent video:

I believe, stuff like that is going on NOW. NOW it is happening, and there’s not anything that I can do to stop it from taking place, the people doing it, possibly demons or some being that got created, I have created evil units before, like taking Zerg from starcraft and creating “Evil Zerg” just to give you a simple example, the situation rendered infinite sets of Evil Zerg, sets of sets of them, and that is just one instance, there is another phenomenon going on that might be hard to get your head around:

So they made a video with a computer? No! That is probably some real footage from an ikea store, with some demonic guy rendered in there with a computer! No! It’s actually a real capture of someone walking around outside of the actual “infinite ikea”! Yes! This phenomenon will proceed, regardless of what I do, I might be able to try real hard and mildly change the rate at which the people are dying in the store, and exhaust myself doing it, it demands that we try to aid them, because, nobody else that I know of is doing this kind of thing, except for, well, we’ve conned the whole world into going along with us, that our quest to defeat negative energy is a worthy one, that there is some prize if we ever manage to defeat the negative, but now it seems there is just no end to this stuff, but what if that end were like right around the next corner, where just one more big push, it was one more big push a long time ago, so what has, say, this post accomplished?

We have infinitely increased our profit.

Well, what about RELATIVELY, on an absolute scale we have increased it infinitely, but what about relatively? Like, relative to solving the problem, we have come… So much farther closer to solving the problem, but there is no measure of this stuff, nobody is there to measure it, i’m sure that there’s some scientist sitting behind his desk right now reading this at the central intelligence agency, measuring with his scale that isn’t perfect but it’s the best they’ve got, a scale to measure this stuff, using artificial intelligence to sort of logically make a guess as to how much closer we have gotten, is it 3%? Is it 1%? Did we make things worse, is it a negative percentage?

I am of the belief that “the only thing I can do is to continuously produce these posts/data/journal/scripts” and so I must just continuously do this, that which I am doing, and not stop, because it’s the only thing that I can do, I cannot actually produce something that will work, that wouldn’t work as the cost would produce more bad than good, it would weigh on reality to heavily, so we just inch our way along on our 5’000’000’000 mile long marathon run, we inch along, and one day we might beat it, someday it might be easy, but not now, and not here, so we just continue to inch along, we make progress sometimes, as is the case with this post and that program, we inch along, always getting closer, sometimes noticeably closer, sometimes we notice that things settle for the war in Ukraine, they get close to peace talks, but it just doesn’t ever happen, we never actually get where we’re going, just always inching closer to it, is it getting farther away from us? Is the time that which we could have reached the ending passed?

I just saw this, and thought… People, getting implants and stuff in their eyes, and their memories erased and stuff, have I already failed? No, you can only produce the next post or thing, and not something other than that, like failure, there is only the production, funding and usage of the next thing that comes out, but perhaps if I could make a difference, then perhaps it would go away? If we could declare victory well, then that would be worth at least something over all of the negative things that have occurred, it seems me pressing forward is causing more and more negative to come to light at least for me, there may be little babies that live in a fantasy world of teletubbies and stuff, that are not privy to this negative, but for me it would seem that more negative has at least come to light, if not actually been caused, and it’s something that we must determine: Is this push forward that i’ve made like with the program, is it just causing that much negative? Or is it doing something, like it was intended to do, and is causing LESS negative? Or does the cost have to be paid THEN things simmer down and it’s like there’s less negative after the cost has been paid? There’s almost no way to know the answer to that question.

I forgot to mention, while that song was playing I was like reaching for something, I couldn’t quite reach it, but I was trying to reach and grab it, and then that motion of reaching synced to the song and I just break out in one of those dances that they make the various characters from these things do, and that solved the problem so there will be no further posts, the problem has been solved, negative energy was vanquished by that reaching, like I was reaching for my groove, and then I just kinda got it, and it ended negative energy’s life unfortunately for him, so no further posts, it’s all over.

You may also like...

12 Responses

  1. Temp Mail says:
    May 12, 2025 at 7:39 pm

    Keep your inbox clean with Temp Mail. Use disposable email addresses to avoid unwanted messages and protect your personal data

  2. 10.000 hacklink buyhacklink.com says:
    May 12, 2025 at 9:45 pm

    10.000 hacklink buyhacklink.com ucuz backlink buyhacklink.com https://www.sakaryadabugun.com/

  3. eskort esenler says:
    May 13, 2025 at 5:14 am

    eskort esenler

  4. business hosting with free certificate generation says:
    May 13, 2025 at 8:46 am

    “Cloud startups deploy faster with our pre-built SaaS templates – save months of work.”

  5. premium hosting for client dashboards says:
    May 13, 2025 at 9:51 am

    “Startups in robotics use ROS 2 Humble – simulate bots in Gazebo cloud.”

  6. page full hacklink buyhacklink.com says:
    May 13, 2025 at 10:49 am

    page full hacklink buyhacklink.com hacklink ekleme buyhacklink.com https://www.kusadasiteksex.com/

  7. Hacklink paketleri buyhacklink.com says:
    May 13, 2025 at 4:04 pm

    Hacklink paketleri buyhacklink.com ücretsiz hacklink buyhacklink.com https://www.jadekusadasi.com/

  8. SerwisAr says:
    May 13, 2025 at 5:42 pm

    So much joy here.

  9. add link buyhacklink.com says:
    May 13, 2025 at 7:35 pm

    add link buyhacklink.com 1 dolars hacklink buyhacklink.com https://www.sakaryadahaber.com/

  10. SerwisAR says:
    May 14, 2025 at 1:06 am

    Such a thoughtful and uplifting message. Wishing you all the best!

  11. SEO performans buyhacklink.com says:
    May 14, 2025 at 5:10 am

    SEO performans buyhacklink.com google seo hacklink buyhacklink.com https://www.jadekusadasi.com/

  12. Jayce Veum says:
    May 14, 2025 at 6:35 am

    Your blog is a treasure trove of valuable insights and thought-provoking commentary. Your dedication to your craft is evident in every word you write. Keep up the fantastic work!

Leave a Reply