Through The Clouds
aka “Energy From The Clouds” aka Negative Energy’s Last Stand!
I have realized that you can honestly and completely “win” against negative energy, i.e. it is destroyed, and it can still be there, right as rain, smiling at you. Now we would throw all that pain that it caused right back where it came from.
Last night my mom took 2 500mg marijuana gummies and overdosed real hard. I had been working on a program which I will post the source to next, I don’t know if it quite works yet or not, but it’s at the very least close to working, you will get the general idea from the source code: I was working on this program all day and then my mom took 2 500mg marijuana gummies. She overdosed real hard, couldn’t walk, couldn’t really talk well, so as I lay next to her so I could hear her breathing to make sure she was alive, I said to myself i’m not going to do this, and I called 911…
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
// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// 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"
// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// CLASSES
// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// FORWARD DECLARED CLASSES
class positive_hex;
class data_buff;
class hash_table;
class arbitrary_component_device;
// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// JAMES DEAN DATA
class james_dean_data
{
protected:
signed long long int local_system_id = 0;
signed long long int local_production_id = 0;
signed long long int local_data_id = 0;
signed long long int local_class_id = 0;
signed long long int local_type_id = 0;
std::vector<std::vector<signed long long int>> local_random_matrix;
std::vector<std::vector<signed long long 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;
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<signed long long int>> random_matrix_input)
{
local_random_matrix = random_matrix_input;
}
void set_local_mod_random_matrix(std::vector<std::vector<signed long long int>> mod_random_matrix_input)
{
local_mod_random_matrix = mod_random_matrix_input;
}
void set_local_system_id(signed long long int system_id_input)
{
local_system_id = system_id_input;
}
void set_local_production_id(signed long long int production_id_input)
{
local_production_id = production_id_input;
}
void set_local_data_id(signed long long int data_id_input)
{
local_data_id = data_id_input;
}
void set_local_class_id(signed long long int class_id_input)
{
local_class_id = class_id_input;
}
void set_local_type_id(signed long long 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_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<signed long long int>> call_random_matrix_input)
{
set_local_random_matrix(call_random_matrix_input);
}
void call_set_local_mod_random_matrix(std::vector<std::vector<signed long long int>> call_mod_random_matrix_input)
{
set_local_mod_random_matrix(call_mod_random_matrix_input);
}
void call_set_local_system_id(signed long long int call_system_id_input)
{
set_local_system_id(call_system_id_input);
}
void call_set_local_production_id(signed long long int call_production_id_input)
{
set_local_production_id(call_production_id_input);
}
void call_set_local_data_id(signed long long int call_data_id_input)
{
set_local_data_id(call_data_id_input);
}
void call_set_local_class_id(signed long long int call_class_id_input)
{
set_local_class_id(call_class_id_input);
}
void call_set_local_type_id(signed long long 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 population
{
protected:
std::vector<james_dean_data*> population_james_dean_matrix;
signed long long int local_population_id = 0;
void set_population_james_dean_matrix(std::vector<james_dean_data*> james_dean_input)
{
population_james_dean_matrix = james_dean_input;
}
void set_population_id(signed long long int population_id_input)
{
local_population_id = population_id_input;
}
public:
void call_set_population_james_dean_matrix(std::vector<james_dean_data*> call_james_dean_input)
{
set_population_james_dean_matrix(call_james_dean_input);
}
void call_set_population_id(signed long long int call_population_id_input)
{
set_population_id(call_population_id_input);
}
};
// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// FORWARD DECLARATIONS
std::vector<std::vector<signed long long int>> return_random_matrix(signed long long int);
std::vector<std::vector<data_buff*>> return_data_buff_matrix(signed long long int);
std::vector<std::vector<positive_hex*>> return_positive_hex_matrix(signed long long int);
std::vector<std::vector<arbitrary_component_device*>> return_arbitrary_component_device_matrix(signed long long int);
std::vector<std::vector<hash_table*>> return_hash_table_matrix(signed long long int);
void create_james_dean_data(signed long long int);
// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// STRUCTURES
struct main_data_struct {
signed long long int local_system_id = 0;
std::mutex system_id_mutex;
signed long long int local_production_id = 0;
std::mutex production_id_mutex;
signed long long int local_data_id = 0;
std::mutex data_id_mutex;
signed long long int local_class_id = 0;
std::mutex class_id_mutex;
signed long long int local_type_id = 0;
std::mutex type_id_mutex;
signed long long int production_target = 20;
signed long long int data_target = 40;
signed long long int class_target = 60;
signed long long int type_target = 90;
signed long long int random_matrix_vector_target = 25;
std::vector<std::vector<signed long long int>> local_random_matrix;
std::vector<signed long long int> small_random_vector;
std::mutex random_matrix_mutex;
signed long long int mod_random_matrix_vector_target = 25;
std::vector<std::vector<signed long long int>> local_mod_random_matrix;
std::vector<signed long long int> small_mod_random_vector;
std::mutex mod_random_matrix_mutex;
signed long long int hash_table_matrix_vector_target = 30;
std::vector<std::vector<hash_table*>> local_hash_table_matrix;
std::vector<hash_table*> small_hash_table_vector;
std::mutex hash_table_mutex;
signed long long int data_buff_matrix_vector_target = 20;
std::vector<std::vector<data_buff*>> local_data_buff_matrix;
std::vector<data_buff*> small_data_buff_vector;
std::mutex data_buff_mutex;
signed long long int positive_hex_matrix_vector_target = 20;
std::vector<std::vector<positive_hex*>> local_positive_hex_matrix;
std::vector<positive_hex*> small_positive_hex_vector;
std::mutex positive_hex_mutex;
signed long long int arbitrary_component_device_matrix_vector_target = 20;
std::vector<std::vector<arbitrary_component_device*>> local_arbitrary_component_device_matrix;
std::vector<arbitrary_component_device*> small_arbitrary_component_device_vector;
std::mutex arbitrary_component_device_mutex;
std::vector<james_dean_data*> local_james_dean_vector;
signed long long int total_data_counter = 0;
signed long long int positive_hex_count = 0;
signed long long int data_buff_count = 0;
signed long long int arbitrary_component_device_count = 0;
signed long long int positive_hex_target = 25;
signed long long int data_buff_target = 25;
signed long long int hash_table_target = 15;
signed long long int random_target = 20;
signed long long int arbitrary_component_device_target = 15;
std::mutex print_mutex;
} james_dean;
// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// INT MAIN
int main(int argc, char *argv[])
{
std::cout << "\n\nC++ JAMES DEAN DATA CREATOR\n\nVERSION: 002, REVISION: 06\n\n";
std::vector<std::thread> thread_vector;
signed long long int thread_target = 24;
signed long long int local_thread_id = 0;
std::cout << "begin table setting...\n";
for(signed long long int current_random_matrix_vector = 0; current_random_matrix_vector < james_dean.random_matrix_vector_target; current_random_matrix_vector++)
{
james_dean.local_random_matrix.push_back(james_dean.small_random_vector);
}
for(signed long long int current_hash_table_matrix_vector = 0; current_hash_table_matrix_vector < james_dean.hash_table_matrix_vector_target; current_hash_table_matrix_vector++)
{
james_dean.local_hash_table_matrix.push_back(james_dean.small_hash_table_vector);
}
for(signed long long int current_data_buff_matrix_vector = 0; current_data_buff_matrix_vector < james_dean.data_buff_matrix_vector_target; current_data_buff_matrix_vector++)
{
james_dean.local_data_buff_matrix.push_back(james_dean.small_data_buff_vector);
}
for(signed long long int current_positive_hex_matrix_vector = 0; current_positive_hex_matrix_vector < james_dean.positive_hex_matrix_vector_target; current_positive_hex_matrix_vector++)
{
james_dean.local_positive_hex_matrix.push_back(james_dean.small_positive_hex_vector);
}
for(signed long long int current_arbitrary_component_device_matrix_vector = 0; current_arbitrary_component_device_matrix_vector < james_dean.arbitrary_component_device_matrix_vector_target; current_arbitrary_component_device_matrix_vector++)
{
james_dean.local_arbitrary_component_device_matrix.push_back(james_dean.small_arbitrary_component_device_vector);
}
std::cout << "table setting completed!\n";
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_james_dean_data, 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));
}
}
signed long long int display_ticker = 0;
std::cout << "begin assignment of james_dean_data!\n";
for(signed long long int current_populus = 0; current_populus < 8'200'000'000; current_populus++)
{
population person_target;
person_target.call_set_population_james_dean_matrix(james_dean.local_james_dean_vector);
display_ticker = display_ticker + 1;
if(display_ticker > 100'000)
{
display_ticker = 0;
std::cout << "[main] population_id = " << current_populus << "\n";
}
}
std::cout << "\n\n\n********************\n********************\nexecution completed!\n\n";
return(0);
}
// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// FUNCTIONS
// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// CREATE JAMES DEAN DATA
void create_james_dean_data(signed long long 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();
signed long long int local_data_count = james_dean.local_production_id * james_dean.local_data_id * james_dean.local_class_id * james_dean.local_type_id;
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);
james_dean.local_type_id = james_dean.local_type_id + 1;
if(james_dean.local_type_id >= james_dean.type_target)
{
james_dean.local_type_id = 0;
james_dean.local_class_id = james_dean.local_class_id + 1;
if(james_dean.local_class_id >= james_dean.class_target)
{
james_dean.local_class_id = 0;
james_dean.local_data_id = james_dean.local_data_id + 1;
if(james_dean.local_data_id >= james_dean.data_target)
{
james_dean.local_data_id = 0;
james_dean.local_production_id = james_dean.local_production_id + 1;
}
}
}
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 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();
std::lock_guard<std::mutex> data_buff_lock(james_dean.data_buff_mutex);
james_dean.local_data_buff_matrix = return_data_buff_matrix(thread_id);
local_james_dean_data.call_set_local_data_buff_matrix(james_dean.local_data_buff_matrix);
james_dean.local_data_buff_matrix.clear();
james_dean.data_buff_mutex.unlock();
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);
std::lock_guard<std::mutex> print_lock6(james_dean.print_mutex);
float data_buff_float_seconds = data_buff_nanoseconds.count() / 1'000'000'000;
std::cout << "[" << thread_id << "] data_buff (" << james_dean.data_buff_target << ") creation time: " << data_buff_float_seconds << "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();
std::lock_guard<std::mutex> positive_hex_lock(james_dean.positive_hex_mutex);
james_dean.local_positive_hex_matrix = return_positive_hex_matrix(thread_id);
local_james_dean_data.call_set_local_positive_hex_matrix(james_dean.local_positive_hex_matrix);
james_dean.local_positive_hex_matrix.clear();
james_dean.positive_hex_mutex.unlock();
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);
std::lock_guard<std::mutex> print_lock8(james_dean.print_mutex);
float positive_hex_float_seconds = positive_hex_nanoseconds.count() / 1'000'000'000;
std::cout << "[" << thread_id << "] positive_hex (" << james_dean.positive_hex_target << ") creation time: " << positive_hex_float_seconds << "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();
std::lock_guard<std::mutex> random_lock(james_dean.random_matrix_mutex);
james_dean.local_random_matrix = return_random_matrix(thread_id);
local_james_dean_data.call_set_local_random_matrix(james_dean.local_random_matrix);
james_dean.local_random_matrix.clear();
james_dean.random_matrix_mutex.unlock();
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);
std::lock_guard<std::mutex> print_lock10(james_dean.print_mutex);
float random_float_seconds = random_nanoseconds.count() / 1'000'000'000;
std::cout << "[" << thread_id << "] random (" << james_dean.positive_hex_target << ") creation time: " << random_float_seconds << "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();
std::lock_guard<std::mutex> mod_random_lock(james_dean.mod_random_matrix_mutex);
james_dean.local_mod_random_matrix = return_random_matrix(thread_id);
local_james_dean_data.call_set_local_mod_random_matrix(james_dean.local_mod_random_matrix);
james_dean.local_random_matrix.clear();
james_dean.random_matrix_mutex.unlock();
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);
std::lock_guard<std::mutex> print_lock12(james_dean.print_mutex);
float mod_random_float_seconds = mod_random_nanoseconds.count() / 1'000'000'000;
std::cout << "[" << thread_id << "] mod_random (" << james_dean.random_target << ") creation time: " << mod_random_float_seconds << "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();
std::lock_guard<std::mutex> hash_table_lock(james_dean.hash_table_mutex);
james_dean.local_hash_table_matrix = return_hash_table_matrix(thread_id);
local_james_dean_data.call_set_local_hash_table_matrix(james_dean.local_hash_table_matrix);
james_dean.local_hash_table_matrix.clear();
james_dean.hash_table_mutex.unlock();
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);
std::lock_guard<std::mutex> print_lock14(james_dean.print_mutex);
float hash_table_float_seconds = hash_table_nanoseconds.count() / 1'000'000'000;
std::cout << "[" << thread_id << "] hash_table (" << james_dean.hash_table_target << ") creation time: " << hash_table_float_seconds << "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();
std::lock_guard<std::mutex> arbitrary_component_device_lock(james_dean.arbitrary_component_device_mutex);
james_dean.local_arbitrary_component_device_matrix = return_arbitrary_component_device_matrix(thread_id);
local_james_dean_data.call_set_arbitrary_component_device_matrix(james_dean.local_arbitrary_component_device_matrix);
james_dean.local_arbitrary_component_device_matrix.clear();
james_dean.arbitrary_component_device_mutex.unlock();
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);
std::lock_guard<std::mutex> print_lock16(james_dean.print_mutex);
float arbitrary_component_device_float_seconds = arbitrary_component_device_nanoseconds.count() / 1'000'000'000;
std::cout << "[" << thread_id << "] arbitrary_component_device (" << james_dean.arbitrary_component_device_target << ") creation time: " << arbitrary_component_device_float_seconds << "s\n";
james_dean.print_mutex.unlock();
std::lock_guard<std::mutex> print_lock17(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);
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_lock18(james_dean.print_mutex);
float matrice_float_seconds = matrice_nanoseconds.count() / 1'000'000'000;
std::cout << "[" << thread_id << "] total matrice (" << total_matrices_created << ") creation time: " << matrice_float_seconds << "s\n";
james_dean.print_mutex.unlock();
james_dean.local_james_dean_vector.push_back(&local_james_dean_data);
james_dean.total_data_counter = james_dean.total_data_counter + 1;
std::lock_guard<std::mutex> print_lock19(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();
}
}
// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// RETURN DATA BUFF MATRIX
std::vector<std::vector<data_buff*>> return_data_buff_matrix(signed long long int thread_id)
{
signed long long int current_db_vector = 0;
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);
james_dean.local_system_id = james_dean.local_system_id + 1;
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);
if(james_dean.local_type_id >= james_dean.type_target)
{
james_dean.local_type_id = 0;
james_dean.local_class_id = james_dean.local_class_id + 1;
if(james_dean.local_class_id >= james_dean.class_target)
{
james_dean.local_class_id = 0;
james_dean.local_data_id = james_dean.local_data_id + 1;
if(james_dean.local_data_id >= james_dean.data_target)
{
james_dean.local_data_id = 0;
james_dean.local_production_id = james_dean.local_production_id + 1;
}
}
}
james_dean.local_random_matrix = return_random_matrix(thread_id);
local_data_buff.call_set_local_random_matrix(james_dean.local_random_matrix);
james_dean.local_random_matrix.clear();
james_dean.local_mod_random_matrix = return_random_matrix(thread_id);
local_data_buff.call_set_local_mod_random_matrix(james_dean.local_mod_random_matrix);
james_dean.local_random_matrix.clear();
james_dean.local_hash_table_matrix = return_hash_table_matrix(thread_id);
local_data_buff.call_set_local_hash_table_matrix(james_dean.local_hash_table_matrix);
james_dean.local_hash_table_matrix.clear();
james_dean.local_data_buff_matrix[current_db_vector].push_back(&local_data_buff);
if(james_dean.local_data_buff_matrix[current_db_vector].size() > 30)
{
current_db_vector = current_db_vector + 1;
james_dean.local_data_buff_matrix.push_back(james_dean.small_data_buff_vector);
}
james_dean.data_buff_count = james_dean.data_buff_count + 1;
}
return(james_dean.local_data_buff_matrix);
}
// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// RETURN POSITIVE HEX MATRIX
std::vector<std::vector<positive_hex*>> return_positive_hex_matrix(signed long long int thread_id)
{
signed long long int current_ph_vector = 0;
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);
james_dean.local_system_id = james_dean.local_system_id + 1;
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);
james_dean.local_type_id = james_dean.local_type_id + 1;
if(james_dean.local_type_id >= james_dean.type_target)
{
james_dean.local_type_id = 0;
james_dean.local_class_id = james_dean.local_class_id + 1;
if(james_dean.local_class_id >= james_dean.class_target)
{
james_dean.local_class_id = 0;
james_dean.local_data_id = james_dean.local_data_id + 1;
if(james_dean.local_data_id >= james_dean.data_target)
{
james_dean.local_data_id = 0;
james_dean.local_production_id = james_dean.local_production_id + 1;
}
}
}
james_dean.local_random_matrix = return_random_matrix(thread_id);
local_positive_hex.call_set_local_random_matrix(james_dean.local_random_matrix);
james_dean.local_random_matrix.clear();
james_dean.local_mod_random_matrix = return_random_matrix(thread_id);
local_positive_hex.call_set_local_mod_random_matrix(james_dean.local_mod_random_matrix);
james_dean.local_random_matrix.clear();
james_dean.local_hash_table_matrix = return_hash_table_matrix(thread_id);
local_positive_hex.call_set_local_hash_table_matrix(james_dean.local_hash_table_matrix);
james_dean.local_hash_table_matrix.clear();
james_dean.local_positive_hex_matrix[current_ph_vector].push_back(&local_positive_hex);
if(james_dean.local_positive_hex_matrix[current_ph_vector].size() > 30)
{
current_ph_vector = current_ph_vector + 1;
james_dean.local_positive_hex_matrix.push_back(james_dean.small_positive_hex_vector);
}
james_dean.positive_hex_count = james_dean.positive_hex_count + 1;
}
return(james_dean.local_positive_hex_matrix);
}
// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// RETURN ARBITRARY COMPONENT DEVICE
std::vector<std::vector<arbitrary_component_device*>> return_arbitrary_component_device_matrix(signed long long int thread_id)
{
signed long long int current_acd_vector = 0;
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);
james_dean.local_system_id = james_dean.local_system_id + 1;
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);
james_dean.local_type_id = james_dean.local_type_id + 1;
if(james_dean.local_type_id >= james_dean.type_target)
{
james_dean.local_type_id = 0;
james_dean.local_class_id = james_dean.local_class_id + 1;
if(james_dean.local_class_id >= james_dean.class_target)
{
james_dean.local_class_id = 0;
james_dean.local_data_id = james_dean.local_data_id + 1;
if(james_dean.local_data_id >= james_dean.data_target)
{
james_dean.local_data_id = 0;
james_dean.local_production_id = james_dean.local_production_id + 1;
}
}
}
james_dean.local_random_matrix = return_random_matrix(thread_id);
local_arbitrary_component_device.call_set_local_random_matrix(james_dean.local_random_matrix);
james_dean.local_random_matrix.clear();
james_dean.local_mod_random_matrix = return_random_matrix(thread_id);
local_arbitrary_component_device.call_set_local_mod_random_matrix(james_dean.local_mod_random_matrix);
james_dean.local_random_matrix.clear();
james_dean.local_hash_table_matrix = return_hash_table_matrix(thread_id);
local_arbitrary_component_device.call_set_local_hash_table_matrix(james_dean.local_hash_table_matrix);
james_dean.local_hash_table_matrix.clear();
james_dean.local_arbitrary_component_device_matrix[current_acd_vector].push_back(&local_arbitrary_component_device);
if(james_dean.local_arbitrary_component_device_matrix[current_acd_vector].size() > 30)
{
current_acd_vector = current_acd_vector + 1;
james_dean.local_arbitrary_component_device_matrix.push_back(james_dean.small_arbitrary_component_device_vector);
}
james_dean.arbitrary_component_device_count = james_dean.arbitrary_component_device_count + 1;
}
return(james_dean.local_arbitrary_component_device_matrix);
}
// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// RETURN HASH TABLE MATRIX
std::vector<std::vector<hash_table*>> return_hash_table_matrix(signed long long 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());
unsigned long long int result_int = uniform_dist(pcg_k16);
signed long long int string_size = 500;
signed long long int table_size = 500;
signed long long int vector_count = 50;
signed long long int table_counter = 0;
signed long long 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;
signed long long int hash_table_target = 4;
signed long long int vector_target = 7;
signed long long int table_target = 10;
signed long long int str_target = 12;
signed long long int letter_target = 24;
signed long long int set_str_target = 30;
std::vector<std::string> local_str_vector;
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);
james_dean.local_system_id = james_dean.local_system_id + 1;
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);
james_dean.local_random_matrix = return_random_matrix(thread_id);
local_hash_table.call_set_local_random_matrix(james_dean.local_random_matrix);
james_dean.local_random_matrix.clear();
james_dean.local_mod_random_matrix = return_random_matrix(thread_id);
local_hash_table.call_set_local_mod_random_matrix(james_dean.local_random_matrix);
james_dean.local_random_matrix.clear();
hash_table_vector[current_vector].push_back(&local_hash_table);
}
}
return(hash_table_vector);
}
// ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=--- ---=+=---
// RETURN RANDOM MATRIX
std::vector<std::vector<signed long long int>> return_random_matrix(signed long long int thread_id)
{
pcg_extras::seed_seq_from<std::random_device> seed_source;
pcg32_k16384 pcg_k16(seed_source);
signed long long int vector_target = 70;
signed long long int set_target = 40;
signed long long int random_target = 200;
std::vector<std::vector<signed long long int>> local_big_random_vector;
std::vector<signed long long int> local_small_random_vector;
signed long long int vector_counter = 0;
signed long long int set_counter = 0;
signed long long int random_counter = 0;
signed long long int random_number = pcg_k16();
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();
local_big_random_vector[current_vector].push_back(random_number);
}
}
}
return(local_big_random_vector);
}god bless america!
so the crack that results from running this program I am donating it all to the Japanese. Then the crack from the shot we will take next, goes all to the Mob, the actual destruction or loss from the fight against the negative will go to the Mob.
So as she lay there asking for water and food and to go to the bathroom, I was playing the song “run through the jungle” by creedence clearwater revival — it says “200 million guns are loaded, satan cries take aim!” and then later I had this daydream of the “Plumed Archers” from Age Of Empires 2 taking their bows and aiming them up above negative energy, and taking the last shot at them, they would either succeed here, or lose against the negative. But what was behind those arrows flying everywhere was every ounce of pain that anyone had ever gone through, and higher quality pains as in the case of more severe pain.
My mom ordered a ham and cheese sandwich and when we got it, it was a turkey sandwich. After the plumed archer incident, in Age Of Empires 2 the “aztec” or “mayan” default zone is “Yucatan” and in yucatan they have turkeys. So I tried to get my mom to eat it all.
She took two bites… and then…
Set the sandwich down. Then she picked it back up after catching her breath, and took a third bite. As I was watching her bite in a different area, I could see that the two bites were both gone, and also still there at the same time. She set her sandwich down again, it had one bite in it, instead of three. This was the slip we were giving negative energy, — a super fuck you, negative energy, we weren’t going to stand for your shit any longer and gave it everything we had. I took the whole sandwich thing as proof that this was at least something important, like the real shot, like a message from those Plumed Archers who lived so long ago. (Plumed Archers are either “Aztec” or “Mayan” civilization, existing many moons ago. To get a message like that from them, denoting that this was the very beginning of something — in the beginning of Age Of Empires 2 you kill your turkeys for food to get your empire started.)
So there’s no connection between the sandwich thing and Aztec or Mayan civilizations, technically, so you have to stretch out your mind a bit to get it around all of this.
And so I hurriedly record my last thoughts before entering “The Great Devoid” (the part of time that goes on after the last battle in Myth, the great devoid is my name for a long period of time that is done like doing jail time having the theme of kind of we were free from the negative… like, we had done all that we could do, and now it was just down to time) and leave my journal in the care of Sauron, knowing that I may not return, and that it may not even matter.
Either we kill negative energy here, or we lose and die, and the world with us!
Also the Africa Corps receive a copy of what the Mob gets in this script, the crack energy from the crack that arises from the shot we all take at negative energy here, the shot being backed by all the pain that has ever occurred in any universe, we stand to hit it realllllly hard, and I don’t intend to lose either.
There are two outcomes here, either we win here, and it is destroyed and generally bad things do not happen, or we lose to it, and for thousands of years possibly we are tormented by negative energy as we grind it away.
The strangest thing is that you can kill it, delete it, bury it, and it’s still there, winking at you or something, there’s possibly something i’m missing in this post that is key to the substance of it but I cannot remember anything… Insert that key next:
Also the combine overwatch receives a copy, and then…
Everyone receives a copy of it!
edit: you shouldn’t take 1000mg of marijuana after reading this, your blood pressure can drop so low that you die, or you forget to breathe your so high, it’s really really really uncomfortable and do NOT take 1000mg of marijuana don’t even take 250mg take 30mg of marijuana at the most!
That is what the preachers cry from their temples — victory.
I am truly thankful to the owner of this web site who has shared this fantastic piece of writing at at this place.
Awesome tips! I’ll definitely try some of these ideas.