DbDDsM2j

1/// Authorship - infinite authentication tool
2///
3/// Version: 1, functions: 12,000-digit multi-way
4/// Computational difficulty and super-flexibility in endless cryptographic evidence
5/// (publicly-verifiable authorized-only number modification)
6/// Nikolay Valentinovich Repnitskiy - documentation & software license: WTFPLv2+ (wtfpl.net.)
7
8/*Please read the nine-page documentation as it is unusually beautiful, informative, and graphic for such a technical project.
9You can generate and publish a personal Authorship number, preferably before you are subject to censorship or worse. This way,
10the public can trust its ownership. Once you become a government threat, the public will inquire about your well being after which,
11you modify your number. Given that only you can modify your number and given that the public or verifying party is here-given the
12ability to verify your modification, we can rest assured that any further correspondence from you is not impersonation. The best
13part is, you can insert data or any message for every authentication event meaning information source can be trusted. Using these
14three properties, Authorship as-is provides the following functionality, as detailed in the documentation.
15
16	* Proof of life
17	* User authentication
18	* Canary update authentication
19	* Data, author, and version control authentication
20	* Unretentive suspend-able untraceable anonymous cryptocurrency (publicly-verifiable authorized-only withdrawal or ownership hand-over)
21	* Untraceable anonymous fair trade over any network (cryptographic solution to the Prisoner’s Dilemma)
22
23How to run the program - Software package repositories for GNU+Linux operating systems have all the developer
24tools you need. Open a terminal and use the following command as root to install Geany and g++ on your computer.
25	apt install geany g++
26Geany is a fast and lightweight text editor and Integrated Development Environment (IDE) in which you can write and run
27code. g++ is the GNU compiler for C++ which allows written code to run. The compiler operates in the background
28automatically and displays errors in your code as you will see in the lower box in Geany. Create a folder somewhere on
29your machine. Open Geany and paste this code into the blank Geany page. Now you can get code-highlighting and set this
30document as a C++ source file. Go to Document >> Set Filetype >> Programming Languages >> C++ source file. (A good tip
31for clarity in auditing is to enable the indentation guides for the block braces. Go to View >> Show Indentation Guides.)
32Save the file as anything.cpp within the newly created folder (Geany will automatically suggest the .cpp extension.)
33This folder is now the home directory of Authorship.cpp--which will create, write to, and read from files within this folder.
34And now you can build then run the program. Use the following Geany shortcuts in order: F9, F5. Whenever it is you wish to use
35Authorship again, open Geany and use the same shortcuts. This will work for any single C++ files whether you paste over
36the current code or open a new file and repeat the process.
37
38You can verify Authorship version control authentication via my first Authorship number:
394523671117254537097693499431873393755009364060988731339955541555938773776426890663223311271998814408425658122410534158628704624876885064033832973303257615671169104146725545829395892153641696722789762397324205856487525253480486335563218618467620996678530597337485824711496066940069750023695890925716907621880507576788843057976137078706159069156432353836254336325807081930268437687591231053926179976642242656846521113064209506521903660032382272493050687940897841665174445617493375991432505818525319389380867283526282151778905117826662036240339165570290133801498835627144391581798167113359589788821315574150139086921336740545442825837175526061566502335370842723111121906894692022951443921665156303004845395615751451178833267397995223688914976938992763237723630966284978742219225922402878097850317232944566981288766177427321855682143216533925852232540986669601451146769125653913262111262981052683921306235735766468956557428610858478551848753521144855128716705223064416023877308758593485710231868507049254
40If this number is never modified, then I never altered this program. Anyone claiming my name without modifying this number cannot be trusted.
41(Modified numbers must be verified using THIS program.) Save this number in a text file and name it "Authorship.number"
42then wait for the file Authorship.public - only this file can modify my number. Authorship.public files are ~207MB.
43Your Authorship.number file will then be overwritten with my new number and you can discard any old files.
44Your Authorship.number file will then contain data about the alteration details of this program.
45
46Authorship and its future variations can be used for the greatest good and evil... don't underestimate uncle Sam.
47Authorship would not have been possible without direct inspiration from my personal heroes who demonstrated
48beautifully the need for endless cryptographic evidence--Julian Assange and Edward Snowden--this is for you!
49
50
51
52
53
54The three basic text files you should know about:
55-------------------------------------------------------------------------------------------------------------------
56Authorship.number   (Storage for another user's Authorship number and message, you will change it as they publish.)   1kB
57Authorship.public   (Number modification information meant to be published. This file will construct a new number.)  ~207MB
58Authorship.private  (*SENSITIVE* Dynamic storage for your Authorship info & keys. This produces Authorship.public.)  ~243MB
59-----------------------------------------------------------------------------------------------------------------*/
60#include <cstdlib> //For rand() & srand() (user defined seeds as well as Unix time.)
61#include <ctime>   //For time function (here only Unix time.)
62#include <fstream> //For file I/O (creates, writes to, and reads from ONLY the three files mentioned above.)
63#include <iostream>
64using namespace std;
65
66int main()
67{	int user_option; //These three functionalities reuse code and run independently (highly modular & audit-friendly.)
68	//(You can run each of the three ifs holding options 1, 2, and 3, in isolation from one another--they are self-sustained.)
69	cout << "\n(Authorship) - infinite authentication tool\n\n"
70		 
71		 << " (1) Get Authorship number\n"
72		 << "        (Generates your first number. This option is used\n"
73		 << "         only once unless you know what you’re doing.)\n\n"
74		 
75		 << " (2) Modify Authorship number\n"
76		 << "        (Generates your new number. Your old number is then modified to\n"
77		 << "         represent this new one, as well as any message of your choice.)\n\n"
78		 
79		 << " (3) Verify number modification\n"
80		 << "        (Generates their new number using their published file.\n"
81		 << "         This file's function-compression must match their old number.\n\n"
82		 
83		 << "Enter option: ";
84	cin >> user_option;
85	if((user_option != 1) && (user_option != 2) && (user_option != 3)) {cout << "\n\nProgram ended.\n\n"; return 0;}
86	
87	
88	
89	
90	
91	//________________________________________________________________________________________________________________________
92	//                                                                                                                       |
93	//                                           1   Get Authorship number                                                   |
94	//_______________________________________________________________________________________________________________________|
95	if(user_option == 1)
96	{	//The following block-bunch generates random numbers in array Authorship_private[].
97		cout << "\n>>>>>>>>>>>>>>>>>>>>>>>(Get your first Authorship number)<<<<<<<<<<<<<<<<<<<<<<<\n";
98		cout << "Random number generator takes 5 minutes. Enter 8 random digits, repeat 50 times.\n\n";
99		
100		unsigned int user_seed[50]; //Fills user_seed with 50 user-defined seeds of size 8.
101		for(int a = 0; a < 50; a++)
102		{	if(a < 9) {cout << " " << (a + 1) << " of 50: ";} //Prints blank to align input status report (aesthetics.)
103			else {cout << (a + 1) << " of 50: ";}
104			
105			cin >> user_seed[a];
106		} //CAUTION: "cin" must exist last, just before the rest of the computation-heavy program begins,
107		//otherwise some things may not be printed and INPUT STREAMS CAN BE SKIPPED such as cin.getline() (see option 2.)
108		//Be extra careful when changing order of user inputs here. The old compiler and hardware used for this build
109		//seems to require all of these sub-optimal methods in order to actually get input, as well as save on memory.
110		//(It's important to build sensitive sofware as such on the worst possible machines as is will be run on such
111		//machines elsewhere in the world. Plus, ceap disposable machines like that give you connectivity control
112		//as you can easily strip wifi cards and other sensors.)
113		
114		
115		
116		
117		
118		static char Authorship_private[256500000]; //This array is filled with random digits then read from and written to left to right
119		//dynamically to save RAM space. It provides random digit input and temporary key storage (to be written to file: Authorship.private.)
120		int read_bookmark = 1000000;  //Bookmarks where to read next from Authorship_private[]. Initial size Prevents read/write collision.
121		int write_bookmark = 0; //Bookmarks where to write next in  Authorship_private[].
122		//(Function generation extracts random numbers using read/write bookmarks. Authorship_private[] is first filled with random numbers normally.)
123		
124		for(int a = 0; a < 50; a++) //Generates a random location (+10^6) for where to read from Authorship_private[]. This step prevents bookmark
125		{	read_bookmark += (user_seed[a] % 10000); //collision and adds to the randomness strength. Average total value for read_bookmark: 1,250,000.
126		} //The last item in the for loop who generates 13,500 multi-way functions deals with collision again, allowing bookmark proximity of ~30,000.
127		
128		srand(time(0));
129		for(int a = 256499999; a >= 0; a--) //Fills Authorship_private[] with random numbers based on Unix time. WRITES RIGHT TO LEFT.
130		{	Authorship_private[a] = (rand() % 10);
131		}
132		
133		for(int a = 0; a < 50; a++) //Constructively applies random digits to Authorship_private[] based on the 50 seeds provided by the user.
134		{	srand(user_seed[a]);    //WRITES ALTERNATING BETWEEN LEFT TO RIGHT & RIGHT TO LEFT. Alternation is based on the 50 user seeds.
135			
136			if((user_seed[a] % 2) == 0)
137			{	for(int b = 0; b < 256500000; b++) //WRITES LEFT TO RIGHT.
138				{	Authorship_private[b] = (Authorship_private[b] + (rand() % 10));
139					Authorship_private[b] %= 10;
140				}
141			}
142			else
143			{	for(int b = 256499999; b >= 0; b--) //WRITES RIGHT TO LEFT.
144				{	Authorship_private[b] = (Authorship_private[b] + (rand() % 10));
145					Authorship_private[b] %= 10;
146				}
147			}
148		}
149		
150		srand(time(0)); //Constructively applies random numbers to Authorship_private[] once more, based on Unix time. WRITES LEFT TO RIGHT.
151		for(int a = 0; a < 256500000; a++)
152		{	Authorship_private[a] = (Authorship_private[a] + (rand() % 10));
153			Authorship_private[a] %= 10;
154		}
155		
156		
157		
158		
159		
160		//These declarations are for deductive lossy compression, they produce the Authorship number dynamically.
161		//See the compression block-bunch near the end of the following for loop who generates 13,500 functions.
162		long long int compression_115[100]; //Hops by -115
163		long long int snapshot_115[100]; //Takes a snapshot of compression_115[] every once in a while.
164		
165		long long int compression_116[100]; //Hops by -116
166		long long int snapshot_116[100]; //Takes a snapshot of compression_116[] every once in a while.
167		
168		long long int compression_117[100]; //Hops by -117
169		long long int snapshot_117[100]; //Takes a snapshot of compression_117[] every once in a while.
170		
171		long long int compression_118[100]; //Hops by -118
172		long long int snapshot_118[100]; //Takes a snapshot of compression_118[] every once in a while.
173		
174		long long int compression_119[100]; //Hops by -119
175		long long int snapshot_119[100]; //Takes a snapshot of compression_119[] every once in a while.
176		
177		for(int a = 0; a < 100; a++)
178		{	compression_115[a] = 5555555555;
179			snapshot_115[a] = 5555555555;
180			
181			compression_116[a] = 5555555555;
182			snapshot_116[a] = 5555555555;
183			
184			compression_117[a] = 5555555555;
185			snapshot_117[a] = 5555555555;
186			
187			compression_118[a] = 5555555555;
188			snapshot_118[a] = 5555555555;
189			
190			compression_119[a] = 5555555555;
191			snapshot_119[a] = 5555555555;
192		}
193		
194		//This is a boolean sieve of Eratosthenes. Zeros are prime, conveniently mapped to their element index. (It is used here like the following
195		//example: if(sieve[my_candidate] == 0) then my_candidate is prime. Otherwise, my_candidate is increased until it is prime. This adjusts
196		//my_candidate for primality in the positive direction.) And values over 99 for 2-digit primes for example are set to the largest prime < 100.)
197		bool sieve[100000] = {1, 1};
198		for(int prime = 2; prime < 317; prime++) //317 is sqrt(100000)
199		{	for(int a = prime + prime; a < 100000; a += prime) {sieve[a] = 1;}
200		}
201		
202		
203		
204		
205		
206		//The following for loop generates 13,500 multi-way functions in array Authorship_private[].
207		for(int f = 0; f < 13500; f++)
208		{	//The following block-bunch generates sub-function 1 for the current function. (Cool zone.)
209			int transformation_determinant[2000];
210			for(int a = 0; a < 2000; a++) //Fills transformation_determinant[] with random digits.
211			{	transformation_determinant[a] = Authorship_private[read_bookmark];
212				read_bookmark++;
213			}
214			
215			int sub_key[2000];
216			int temp_sub_key[2000];
217			for(int a = 0; a < 2000; a++) //Fills sub_key[] with random digits. This sub-key will be transformed and used dynamically.
218			{	sub_key[a] = Authorship_private[read_bookmark];
219				temp_sub_key[a] = Authorship_private[read_bookmark]; //Makes temp copy of sub-key so as to later append it near the current
220				read_bookmark++;                                     //ciphertext when complete. (Written to Authorship_private[].)
221			}                                                        //These kind of details prevent read/write_bookmark collision.
222			
223			for(int a = 0; a < 2000; a++) //Generates first sub-ciphertext of current function and writes it to Authorship_private[].
224			{	Authorship_private[write_bookmark] = sub_key[a];
225				Authorship_private[write_bookmark] += Authorship_private[read_bookmark];
226				Authorship_private[write_bookmark] %= 10;
227				read_bookmark++;
228				write_bookmark++;
229			}
230			
231			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
232			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
233			
234			for(int a = 0; a < 1999; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 2.)
235			{	sub_key[a] += transformation_determinant[a];
236				sub_key[a] = ((sub_key[a] + transformation_determinant[a + 1]) % 10); //[a + 1] means do up to 1998 or seg fault.
237			}
238			sub_key[1999] = ((sub_key[1999] + transformation_determinant[1000]) % 10); //Last element was not transformed so here it is.
239			//(1st of 5 total transformations per function.) Each one is different.
240			
241			
242			
243			
244			
245			//The following block-bunch generates sub-function 2 for the current function. (Hot zone.)
246			int sub_plaintext_SUB2[2000];
247			int prime_lengths_in_order_SUB2[1000]; //Expected contiguous primes: ~667.
248			
249			int length_sum_SUB2 = 0;
250			int element_SUB2 = 0; //Begins writing to prime_lengths_in_order_SUB2[] from element 0 (basic counter.)
251			while(length_sum_SUB2 < 2000)
252			{	if(Authorship_private[read_bookmark] < 5) {	Authorship_private[read_bookmark]++;} //Reassignes (0=1,1=2,2=3,3=4,4=5.)
253				else //Assignes 5 to: 1, 6 to: 2, 7 to: 3, 8 to: 4, and 9 to: 5. (All prime lengths must be 1-5.)
254				{	Authorship_private[read_bookmark] += 16;
255					Authorship_private[read_bookmark] %= 10; //Example: 7: (7+16) = 23, 23 mod 10 = 3. Seven is now 3.
256				}
257				
258				length_sum_SUB2 += Authorship_private[read_bookmark];
259				prime_lengths_in_order_SUB2[element_SUB2] = Authorship_private[read_bookmark]; //Prime lengths are recorded in
260				element_SUB2++; //prime_lengths_in_order_SUB2[] so as to later append it near the current ciphertext when complete.
261				read_bookmark++; //    ...(Written to Authorship_private[].)
262			}
263			
264			element_SUB2--;
265			if(length_sum_SUB2 > 2000) //Subtracts from last entry in prime_lengths_in_order_SUB2[] so as to ensure sum(entries) = 2,000.
266			{	int overflow = (length_sum_SUB2 % 10);
267				prime_lengths_in_order_SUB2[element_SUB2] -= overflow;
268			}
269			
270			int write_bookmark_SUB2 = 0;
271			for(int a = 0; a <= element_SUB2; a++) //Genetates primes of corresponding length & writes them to sub_plaintext_SUB2[].
272			{	if(prime_lengths_in_order_SUB2[a] == 1) //Randomly generates a single-digit prime.
273				{	if(Authorship_private[read_bookmark] < 5)
274					{	if(Authorship_private[read_bookmark + 1] < 5) {sub_plaintext_SUB2[write_bookmark_SUB2] = 2;} //The prime 2.
275						else {sub_plaintext_SUB2[write_bookmark_SUB2] = 3;} //The prime 3.
276					}
277					
278					else
279					{	if(Authorship_private[read_bookmark + 1] < 5) {sub_plaintext_SUB2[write_bookmark_SUB2] = 5;} //The prime 5.
280						else {sub_plaintext_SUB2[write_bookmark_SUB2] = 7;} //The prime 7.
281					}
282					
283					write_bookmark_SUB2++;
284					read_bookmark += 2;
285					continue;
286				}
287				
288				if(prime_lengths_in_order_SUB2[a] == 2) //Randomly generates a two-digit prime.
289				{	int temp_2_digit_prime;
290					temp_2_digit_prime = Authorship_private[read_bookmark]; //Unloads 2 array elements to make one integer.
291					if(temp_2_digit_prime == 0) {temp_2_digit_prime++;}
292					temp_2_digit_prime *= 10;
293					temp_2_digit_prime += Authorship_private[read_bookmark + 1];
294					
295					while(sieve[temp_2_digit_prime] == 1) //Adjusts temp_2_digit_prime for primality (tests current value & searches in pos dir.)
296					{	if(temp_2_digit_prime > 99) {temp_2_digit_prime = 97; break;} //If exceeds length of 2, sets it to largest 2-digit prime.
297						temp_2_digit_prime++;
298					}
299					
300					sub_plaintext_SUB2[write_bookmark_SUB2 + 1] = (temp_2_digit_prime % 10); //Writes prime to sub_plaintext_SUB2[].
301					temp_2_digit_prime /= 10;
302					sub_plaintext_SUB2[write_bookmark_SUB2] = temp_2_digit_prime;
303					
304					write_bookmark_SUB2 += 2;
305					read_bookmark += 2;
306					continue;
307				}
308				
309				if(prime_lengths_in_order_SUB2[a] == 3) //Randomly generates a three-digit prime.
310				{	int temp_3_digit_prime;
311					temp_3_digit_prime = Authorship_private[read_bookmark]; //Unloads 3 array elements to make one integer.
312					if(temp_3_digit_prime == 0) {temp_3_digit_prime++;}
313					temp_3_digit_prime *= 10;
314					temp_3_digit_prime += Authorship_private[read_bookmark + 1];
315					temp_3_digit_prime *= 10;
316					temp_3_digit_prime += Authorship_private[read_bookmark + 2];
317					
318					while(sieve[temp_3_digit_prime] == 1) //Adjusts temp_3_digit_prime for primality (tests current value & searches in pos dir.)
319					{	if(temp_3_digit_prime > 999) {temp_3_digit_prime = 997; break;} //If exceeds length of 3, sets it to largest 3-digit prime.
320						temp_3_digit_prime++;
321					}
322					
323					sub_plaintext_SUB2[write_bookmark_SUB2 + 2] = (temp_3_digit_prime % 10); //Writes prime to sub_plaintext_SUB2[].
324					temp_3_digit_prime /= 10;
325					sub_plaintext_SUB2[write_bookmark_SUB2 + 1] = (temp_3_digit_prime % 10);
326					temp_3_digit_prime /= 10;
327					sub_plaintext_SUB2[write_bookmark_SUB2] = temp_3_digit_prime;
328					
329					write_bookmark_SUB2 += 3;
330					read_bookmark += 3;
331					continue;
332				}
333				
334				if(prime_lengths_in_order_SUB2[a] == 4) //Randomly generates a four-digit prime.
335				{	int temp_4_digit_prime;
336					temp_4_digit_prime = Authorship_private[read_bookmark]; //Unloads 4 array elements to make one integer.
337					if(temp_4_digit_prime == 0) {temp_4_digit_prime++;}
338					temp_4_digit_prime *= 10;
339					temp_4_digit_prime += Authorship_private[read_bookmark + 1];
340					temp_4_digit_prime *= 10;
341					temp_4_digit_prime += Authorship_private[read_bookmark + 2];
342					temp_4_digit_prime *= 10;
343					temp_4_digit_prime += Authorship_private[read_bookmark + 3];
344					
345					while(sieve[temp_4_digit_prime] == 1) //Adjusts temp_4_digit_prime for primality (tests current value & searches in pos dir.)
346					{	if(temp_4_digit_prime > 9999) {temp_4_digit_prime = 9973; break;} //If exceeds length of 4, sets it to largest 4-digit prime.
347						temp_4_digit_prime++;
348					}
349					
350					sub_plaintext_SUB2[write_bookmark_SUB2 + 3] = (temp_4_digit_prime % 10); //Writes prime to sub_plaintext_SUB2[].
351					temp_4_digit_prime /= 10;
352					sub_plaintext_SUB2[write_bookmark_SUB2 + 2] = (temp_4_digit_prime % 10);
353					temp_4_digit_prime /= 10;
354					sub_plaintext_SUB2[write_bookmark_SUB2 + 1] = (temp_4_digit_prime % 10);
355					temp_4_digit_prime /= 10;
356					sub_plaintext_SUB2[write_bookmark_SUB2] = temp_4_digit_prime;
357					
358					write_bookmark_SUB2 += 4;
359					read_bookmark += 4;
360					continue;
361				}
362				
363				if(prime_lengths_in_order_SUB2[a] == 5) //Randomly generates a five-digit prime.
364				{	int temp_5_digit_prime;
365					temp_5_digit_prime = Authorship_private[read_bookmark]; //Unloads 5 array elements to make one integer.
366					if(temp_5_digit_prime == 0) {temp_5_digit_prime++;}
367					temp_5_digit_prime *= 10;
368					temp_5_digit_prime += Authorship_private[read_bookmark + 1];
369					temp_5_digit_prime *= 10;
370					temp_5_digit_prime += Authorship_private[read_bookmark + 2];
371					temp_5_digit_prime *= 10;
372					temp_5_digit_prime += Authorship_private[read_bookmark + 3];
373					temp_5_digit_prime *= 10;
374					temp_5_digit_prime += Authorship_private[read_bookmark + 4];
375					
376					while(sieve[temp_5_digit_prime] == 1) //Adjusts temp_5_digit_prime for primality (tests current value & searches in pos dir.)
377					{	if(temp_5_digit_prime > 99999) {temp_5_digit_prime = 99991; break;} //If exceeds length of 5, sets it to largest 5-digit prime.
378						temp_5_digit_prime++;
379					}
380					
381					sub_plaintext_SUB2[write_bookmark_SUB2 + 4] = (temp_5_digit_prime % 10); //Writes prime to sub_plaintext_SUB2[].
382					temp_5_digit_prime /= 10;
383					sub_plaintext_SUB2[write_bookmark_SUB2 + 3] = (temp_5_digit_prime % 10);
384					temp_5_digit_prime /= 10;
385					sub_plaintext_SUB2[write_bookmark_SUB2 + 2] = (temp_5_digit_prime % 10);
386					temp_5_digit_prime /= 10;
387					sub_plaintext_SUB2[write_bookmark_SUB2 + 1] = (temp_5_digit_prime % 10);
388					temp_5_digit_prime /= 10;
389					sub_plaintext_SUB2[write_bookmark_SUB2] = temp_5_digit_prime;
390					
391					write_bookmark_SUB2 += 5;
392					read_bookmark += 5;
393					continue;
394				}
395			}
396			
397			for(int a = 0; a < 2000; a++) //Generates second sub-ciphertext of current function and writes it to Authorship_private[].
398			{	Authorship_private[write_bookmark] = sub_key[a];
399				Authorship_private[write_bookmark] += sub_plaintext_SUB2[a];
400				Authorship_private[write_bookmark] %= 10;
401				write_bookmark++;
402			}
403			
404			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
405			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
406			
407			for(int a = 0; a < 1998; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 3.)
408			{	sub_key[a] += transformation_determinant[a];
409				sub_key[a] = ((sub_key[a] + transformation_determinant[a + 2]) % 10); //[a + 2] means do up to 1997 or seg fault.
410			}
411			sub_key[1998] = ((sub_key[1998] + transformation_determinant[1005]) % 10); //Last two elements were not transformed so here it is.
412			sub_key[1999] = ((sub_key[1999] + transformation_determinant[1010]) % 10);
413			//(2nd of 5 total transformations per function.) Each one is different.
414			
415			
416			
417			
418			
419			//The following block-bunch generates sub-function 3 for the current function. (Cool zone.)
420			for(int a = 0; a < 2000; a++) //Generates third sub-ciphertext of current function and writes it to Authorship_private[].
421			{	Authorship_private[write_bookmark] = sub_key[a];
422				Authorship_private[write_bookmark] += Authorship_private[read_bookmark];
423				Authorship_private[write_bookmark] %= 10;
424				read_bookmark++;
425				write_bookmark++;
426			}
427			
428			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
429			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
430			
431			
432			for(int a = 0; a < 1997; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 4.)
433			{	sub_key[a] += transformation_determinant[a];
434				sub_key[a] = ((sub_key[a] + transformation_determinant[a + 3]) % 10); //[a + 3] means do up to 1996 or seg fault.
435			}
436			sub_key[1997] = ((sub_key[1997] + transformation_determinant[1015]) % 10); //Last three elements were not transformed so here it is.
437			sub_key[1998] = ((sub_key[1998] + transformation_determinant[1020]) % 10);
438			sub_key[1999] = ((sub_key[1999] + transformation_determinant[1025]) % 10);
439			//(3rd of 5 total transformations per function.) Each one is different.
440			
441			
442			
443			
444			
445			//The following block-bunch generates sub-function 4 for the current function. (Hot zone.)
446			int sub_plaintext_SUB4[2000];
447			int prime_lengths_in_order_SUB4[1000]; //Expected contiguous primes: ~667.
448			
449			int length_sum_SUB4 = 0;
450			int element_SUB4 = 0; //Begins writing to prime_lengths_in_order_SUB4[] from element 0 (basic counter.)
451			while(length_sum_SUB4 < 2000)
452			{	if(Authorship_private[read_bookmark] < 5) {	Authorship_private[read_bookmark]++;} //Reassignes (0=1,1=2,2=3,3=4,4=5.)
453				else //Assignes 5 to: 1, 6 to: 2, 7 to: 3, 8 to: 4, and 9 to: 5. (All prime lengths must be 1-5.)
454				{	Authorship_private[read_bookmark] += 16;
455					Authorship_private[read_bookmark] %= 10; //Example: 7: (7+16) = 23, 23 mod 10 = 3. Seven is now 3.
456				}
457				
458				length_sum_SUB4 += Authorship_private[read_bookmark];
459				prime_lengths_in_order_SUB4[element_SUB4] = Authorship_private[read_bookmark]; //Prime lengths are recorded in
460				element_SUB4++; //prime_lengths_in_order_SUB4[] so as to later append it near the current ciphertext when complete.
461				read_bookmark++; //    ...(Written to Authorship_private[].)
462			}
463			
464			element_SUB4--;
465			if(length_sum_SUB4 > 2000) //Subtracts from last entry in prime_lengths_in_order_SUB4[] so as to ensure sum(entries) = 2,000.
466			{	int overflow = (length_sum_SUB4 % 10);
467				prime_lengths_in_order_SUB4[element_SUB4] -= overflow;
468			}
469			
470			int write_bookmark_SUB4 = 0;
471			for(int a = 0; a <= element_SUB4; a++) //Genetates primes of corresponding length & writes them to sub_plaintext_SUB4[].
472			{	if(prime_lengths_in_order_SUB4[a] == 1) //Randomly generates a single-digit prime.
473				{	if(Authorship_private[read_bookmark] < 5)
474					{	if(Authorship_private[read_bookmark + 1] < 5) {sub_plaintext_SUB4[write_bookmark_SUB4] = 2;} //The prime 2.
475						else {sub_plaintext_SUB4[write_bookmark_SUB4] = 3;} //The prime 3.
476					}
477					
478					else
479					{	if(Authorship_private[read_bookmark + 1] < 5) {sub_plaintext_SUB4[write_bookmark_SUB4] = 5;} //The prime 5.
480						else {sub_plaintext_SUB4[write_bookmark_SUB4] = 7;} //The prime 7.
481					}
482					
483					write_bookmark_SUB4++;
484					read_bookmark += 2;
485					continue;
486				}
487				
488				if(prime_lengths_in_order_SUB4[a] == 2) //Randomly generates a two-digit prime.
489				{	int temp_2_digit_prime;
490					temp_2_digit_prime = Authorship_private[read_bookmark]; //Unloads 2 array elements to make one integer.
491					if(temp_2_digit_prime == 0) {temp_2_digit_prime++;}
492					temp_2_digit_prime *= 10;
493					temp_2_digit_prime += Authorship_private[read_bookmark + 1];
494					
495					while(sieve[temp_2_digit_prime] == 1) //Adjusts temp_2_digit_prime for primality (tests current value & searches in pos dir.)
496					{	if(temp_2_digit_prime > 99) {temp_2_digit_prime = 97; break;} //If exceeds length of 2, sets it to largest 2-digit prime.
497						temp_2_digit_prime++;
498					}
499					
500					sub_plaintext_SUB4[write_bookmark_SUB4 + 1] = (temp_2_digit_prime % 10); //Writes prime to sub_plaintext_SUB4[].
501					temp_2_digit_prime /= 10;
502					sub_plaintext_SUB4[write_bookmark_SUB4] = temp_2_digit_prime;
503					
504					write_bookmark_SUB4 += 2;
505					read_bookmark += 2;
506					continue;
507				}
508				
509				if(prime_lengths_in_order_SUB4[a] == 3) //Randomly generates a three-digit prime.
510				{	int temp_3_digit_prime;
511					temp_3_digit_prime = Authorship_private[read_bookmark]; //Unloads 3 array elements to make one integer.
512					if(temp_3_digit_prime == 0) {temp_3_digit_prime++;}
513					temp_3_digit_prime *= 10;
514					temp_3_digit_prime += Authorship_private[read_bookmark + 1];
515					temp_3_digit_prime *= 10;
516					temp_3_digit_prime += Authorship_private[read_bookmark + 2];
517					
518					while(sieve[temp_3_digit_prime] == 1) //Adjusts temp_3_digit_prime for primality (tests current value & searches in pos dir.)
519					{	if(temp_3_digit_prime > 999) {temp_3_digit_prime = 997; break;} //If exceeds length of 3, sets it to largest 3-digit prime.
520						temp_3_digit_prime++;
521					}
522					
523					sub_plaintext_SUB4[write_bookmark_SUB4 + 2] = (temp_3_digit_prime % 10); //Writes prime to sub_plaintext_SUB4[].
524					temp_3_digit_prime /= 10;
525					sub_plaintext_SUB4[write_bookmark_SUB4 + 1] = (temp_3_digit_prime % 10);
526					temp_3_digit_prime /= 10;
527					sub_plaintext_SUB4[write_bookmark_SUB4] = temp_3_digit_prime;
528					
529					write_bookmark_SUB4 += 3;
530					read_bookmark += 3;
531					continue;
532				}
533				
534				if(prime_lengths_in_order_SUB4[a] == 4) //Randomly generates a four-digit prime.
535				{	int temp_4_digit_prime;
536					temp_4_digit_prime = Authorship_private[read_bookmark]; //Unloads 4 array elements to make one integer.
537					if(temp_4_digit_prime == 0) {temp_4_digit_prime++;}
538					temp_4_digit_prime *= 10;
539					temp_4_digit_prime += Authorship_private[read_bookmark + 1];
540					temp_4_digit_prime *= 10;
541					temp_4_digit_prime += Authorship_private[read_bookmark + 2];
542					temp_4_digit_prime *= 10;
543					temp_4_digit_prime += Authorship_private[read_bookmark + 3];
544					
545					while(sieve[temp_4_digit_prime] == 1) //Adjusts temp_4_digit_prime for primality (tests current value & searches in pos dir.)
546					{	if(temp_4_digit_prime > 9999) {temp_4_digit_prime = 9973; break;} //If exceeds length of 4, sets it to largest 4-digit prime.
547						temp_4_digit_prime++;
548					}
549					
550					sub_plaintext_SUB4[write_bookmark_SUB4 + 3] = (temp_4_digit_prime % 10); //Writes prime to sub_plaintext_SUB4[].
551					temp_4_digit_prime /= 10;
552					sub_plaintext_SUB4[write_bookmark_SUB4 + 2] = (temp_4_digit_prime % 10);
553					temp_4_digit_prime /= 10;
554					sub_plaintext_SUB4[write_bookmark_SUB4 + 1] = (temp_4_digit_prime % 10);
555					temp_4_digit_prime /= 10;
556					sub_plaintext_SUB4[write_bookmark_SUB4] = temp_4_digit_prime;
557					
558					write_bookmark_SUB4 += 4;
559					read_bookmark += 4;
560					continue;
561				}
562				
563				if(prime_lengths_in_order_SUB4[a] == 5) //Randomly generates a five-digit prime.
564				{	int temp_5_digit_prime;
565					temp_5_digit_prime = Authorship_private[read_bookmark]; //Unloads 5 array elements to make one integer.
566					if(temp_5_digit_prime == 0) {temp_5_digit_prime++;}
567					temp_5_digit_prime *= 10;
568					temp_5_digit_prime += Authorship_private[read_bookmark + 1];
569					temp_5_digit_prime *= 10;
570					temp_5_digit_prime += Authorship_private[read_bookmark + 2];
571					temp_5_digit_prime *= 10;
572					temp_5_digit_prime += Authorship_private[read_bookmark + 3];
573					temp_5_digit_prime *= 10;
574					temp_5_digit_prime += Authorship_private[read_bookmark + 4];
575					
576					while(sieve[temp_5_digit_prime] == 1) //Adjusts temp_5_digit_prime for primality (tests current value & searches in pos dir.)
577					{	if(temp_5_digit_prime > 99999) {temp_5_digit_prime = 99991; break;} //If exceeds length of 5, sets it to largest 5-digit prime.
578						temp_5_digit_prime++;
579					}
580					
581					sub_plaintext_SUB4[write_bookmark_SUB4 + 4] = (temp_5_digit_prime % 10); //Writes prime to sub_plaintext_SUB4[].
582					temp_5_digit_prime /= 10;
583					sub_plaintext_SUB4[write_bookmark_SUB4 + 3] = (temp_5_digit_prime % 10);
584					temp_5_digit_prime /= 10;
585					sub_plaintext_SUB4[write_bookmark_SUB4 + 2] = (temp_5_digit_prime % 10);
586					temp_5_digit_prime /= 10;
587					sub_plaintext_SUB4[write_bookmark_SUB4 + 1] = (temp_5_digit_prime % 10);
588					temp_5_digit_prime /= 10;
589					sub_plaintext_SUB4[write_bookmark_SUB4] = temp_5_digit_prime;
590					
591					write_bookmark_SUB4 += 5;
592					read_bookmark += 5;
593					continue;
594				}
595			}
596			
597			for(int a = 0; a < 2000; a++) //Generates fourth sub-ciphertext of current function and writes it to Authorship_private[].
598			{	Authorship_private[write_bookmark] = sub_key[a];
599				Authorship_private[write_bookmark] += sub_plaintext_SUB4[a];
600				Authorship_private[write_bookmark] %= 10;
601				write_bookmark++;
602			}
603			
604			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
605			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
606			
607			for(int a = 0; a < 1996; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 5.)
608			{	sub_key[a] += transformation_determinant[a];
609				sub_key[a] = ((sub_key[a] + transformation_determinant[a + 4]) % 10); //[a + 4] means do up to 1995 or seg fault.
610			}
611			sub_key[1996] = ((sub_key[1996] + transformation_determinant[1030]) % 10); //Last four elements were not transformed so here it is.
612			sub_key[1997] = ((sub_key[1997] + transformation_determinant[1035]) % 10);
613			sub_key[1998] = ((sub_key[1998] + transformation_determinant[1040]) % 10);
614			sub_key[1999] = ((sub_key[1999] + transformation_determinant[1045]) % 10);
615			//(4th of 5 total transformations per function.) Each one is different.
616			
617			
618			
619			
620			
621			//The following block-bunch generates sub-function 5 for the current function. (Cool zone.)
622			for(int a = 0; a < 2000; a++) //Generates fifth sub-ciphertext of current function and writes it to Authorship_private[].
623			{	Authorship_private[write_bookmark] = sub_key[a];
624				Authorship_private[write_bookmark] += Authorship_private[read_bookmark];
625				Authorship_private[write_bookmark] %= 10;
626				read_bookmark++;
627				write_bookmark++;
628			}
629			
630			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
631			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
632			
633			for(int a = 0; a < 1995; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 6.)
634			{	sub_key[a] += transformation_determinant[a];
635				sub_key[a] = ((sub_key[a] + transformation_determinant[a + 5]) % 10); //[a + 5] means do up to 1994 or seg fault.
636			}
637			sub_key[1995] = ((sub_key[1995] + transformation_determinant[1050]) % 10); //Last five elements were not transformed so here it is.
638			sub_key[1996] = ((sub_key[1996] + transformation_determinant[1055]) % 10);
639			sub_key[1997] = ((sub_key[1997] + transformation_determinant[1060]) % 10);
640			sub_key[1998] = ((sub_key[1998] + transformation_determinant[1065]) % 10);
641			sub_key[1999] = ((sub_key[1999] + transformation_determinant[1070]) % 10);
642			//(5th of 5 total transformations per function.) Each one is different.
643			
644			
645			
646			
647			
648			//The following block-bunch generates sub-function 6 for the current function. (Hot zone.)
649			int sub_plaintext_SUB6[2000];
650			int prime_lengths_in_order_SUB6[1000]; //Expected contiguous primes: ~667.
651			
652			int length_sum_SUB6 = 0;
653			int element_SUB6 = 0; //Begins writing to prime_lengths_in_order_SUB6[] from element 0 (basic counter.)
654			while(length_sum_SUB6 < 2000)
655			{	if(Authorship_private[read_bookmark] < 5) {	Authorship_private[read_bookmark]++;} //Reassignes (0=1,1=2,2=3,3=4,4=5.)
656				else //Assignes 5 to: 1, 6 to: 2, 7 to: 3, 8 to: 4, and 9 to: 5. (All prime lengths must be 1-5.)
657				{	Authorship_private[read_bookmark] += 16;
658					Authorship_private[read_bookmark] %= 10; //Example: 7: (7+16) = 23, 23 mod 10 = 3. Seven is now 3.
659				}
660				
661				length_sum_SUB6 += Authorship_private[read_bookmark];
662				prime_lengths_in_order_SUB6[element_SUB6] = Authorship_private[read_bookmark]; //Prime lengths are recorded in
663				element_SUB6++; //prime_lengths_in_order_SUB6[] so as to later append it near the current ciphertext when complete.
664				read_bookmark++; //    ...(Written to Authorship_private[].)
665			}
666			
667			element_SUB6--;
668			if(length_sum_SUB6 > 2000) //Subtracts from last entry in prime_lengths_in_order_SUB6[] so as to ensure sum(entries) = 2,000.
669			{	int overflow = (length_sum_SUB6 % 10);
670				prime_lengths_in_order_SUB6[element_SUB6] -= overflow;
671			}
672			
673			int write_bookmark_SUB6 = 0;
674			for(int a = 0; a <= element_SUB6; a++) //Genetates primes of corresponding length & writes them to sub_plaintext_SUB6[].
675			{	if(prime_lengths_in_order_SUB6[a] == 1) //Randomly generates a single-digit prime.
676				{	if(Authorship_private[read_bookmark] < 5)
677					{	if(Authorship_private[read_bookmark + 1] < 5) {sub_plaintext_SUB6[write_bookmark_SUB6] = 2;} //The prime 2.
678						else {sub_plaintext_SUB6[write_bookmark_SUB6] = 3;} //The prime 3.
679					}
680					
681					else
682					{	if(Authorship_private[read_bookmark + 1] < 5) {sub_plaintext_SUB6[write_bookmark_SUB6] = 5;} //The prime 5.
683						else {sub_plaintext_SUB6[write_bookmark_SUB6] = 7;} //The prime 7.
684					}
685					
686					write_bookmark_SUB6++;
687					read_bookmark += 2;
688					continue;
689				}
690				
691				if(prime_lengths_in_order_SUB6[a] == 2) //Randomly generates a two-digit prime.
692				{	int temp_2_digit_prime;
693					temp_2_digit_prime = Authorship_private[read_bookmark]; //Unloads 2 array elements to make one integer.
694					if(temp_2_digit_prime == 0) {temp_2_digit_prime++;}
695					temp_2_digit_prime *= 10;
696					temp_2_digit_prime += Authorship_private[read_bookmark + 1];
697					
698					while(sieve[temp_2_digit_prime] == 1) //Adjusts temp_2_digit_prime for primality (tests current value & searches in pos dir.)
699					{	if(temp_2_digit_prime > 99) {temp_2_digit_prime = 97; break;} //If exceeds length of 2, sets it to largest 2-digit prime.
700						temp_2_digit_prime++;
701					}
702					
703					sub_plaintext_SUB6[write_bookmark_SUB6 + 1] = (temp_2_digit_prime % 10); //Writes prime to sub_plaintext_SUB6[].
704					temp_2_digit_prime /= 10;
705					sub_plaintext_SUB6[write_bookmark_SUB6] = temp_2_digit_prime;
706					
707					write_bookmark_SUB6 += 2;
708					read_bookmark += 2;
709					continue;
710				}
711				
712				if(prime_lengths_in_order_SUB6[a] == 3) //Randomly generates a three-digit prime.
713				{	int temp_3_digit_prime;
714					temp_3_digit_prime = Authorship_private[read_bookmark]; //Unloads 3 array elements to make one integer.
715					if(temp_3_digit_prime == 0) {temp_3_digit_prime++;}
716					temp_3_digit_prime *= 10;
717					temp_3_digit_prime += Authorship_private[read_bookmark + 1];
718					temp_3_digit_prime *= 10;
719					temp_3_digit_prime += Authorship_private[read_bookmark + 2];
720					
721					while(sieve[temp_3_digit_prime] == 1) //Adjusts temp_3_digit_prime for primality (tests current value & searches in pos dir.)
722					{	if(temp_3_digit_prime > 999) {temp_3_digit_prime = 997; break;} //If exceeds length of 3, sets it to largest 3-digit prime.
723						temp_3_digit_prime++;
724					}
725					
726					sub_plaintext_SUB6[write_bookmark_SUB6 + 2] = (temp_3_digit_prime % 10); //Writes prime to sub_plaintext_SUB6[].
727					temp_3_digit_prime /= 10;
728					sub_plaintext_SUB6[write_bookmark_SUB6 + 1] = (temp_3_digit_prime % 10);
729					temp_3_digit_prime /= 10;
730					sub_plaintext_SUB6[write_bookmark_SUB6] = temp_3_digit_prime;
731					
732					write_bookmark_SUB6 += 3;
733					read_bookmark += 3;
734					continue;
735				}
736				
737				if(prime_lengths_in_order_SUB6[a] == 4) //Randomly generates a four-digit prime.
738				{	int temp_4_digit_prime;
739					temp_4_digit_prime = Authorship_private[read_bookmark]; //Unloads 4 array elements to make one integer.
740					if(temp_4_digit_prime == 0) {temp_4_digit_prime++;}
741					temp_4_digit_prime *= 10;
742					temp_4_digit_prime += Authorship_private[read_bookmark + 1];
743					temp_4_digit_prime *= 10;
744					temp_4_digit_prime += Authorship_private[read_bookmark + 2];
745					temp_4_digit_prime *= 10;
746					temp_4_digit_prime += Authorship_private[read_bookmark + 3];
747					
748					while(sieve[temp_4_digit_prime] == 1) //Adjusts temp_4_digit_prime for primality (tests current value & searches in pos dir.)
749					{	if(temp_4_digit_prime > 9999) {temp_4_digit_prime = 9973; break;} //If exceeds length of 4, sets it to largest 4-digit prime.
750						temp_4_digit_prime++;
751					}
752					
753					sub_plaintext_SUB6[write_bookmark_SUB6 + 3] = (temp_4_digit_prime % 10); //Writes prime to sub_plaintext_SUB6[].
754					temp_4_digit_prime /= 10;
755					sub_plaintext_SUB6[write_bookmark_SUB6 + 2] = (temp_4_digit_prime % 10);
756					temp_4_digit_prime /= 10;
757					sub_plaintext_SUB6[write_bookmark_SUB6 + 1] = (temp_4_digit_prime % 10);
758					temp_4_digit_prime /= 10;
759					sub_plaintext_SUB6[write_bookmark_SUB6] = temp_4_digit_prime;
760					
761					write_bookmark_SUB6 += 4;
762					read_bookmark += 4;
763					continue;
764				}
765				
766				if(prime_lengths_in_order_SUB6[a] == 5) //Randomly generates a five-digit prime.
767				{	int temp_5_digit_prime;
768					temp_5_digit_prime = Authorship_private[read_bookmark]; //Unloads 5 array elements to make one integer.
769					if(temp_5_digit_prime == 0) {temp_5_digit_prime++;}
770					temp_5_digit_prime *= 10;
771					temp_5_digit_prime += Authorship_private[read_bookmark + 1];
772					temp_5_digit_prime *= 10;
773					temp_5_digit_prime += Authorship_private[read_bookmark + 2];
774					temp_5_digit_prime *= 10;
775					temp_5_digit_prime += Authorship_private[read_bookmark + 3];
776					temp_5_digit_prime *= 10;
777					temp_5_digit_prime += Authorship_private[read_bookmark + 4];
778					
779					while(sieve[temp_5_digit_prime] == 1) //Adjusts temp_5_digit_prime for primality (tests current value & searches in pos dir.)
780					{	if(temp_5_digit_prime > 99999) {temp_5_digit_prime = 99991; break;} //If exceeds length of 5, sets it to largest 5-digit prime.
781						temp_5_digit_prime++;
782					}
783					
784					sub_plaintext_SUB6[write_bookmark_SUB6 + 4] = (temp_5_digit_prime % 10); //Writes prime to sub_plaintext_SUB6[].
785					temp_5_digit_prime /= 10;
786					sub_plaintext_SUB6[write_bookmark_SUB6 + 3] = (temp_5_digit_prime % 10);
787					temp_5_digit_prime /= 10;
788					sub_plaintext_SUB6[write_bookmark_SUB6 + 2] = (temp_5_digit_prime % 10);
789					temp_5_digit_prime /= 10;
790					sub_plaintext_SUB6[write_bookmark_SUB6 + 1] = (temp_5_digit_prime % 10);
791					temp_5_digit_prime /= 10;
792					sub_plaintext_SUB6[write_bookmark_SUB6] = temp_5_digit_prime;
793					
794					write_bookmark_SUB6 += 5;
795					read_bookmark += 5;
796					continue;
797				}
798			}
799			
800			for(int a = 0; a < 2000; a++) //Generates sixth sub-ciphertext of current function and writes it to Authorship_private[].
801			{	Authorship_private[write_bookmark] = sub_key[a];
802				Authorship_private[write_bookmark] += sub_plaintext_SUB6[a];
803				Authorship_private[write_bookmark] %= 10;
804				write_bookmark++;
805			}
806			
807			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
808			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
809			
810			
811			
812			
813			
814			//The following block-bunch generates the Authorship number dynamically. (Its final form is then produced after the 13,500 functions.)
815			//This sits here (just after the full function is written to array Authorship_private[]) because now temp_write_bookmark fingerprints the
816			//function right to left so as to build the Authorship number. Then solution ingredients are appended to the current function.
817			compression_119[0] += compression_119[99];
818			compression_119[0] %= 10000000000;
819			
820			int temp_write_bookmark;
821			temp_write_bookmark = (write_bookmark - 2);
822			
823			for(int a = 0; a < 100; a++)
824			{	compression_115[a] += Authorship_private[temp_write_bookmark];
825				compression_115[a] *= 5;
826				compression_115[a] %= 10000000000;
827				temp_write_bookmark -= 115;
828			}
829			temp_write_bookmark = (write_bookmark - 2); //Resetting the temporary variable.
830			
831			for(int a = 0; a < 100; a++)
832			{	compression_116[a] += Authorship_private[temp_write_bookmark];
833				compression_116[a] *= 6;
834				compression_116[a] %= 10000000000;
835				temp_write_bookmark -= 116;
836			}
837			temp_write_bookmark = (write_bookmark - 2); //Resetting the temporary variable.
838			
839			for(int a = 0; a < 100; a++)
840			{	compression_117[a] += Authorship_private[temp_write_bookmark];
841				compression_117[a] *= 7;
842				compression_117[a] %= 10000000000;
843				temp_write_bookmark -= 117;
844			}
845			temp_write_bookmark = (write_bookmark - 2); //Resetting the temporary variable.
846			
847			for(int a = 0; a < 100; a++)
848			{	compression_118[a] += Authorship_private[temp_write_bookmark];
849				compression_118[a] *= 8;
850				compression_118[a] %= 10000000000;
851				temp_write_bookmark -= 118;
852			}
853			temp_write_bookmark = (write_bookmark - 2); //Resetting the temporary variable.
854			
855			for(int a = 0; a < 100; a++)
856			{	compression_119[a] += Authorship_private[temp_write_bookmark];
857				compression_119[a] *= 9;
858				compression_119[a] %= 10000000000;
859				temp_write_bookmark -= 119;
860			}
861			
862			//Compression snapshots are active in early stages of Authorship number evolution. They are applied to the compression in the end.
863			if((f == 1000) || (f == 2000) || (f == 3000) || (f == 4000) || (f == 5000) || (f == 6000) || (f == 7000) || (f == 8000))
864			{	for(int a = 0; a < 100; a++)
865				{	snapshot_115[a] += compression_115[a];
866					snapshot_115[a] %= 10000000000; //(10^10, results in last ten digits shown.)
867					
868					snapshot_116[a] += compression_116[a];
869					snapshot_116[a] %= 10000000000;
870					
871					snapshot_117[a] += compression_117[a];
872					snapshot_117[a] %= 10000000000;
873					
874					snapshot_118[a] += compression_118[a];
875					snapshot_118[a] %= 10000000000;
876					
877					snapshot_119[a] += compression_119[a];
878					snapshot_119[a] %= 10000000000;
879				}
880			}
881			
882			
883			
884			
885			
886			//The following block-bunch appends to the current function in Authorship_private[]: solution ingredients.
887			for(int a = 0; a < 2000; a++) //Writes the transformation determinant.
888			{	Authorship_private[write_bookmark] = transformation_determinant[a];
889				write_bookmark++;
890			}
891			
892			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
893			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
894			
895			for(int a = 0; a < 2000; a++) //Writes the sub-key.
896			{	Authorship_private[write_bookmark] = temp_sub_key[a];
897				write_bookmark++;
898			}
899			
900			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
901			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
902			
903			for(int a = 0; a <= element_SUB2; a++) //Writes the prime_lengths_in_order_SUB2 (hot zone.)
904			{	Authorship_private[write_bookmark] = prime_lengths_in_order_SUB2[a];
905				write_bookmark++;
906			}
907			
908			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
909			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
910			
911			for(int a = 0; a <= element_SUB4; a++) //Writes the prime_lengths_in_order_SUB4 (hot zone.)
912			{	Authorship_private[write_bookmark] = prime_lengths_in_order_SUB4[a];
913				write_bookmark++;
914			}
915			
916			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
917			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
918			
919			for(int a = 0; a <= element_SUB6; a++) //Writes the prime_lengths_in_order_SUB6 (hot zone.)
920			{	Authorship_private[write_bookmark] = prime_lengths_in_order_SUB6[a];
921				write_bookmark++;
922			}
923			
924			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
925			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
926			
927			if((read_bookmark - write_bookmark) < 30000) //Further collision prevention for read/write bookmarks. After each cycle within this
928			{	read_bookmark += 1000000; //for loop, read_bookmark increases by ~16,000 while write_bookmark increases by ~18,000 and so the
929			}                             //write_bookmark evenually catches up. This block forces read_bookmark to jump dynamically.
930		                                  //Consider instead making tiny jumps away from write_bookmark--adjusting only by ~2,000 elements forward.
931		                                  //That would be okay because you're just following along with write_bookmark and Authorship_private[]
932		                                  //fits them all just fine. Now consider jumping only once in a while--distancing in bulk. This is no more
933		                                  //a waste of random numbers than making small jumps. The bookmarks simply and smoothly approach
934		                                  //one another over time. All that space between them must exist one way or another--in bulk or in parts.
935		}
936		
937		
938		
939		
940		
941		//Writes everything to the file Authorship.private including the last dot then the null character.
942		ofstream out_stream;
943		out_stream.open("Authorship.private");
944		
945		for(int a = 0; a < write_bookmark; a++)
946		{	if(Authorship_private[a] == '.') {out_stream << '.';}
947			else {out_stream << int(Authorship_private[a]);}
948		}
949		out_stream << '\0'; //These digits will be loaded into RAM one day, null marks when to stop reading them.
950		
951		out_stream.close();
952		
953		
954		
955		
956		
957		//Constructively combines the comression tables. compression_119[] will hold it all.
958		for(int a = 0; a < 100; a++)
959		{	compression_119[a] += compression_115[a];
960			if((compression_119[a] % 2) == 0) {compression_119[a] *= 2;}
961			
962			compression_119[a] += compression_116[a];
963			if((compression_119[a] % 2) == 0) {compression_119[a] *= 3;}
964			
965			compression_119[a] += compression_117[a];
966			if((compression_119[a] % 2) == 0) {compression_119[a] *= 5;}
967			
968			compression_119[a] += compression_118[a];
969			if((compression_119[a] % 2) == 0) {compression_119[a] *= 7;}
970			
971			compression_119[a] %= 10000000000; //(10^10, results in last ten digits shown.)
972		}
973		
974		//Constructively combines the snapshot tables. snapshot_119[] will hold it all.
975		for(int a = 0; a < 100; a++)
976		{	snapshot_119[a] += snapshot_115[a];
977			if((snapshot_119[a] % 2) == 0) {snapshot_119[a] *= 2;}
978			
979			snapshot_119[a] += snapshot_116[a];
980			if((snapshot_119[a] % 2) == 0) {snapshot_119[a] *= 3;}
981			
982			snapshot_119[a] += snapshot_117[a];
983			if((snapshot_119[a] % 2) == 0) {snapshot_119[a] *= 5;}
984			
985			snapshot_119[a] += snapshot_118[a];
986			if((snapshot_119[a] % 2) == 0) {snapshot_119[a] *= 7;}
987			
988			snapshot_119[a] %= 10000000000; //(10^10, results in last ten digits shown.)
989		}
990		
991		//Applies the snapshots to the last stage in compression. (As the Authorship number evolved over time, snapshots made a record of its early stages.)
992		for(int a = 0; a < 100; a++)
993		{	compression_119[a] += snapshot_119[a];
994			compression_119[a] %= 10000000000; //(10^10, results in last ten digits shown.)
995		}
996		
997		for(int a = 0; a < 100; a++) //Ensures each constituent compression integer is 10 digits long. The Authorship number is now complete.
998		{	if(compression_119[a] < 1000000000)
999			{	compression_119[a] += 1000000000;
1000			}
1001		}
1002		
1003		
1004		
1005		
1006		
1007		//Writes number to the file Authorship.number.
1008		out_stream.open("Authorship.number");
1009		
1010		for(int a = 0; a < 100; a++)
1011		{	out_stream << compression_119[a];
1012		}
1013		
1014		out_stream.close();
1015		
1016		
1017		
1018		
1019		
1020		//Overwrites RAM of Authorship_private[].
1021		for(int a = 0; a < 256500000; a++)
1022		{	Authorship_private[a] = 9;
1023			Authorship_private[a] = 8;
1024			Authorship_private[a] = 7;
1025			Authorship_private[a] = 6;
1026			Authorship_private[a] = 5;
1027			Authorship_private[a] = 4;
1028			Authorship_private[a] = 3;
1029			Authorship_private[a] = 2;
1030			Authorship_private[a] = 1;
1031			Authorship_private[a] = 0;
1032		}
1033		
1034		
1035		
1036		
1037		
1038		cout << "\n\n\nFinished.\n\n\n";
1039		
1040		cout << "Your number resides in the file Authorship.number in this directory, publish it!\n";
1041		cout << "Your keys reside in Authorship.private in this directory, cache them guardedly.\n\n\n\n";
1042	}
1043	
1044	
1045	
1046	
1047	
1048	//________________________________________________________________________________________________________________________
1049	//                                                                                                                       |
1050	//                                          2   Modify Authorship number                                                 |
1051	//_______________________________________________________________________________________________________________________|
1052	if(user_option == 2)
1053	{	//BASIC LAYOUT:
1054		//1. Generates your new number & keys (same as Authorship option 1.)
1055		//2. Loads given old Authorship.private file into old[].
1056		//3. Overwrites given Authorship.private flie with new keys from step 1.
1057		//4. Forces old[] to represent your new number & message.
1058		//5. Writes old[] to now-created file Authorship.public.
1059		
1060		cout << "\n>>>>>>>>>>>>>>>>>>>>>>>>>>>(Modify Authorship number)<<<<<<<<<<<<<<<<<<<<<<<<<<<\n";
1061		cout << "Place a COPY your Authorship.private file in this directory if not already here.\n";
1062		cout << "Enter a message (1,000 characters max, will be truncated) otherwise press enter:\n\n";
1063		///If you are having trouble with ^^^^^^^^^^ inserting your message, remove the following two
1064		///lines marked with @@@@@@ symbols. Systems other than GNU+Linux may automatically flush keyboard input
1065		///and the new line character produced by any previous out streams or the enter key will invade getline().
1066		
1067		//These two lines must exist unfortunately. nothing_to_see_here[] will catch the \n or whatever it is causing issues
1068		//(these issues are all throughout C++.) The previous cout streams something. The ending of that something would have
1069		//made its way into the next "message[10000]" and "cin.getline(message, 10000);" would be skipped completely.
1070		//And so "nothing_to_see_here[]" is placed before the next getline so as to catch the uncontrollable stream.
1071		char nothing_to_see_here[1]; ///@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
1072		cin.getline(nothing_to_see_here, 1); ///@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
1073		
1074		char message[10000]; //This is TEN thousand incase the user enters too many. Too many characters interferes
1075		//with the next in-stream for user_seed (down a few lines.) (10,000 - 1) is enough room for error and strange
1076		//inputs. The user seed in-stream is cut out completely in fact, if user message overflows for size message[1001].
1077		cin.getline(message, 10000); //If enter is pressed, ALL message[] elements are auto-set to null. If a message
1078		//is entered on the other hand, ALL REMAINING message[] elements are auto-set to null. Overflow beyond 1000
1079		//characters is automatically not allowed by C++ as set by the argument of getline(). Later in the program:
1080		//if message[0] is null, no message exists. Otherwise, message[] is read from--until the first null.
1081		message[1000] = '\0'; //Now to safely truncate the message length to its max (1,001st element is set to null.)
1082		
1083		cout << "\nRandom number generator takes 5 minutes. Enter 8 random digits, repeat 50 times.\n\n";
1084		
1085		unsigned int user_seed[50]; //Fills user_seed with 50 user-defined seeds of size 8.
1086		for(int a = 0; a < 50; a++)
1087		{	if(a < 9) {cout << " " << (a + 1) << " of 50: ";} //Prints blank to align input status report (aesthetics.)
1088			else {cout << (a + 1) << " of 50: ";}
1089			
1090			cin >> user_seed[a];
1091		} //CAUTION: "cin" must exist last, just before the rest of the computation-heavy program begins,
1092		//otherwise some things may not be printed and INPUT STREAMS CAN BE SKIPPED such as cin.getline().
1093		//For example, you can ask the user if they want to enter some message: if(message_decision == 'y')
1094		//then in-stream the message as well as print something... all of this would be skipped if not
1095		//layed out the way it is currently (at least for some machines and compilers.)
1096		
1097		
1098		
1099		
1100		
1101		static char Authorship_private[256500000]; //This array is filled with random digits then read from and written to left to right
1102		//dynamically to save RAM space. It provides random digit input and temporary key storage (to be written to file: Authorship.private.)
1103		int read_bookmark = 1000000;  //Bookmarks where to read next from Authorship_private[]. Initial size prevents read/write collision.
1104		int write_bookmark = 0; //Bookmarks where to write next in  Authorship_private[].
1105		//(Function generation extracts random numbers using read/write bookmarks. Authorship_private[] is first filled with random numbers normally.)
1106		
1107		for(int a = 0; a < 50; a++) //Generates a random location (+10^6) for where to read from Authorship_private[]. This step prevents bookmark
1108		{	read_bookmark += (user_seed[a] % 10000); //collision and adds to the randomness strength. Average total value for read_bookmark: 1,250,000.
1109		} //The last item in the for loop who generates 13,500 multi-way functions deals with collision again, allowing bookmark proximity of ~30,000.
1110		
1111		srand(time(0));
1112		for(int a = 256499999; a >= 0; a--) //Fills Authorship_private[] with random numbers based on Unix time. WRITES RIGHT TO LEFT.
1113		{	Authorship_private[a] = (rand() % 10);
1114		}
1115		
1116		for(int a = 0; a < 50; a++) //Constructively applies random digits to Authorship_private[] based on the 50 seeds provided by the user.
1117		{	srand(user_seed[a]);    //WRITES ALTERNATING BETWEEN LEFT TO RIGHT & RIGHT TO LEFT. Alternation is based on the 50 user seeds.
1118			
1119			if((user_seed[a] % 2) == 0)
1120			{	for(int b = 0; b < 256500000; b++) //If current user seed is even, WRITES RANDOM NUMBERS LEFT TO RIGHT.
1121				{	Authorship_private[b] = (Authorship_private[b] + (rand() % 10));
1122					Authorship_private[b] %= 10;
1123				}
1124			}
1125			else
1126			{	for(int b = 256499999; b >= 0; b--) //If current user seed is odd, WRITES RANDOM NUMBERS RIGHT TO LEFT.
1127				{	Authorship_private[b] = (Authorship_private[b] + (rand() % 10));
1128					Authorship_private[b] %= 10;
1129				}
1130			}
1131		}
1132		
1133		srand(time(0)); //Constructively applies random numbers to Authorship_private[] once more, based on Unix time. WRITES LEFT TO RIGHT.
1134		for(int a = 0; a < 256500000; a++)
1135		{	Authorship_private[a] = (Authorship_private[a] + (rand() % 10));
1136			Authorship_private[a] %= 10;
1137		}
1138		
1139		
1140		
1141		
1142		
1143		//These declarations are for deductive lossy compression, they produce the Authorship number dynamically.
1144		//See the compression block-bunch near the end of the following for loop who generates 13,500 functions.
1145		long long int compression_115[100]; //Hops by -115
1146		long long int snapshot_115[100]; //Takes a snapshot of compression_115[] every once in a while.
1147		
1148		long long int compression_116[100]; //Hops by -116
1149		long long int snapshot_116[100]; //Takes a snapshot of compression_116[] every once in a while.
1150		
1151		long long int compression_117[100]; //Hops by -117
1152		long long int snapshot_117[100]; //Takes a snapshot of compression_117[] every once in a while.
1153		
1154		long long int compression_118[100]; //Hops by -118
1155		long long int snapshot_118[100]; //Takes a snapshot of compression_118[] every once in a while.
1156		
1157		long long int compression_119[100]; //Hops by -119
1158		long long int snapshot_119[100]; //Takes a snapshot of compression_119[] every once in a while.
1159		
1160		for(int a = 0; a < 100; a++)
1161		{	compression_115[a] = 5555555555;
1162			snapshot_115[a] = 5555555555;
1163			
1164			compression_116[a] = 5555555555;
1165			snapshot_116[a] = 5555555555;
1166			
1167			compression_117[a] = 5555555555;
1168			snapshot_117[a] = 5555555555;
1169			
1170			compression_118[a] = 5555555555;
1171			snapshot_118[a] = 5555555555;
1172			
1173			compression_119[a] = 5555555555;
1174			snapshot_119[a] = 5555555555;
1175		}
1176		
1177		//This is a boolean sieve of Eratosthenes. Zeros are prime, conveniently mapped to their element index. (It is used here like the following
1178		//example: if(sieve[my_candidate] == 0) then my_candidate is prime. Otherwise, my_candidate is increased until it is prime. This adjusts
1179		//my_candidate for primality in the positive direction.) And values over 99 for 2-digit primes for example are set to the largest prime < 100.)
1180		bool sieve[100000] = {1, 1};
1181		for(int prime = 2; prime < 317; prime++) //317 is sqrt(100000)
1182		{	for(int a = prime + prime; a < 100000; a += prime) {sieve[a] = 1;}
1183		}
1184		
1185		
1186		
1187		
1188		
1189		//The following for loop generates 13,500 multi-way functions in array Authorship_private[].
1190		for(int f = 0; f < 13500; f++)
1191		{	//The following block-bunch generates sub-function 1 for the current function. (Cool zone.)
1192			int transformation_determinant[2000];
1193			for(int a = 0; a < 2000; a++) //Fills transformation_determinant[] with random digits.
1194			{	transformation_determinant[a] = Authorship_private[read_bookmark];
1195				read_bookmark++;
1196			}
1197			
1198			int sub_key[2000];
1199			int temp_sub_key[2000];
1200			for(int a = 0; a < 2000; a++) //Fills sub_key[] with random digits. This sub-key will be transformed and used dynamically.
1201			{	sub_key[a] = Authorship_private[read_bookmark];
1202				temp_sub_key[a] = Authorship_private[read_bookmark]; //Makes temp copy of sub-key so as to later append it near the current
1203				read_bookmark++;                                     //ciphertext when complete. (Written to Authorship_private[].)
1204			}                                                        //These kind of details prevent read/write_bookmark collision.
1205			
1206			for(int a = 0; a < 2000; a++) //Generates first sub-ciphertext of current function and writes it to Authorship_private[].
1207			{	Authorship_private[write_bookmark] = sub_key[a];
1208				Authorship_private[write_bookmark] += Authorship_private[read_bookmark];
1209				Authorship_private[write_bookmark] %= 10;
1210				read_bookmark++;
1211				write_bookmark++;
1212			}
1213			
1214			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
1215			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
1216			
1217			for(int a = 0; a < 1999; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 2.)
1218			{	sub_key[a] += transformation_determinant[a];
1219				sub_key[a] = ((sub_key[a] + transformation_determinant[a + 1]) % 10); //[a + 1] means do up to 1998 or seg fault.
1220			}
1221			sub_key[1999] = ((sub_key[1999] + transformation_determinant[1000]) % 10); //Last element was not transformed so here it is.
1222			//(1st of 5 total transformations per function.) Each one is different.
1223			
1224			
1225			
1226			
1227			
1228			//The following block-bunch generates sub-function 2 for the current function. (Hot zone.)
1229			int sub_plaintext_SUB2[2000];
1230			int prime_lengths_in_order_SUB2[1000]; //Expected contiguous primes: ~667.
1231			
1232			int length_sum_SUB2 = 0;
1233			int element_SUB2 = 0; //Begins writing to prime_lengths_in_order_SUB2[] from element 0 (basic counter.)
1234			while(length_sum_SUB2 < 2000)
1235			{	if(Authorship_private[read_bookmark] < 5) {	Authorship_private[read_bookmark]++;} //Reassignes (0=1,1=2,2=3,3=4,4=5.)
1236				else //Assignes 5 to: 1, 6 to: 2, 7 to: 3, 8 to: 4, and 9 to: 5. (All prime lengths must be 1-5.)
1237				{	Authorship_private[read_bookmark] += 16;
1238					Authorship_private[read_bookmark] %= 10; //Example: 7: (7+16) = 23, 23 mod 10 = 3. Seven is now 3.
1239				}
1240				
1241				length_sum_SUB2 += Authorship_private[read_bookmark];
1242				prime_lengths_in_order_SUB2[element_SUB2] = Authorship_private[read_bookmark]; //Prime lengths are recorded in
1243				element_SUB2++; //prime_lengths_in_order_SUB2[] so as to later append it near the current ciphertext when complete.
1244				read_bookmark++; //    ...(Written to Authorship_private[].)
1245			}
1246			
1247			element_SUB2--;
1248			if(length_sum_SUB2 > 2000) //Subtracts from last entry in prime_lengths_in_order_SUB2[] so as to ensure sum(entries) = 2,000.
1249			{	int overflow = (length_sum_SUB2 % 10);
1250				prime_lengths_in_order_SUB2[element_SUB2] -= overflow;
1251			}
1252			
1253			int write_bookmark_SUB2 = 0;
1254			for(int a = 0; a <= element_SUB2; a++) //Genetates primes of corresponding length & writes them to sub_plaintext_SUB2[].
1255			{	if(prime_lengths_in_order_SUB2[a] == 1) //Randomly generates a single-digit prime.
1256				{	if(Authorship_private[read_bookmark] < 5)
1257					{	if(Authorship_private[read_bookmark + 1] < 5) {sub_plaintext_SUB2[write_bookmark_SUB2] = 2;} //The prime 2.
1258						else {sub_plaintext_SUB2[write_bookmark_SUB2] = 3;} //The prime 3.
1259					}
1260					
1261					else
1262					{	if(Authorship_private[read_bookmark + 1] < 5) {sub_plaintext_SUB2[write_bookmark_SUB2] = 5;} //The prime 5.
1263						else {sub_plaintext_SUB2[write_bookmark_SUB2] = 7;} //The prime 7.
1264					}
1265					
1266					write_bookmark_SUB2++;
1267					read_bookmark += 2;
1268					continue;
1269				}
1270				
1271				if(prime_lengths_in_order_SUB2[a] == 2) //Randomly generates a two-digit prime.
1272				{	int temp_2_digit_prime;
1273					temp_2_digit_prime = Authorship_private[read_bookmark]; //Unloads 2 array elements to make one integer.
1274					if(temp_2_digit_prime == 0) {temp_2_digit_prime++;}
1275					temp_2_digit_prime *= 10;
1276					temp_2_digit_prime += Authorship_private[read_bookmark + 1];
1277					
1278					while(sieve[temp_2_digit_prime] == 1) //Adjusts temp_2_digit_prime for primality (tests current value & searches in pos dir.)
1279					{	if(temp_2_digit_prime > 99) {temp_2_digit_prime = 97; break;} //If exceeds length of 2, sets it to largest 2-digit prime.
1280						temp_2_digit_prime++;
1281					}
1282					
1283					sub_plaintext_SUB2[write_bookmark_SUB2 + 1] = (temp_2_digit_prime % 10); //Writes prime to sub_plaintext_SUB2[].
1284					temp_2_digit_prime /= 10;
1285					sub_plaintext_SUB2[write_bookmark_SUB2] = temp_2_digit_prime;
1286					
1287					write_bookmark_SUB2 += 2;
1288					read_bookmark += 2;
1289					continue;
1290				}
1291				
1292				if(prime_lengths_in_order_SUB2[a] == 3) //Randomly generates a three-digit prime.
1293				{	int temp_3_digit_prime;
1294					temp_3_digit_prime = Authorship_private[read_bookmark]; //Unloads 3 array elements to make one integer.
1295					if(temp_3_digit_prime == 0) {temp_3_digit_prime++;}
1296					temp_3_digit_prime *= 10;
1297					temp_3_digit_prime += Authorship_private[read_bookmark + 1];
1298					temp_3_digit_prime *= 10;
1299					temp_3_digit_prime += Authorship_private[read_bookmark + 2];
1300					
1301					while(sieve[temp_3_digit_prime] == 1) //Adjusts temp_3_digit_prime for primality (tests current value & searches in pos dir.)
1302					{	if(temp_3_digit_prime > 999) {temp_3_digit_prime = 997; break;} //If exceeds length of 3, sets it to largest 3-digit prime.
1303						temp_3_digit_prime++;
1304					}
1305					
1306					sub_plaintext_SUB2[write_bookmark_SUB2 + 2] = (temp_3_digit_prime % 10); //Writes prime to sub_plaintext_SUB2[].
1307					temp_3_digit_prime /= 10;
1308					sub_plaintext_SUB2[write_bookmark_SUB2 + 1] = (temp_3_digit_prime % 10);
1309					temp_3_digit_prime /= 10;
1310					sub_plaintext_SUB2[write_bookmark_SUB2] = temp_3_digit_prime;
1311					
1312					write_bookmark_SUB2 += 3;
1313					read_bookmark += 3;
1314					continue;
1315				}
1316				
1317				if(prime_lengths_in_order_SUB2[a] == 4) //Randomly generates a four-digit prime.
1318				{	int temp_4_digit_prime;
1319					temp_4_digit_prime = Authorship_private[read_bookmark]; //Unloads 4 array elements to make one integer.
1320					if(temp_4_digit_prime == 0) {temp_4_digit_prime++;}
1321					temp_4_digit_prime *= 10;
1322					temp_4_digit_prime += Authorship_private[read_bookmark + 1];
1323					temp_4_digit_prime *= 10;
1324					temp_4_digit_prime += Authorship_private[read_bookmark + 2];
1325					temp_4_digit_prime *= 10;
1326					temp_4_digit_prime += Authorship_private[read_bookmark + 3];
1327					
1328					while(sieve[temp_4_digit_prime] == 1) //Adjusts temp_4_digit_prime for primality (tests current value & searches in pos dir.)
1329					{	if(temp_4_digit_prime > 9999) {temp_4_digit_prime = 9973; break;} //If exceeds length of 4, sets it to largest 4-digit prime.
1330						temp_4_digit_prime++;
1331					}
1332					
1333					sub_plaintext_SUB2[write_bookmark_SUB2 + 3] = (temp_4_digit_prime % 10); //Writes prime to sub_plaintext_SUB2[].
1334					temp_4_digit_prime /= 10;
1335					sub_plaintext_SUB2[write_bookmark_SUB2 + 2] = (temp_4_digit_prime % 10);
1336					temp_4_digit_prime /= 10;
1337					sub_plaintext_SUB2[write_bookmark_SUB2 + 1] = (temp_4_digit_prime % 10);
1338					temp_4_digit_prime /= 10;
1339					sub_plaintext_SUB2[write_bookmark_SUB2] = temp_4_digit_prime;
1340					
1341					write_bookmark_SUB2 += 4;
1342					read_bookmark += 4;
1343					continue;
1344				}
1345				
1346				if(prime_lengths_in_order_SUB2[a] == 5) //Randomly generates a five-digit prime.
1347				{	int temp_5_digit_prime;
1348					temp_5_digit_prime = Authorship_private[read_bookmark]; //Unloads 5 array elements to make one integer.
1349					if(temp_5_digit_prime == 0) {temp_5_digit_prime++;}
1350					temp_5_digit_prime *= 10;
1351					temp_5_digit_prime += Authorship_private[read_bookmark + 1];
1352					temp_5_digit_prime *= 10;
1353					temp_5_digit_prime += Authorship_private[read_bookmark + 2];
1354					temp_5_digit_prime *= 10;
1355					temp_5_digit_prime += Authorship_private[read_bookmark + 3];
1356					temp_5_digit_prime *= 10;
1357					temp_5_digit_prime += Authorship_private[read_bookmark + 4];
1358					
1359					while(sieve[temp_5_digit_prime] == 1) //Adjusts temp_5_digit_prime for primality (tests current value & searches in pos dir.)
1360					{	if(temp_5_digit_prime > 99999) {temp_5_digit_prime = 99991; break;} //If exceeds length of 5, sets it to largest 5-digit prime.
1361						temp_5_digit_prime++;
1362					}
1363					
1364					sub_plaintext_SUB2[write_bookmark_SUB2 + 4] = (temp_5_digit_prime % 10); //Writes prime to sub_plaintext_SUB2[].
1365					temp_5_digit_prime /= 10;
1366					sub_plaintext_SUB2[write_bookmark_SUB2 + 3] = (temp_5_digit_prime % 10);
1367					temp_5_digit_prime /= 10;
1368					sub_plaintext_SUB2[write_bookmark_SUB2 + 2] = (temp_5_digit_prime % 10);
1369					temp_5_digit_prime /= 10;
1370					sub_plaintext_SUB2[write_bookmark_SUB2 + 1] = (temp_5_digit_prime % 10);
1371					temp_5_digit_prime /= 10;
1372					sub_plaintext_SUB2[write_bookmark_SUB2] = temp_5_digit_prime;
1373					
1374					write_bookmark_SUB2 += 5;
1375					read_bookmark += 5;
1376					continue;
1377				}
1378			}
1379			
1380			for(int a = 0; a < 2000; a++) //Generates second sub-ciphertext of current function and writes it to Authorship_private[].
1381			{	Authorship_private[write_bookmark] = sub_key[a];
1382				Authorship_private[write_bookmark] += sub_plaintext_SUB2[a];
1383				Authorship_private[write_bookmark] %= 10;
1384				write_bookmark++;
1385			}
1386			
1387			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
1388			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
1389			
1390			for(int a = 0; a < 1998; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 3.)
1391			{	sub_key[a] += transformation_determinant[a];
1392				sub_key[a] = ((sub_key[a] + transformation_determinant[a + 2]) % 10); //[a + 2] means do up to 1997 or seg fault.
1393			}
1394			sub_key[1998] = ((sub_key[1998] + transformation_determinant[1005]) % 10); //Last two elements were not transformed so here it is.
1395			sub_key[1999] = ((sub_key[1999] + transformation_determinant[1010]) % 10);
1396			//(2nd of 5 total transformations per function.) Each one is different.
1397			
1398			
1399			
1400			
1401			
1402			//The following block-bunch generates sub-function 3 for the current function. (Cool zone.)
1403			for(int a = 0; a < 2000; a++) //Generates third sub-ciphertext of current function and writes it to Authorship_private[].
1404			{	Authorship_private[write_bookmark] = sub_key[a];
1405				Authorship_private[write_bookmark] += Authorship_private[read_bookmark];
1406				Authorship_private[write_bookmark] %= 10;
1407				read_bookmark++;
1408				write_bookmark++;
1409			}
1410			
1411			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
1412			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
1413			
1414			
1415			for(int a = 0; a < 1997; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 4.)
1416			{	sub_key[a] += transformation_determinant[a];
1417				sub_key[a] = ((sub_key[a] + transformation_determinant[a + 3]) % 10); //[a + 3] means do up to 1996 or seg fault.
1418			}
1419			sub_key[1997] = ((sub_key[1997] + transformation_determinant[1015]) % 10); //Last three elements were not transformed so here it is.
1420			sub_key[1998] = ((sub_key[1998] + transformation_determinant[1020]) % 10);
1421			sub_key[1999] = ((sub_key[1999] + transformation_determinant[1025]) % 10);
1422			//(3rd of 5 total transformations per function.) Each one is different.
1423			
1424			
1425			
1426			
1427			
1428			//The following block-bunch generates sub-function 4 for the current function. (Hot zone.)
1429			int sub_plaintext_SUB4[2000];
1430			int prime_lengths_in_order_SUB4[1000]; //Expected contiguous primes: ~667.
1431			
1432			int length_sum_SUB4 = 0;
1433			int element_SUB4 = 0; //Begins writing to prime_lengths_in_order_SUB4[] from element 0 (basic counter.)
1434			while(length_sum_SUB4 < 2000)
1435			{	if(Authorship_private[read_bookmark] < 5) {	Authorship_private[read_bookmark]++;} //Reassignes (0=1,1=2,2=3,3=4,4=5.)
1436				else //Assignes 5 to: 1, 6 to: 2, 7 to: 3, 8 to: 4, and 9 to: 5. (All prime lengths must be 1-5.)
1437				{	Authorship_private[read_bookmark] += 16;
1438					Authorship_private[read_bookmark] %= 10; //Example: 7: (7+16) = 23, 23 mod 10 = 3. Seven is now 3.
1439				}
1440				
1441				length_sum_SUB4 += Authorship_private[read_bookmark];
1442				prime_lengths_in_order_SUB4[element_SUB4] = Authorship_private[read_bookmark]; //Prime lengths are recorded in
1443				element_SUB4++; //prime_lengths_in_order_SUB4[] so as to later append it near the current ciphertext when complete.
1444				read_bookmark++; //    ...(Written to Authorship_private[].)
1445			}
1446			
1447			element_SUB4--;
1448			if(length_sum_SUB4 > 2000) //Subtracts from last entry in prime_lengths_in_order_SUB4[] so as to ensure sum(entries) = 2,000.
1449			{	int overflow = (length_sum_SUB4 % 10);
1450				prime_lengths_in_order_SUB4[element_SUB4] -= overflow;
1451			}
1452			
1453			int write_bookmark_SUB4 = 0;
1454			for(int a = 0; a <= element_SUB4; a++) //Genetates primes of corresponding length & writes them to sub_plaintext_SUB4[].
1455			{	if(prime_lengths_in_order_SUB4[a] == 1) //Randomly generates a single-digit prime.
1456				{	if(Authorship_private[read_bookmark] < 5)
1457					{	if(Authorship_private[read_bookmark + 1] < 5) {sub_plaintext_SUB4[write_bookmark_SUB4] = 2;} //The prime 2.
1458						else {sub_plaintext_SUB4[write_bookmark_SUB4] = 3;} //The prime 3.
1459					}
1460					
1461					else
1462					{	if(Authorship_private[read_bookmark + 1] < 5) {sub_plaintext_SUB4[write_bookmark_SUB4] = 5;} //The prime 5.
1463						else {sub_plaintext_SUB4[write_bookmark_SUB4] = 7;} //The prime 7.
1464					}
1465					
1466					write_bookmark_SUB4++;
1467					read_bookmark += 2;
1468					continue;
1469				}
1470				
1471				if(prime_lengths_in_order_SUB4[a] == 2) //Randomly generates a two-digit prime.
1472				{	int temp_2_digit_prime;
1473					temp_2_digit_prime = Authorship_private[read_bookmark]; //Unloads 2 array elements to make one integer.
1474					if(temp_2_digit_prime == 0) {temp_2_digit_prime++;}
1475					temp_2_digit_prime *= 10;
1476					temp_2_digit_prime += Authorship_private[read_bookmark + 1];
1477					
1478					while(sieve[temp_2_digit_prime] == 1) //Adjusts temp_2_digit_prime for primality (tests current value & searches in pos dir.)
1479					{	if(temp_2_digit_prime > 99) {temp_2_digit_prime = 97; break;} //If exceeds length of 2, sets it to largest 2-digit prime.
1480						temp_2_digit_prime++;
1481					}
1482					
1483					sub_plaintext_SUB4[write_bookmark_SUB4 + 1] = (temp_2_digit_prime % 10); //Writes prime to sub_plaintext_SUB4[].
1484					temp_2_digit_prime /= 10;
1485					sub_plaintext_SUB4[write_bookmark_SUB4] = temp_2_digit_prime;
1486					
1487					write_bookmark_SUB4 += 2;
1488					read_bookmark += 2;
1489					continue;
1490				}
1491				
1492				if(prime_lengths_in_order_SUB4[a] == 3) //Randomly generates a three-digit prime.
1493				{	int temp_3_digit_prime;
1494					temp_3_digit_prime = Authorship_private[read_bookmark]; //Unloads 3 array elements to make one integer.
1495					if(temp_3_digit_prime == 0) {temp_3_digit_prime++;}
1496					temp_3_digit_prime *= 10;
1497					temp_3_digit_prime += Authorship_private[read_bookmark + 1];
1498					temp_3_digit_prime *= 10;
1499					temp_3_digit_prime += Authorship_private[read_bookmark + 2];
1500					
1501					while(sieve[temp_3_digit_prime] == 1) //Adjusts temp_3_digit_prime for primality (tests current value & searches in pos dir.)
1502					{	if(temp_3_digit_prime > 999) {temp_3_digit_prime = 997; break;} //If exceeds length of 3, sets it to largest 3-digit prime.
1503						temp_3_digit_prime++;
1504					}
1505					
1506					sub_plaintext_SUB4[write_bookmark_SUB4 + 2] = (temp_3_digit_prime % 10); //Writes prime to sub_plaintext_SUB4[].
1507					temp_3_digit_prime /= 10;
1508					sub_plaintext_SUB4[write_bookmark_SUB4 + 1] = (temp_3_digit_prime % 10);
1509					temp_3_digit_prime /= 10;
1510					sub_plaintext_SUB4[write_bookmark_SUB4] = temp_3_digit_prime;
1511					
1512					write_bookmark_SUB4 += 3;
1513					read_bookmark += 3;
1514					continue;
1515				}
1516				
1517				if(prime_lengths_in_order_SUB4[a] == 4) //Randomly generates a four-digit prime.
1518				{	int temp_4_digit_prime;
1519					temp_4_digit_prime = Authorship_private[read_bookmark]; //Unloads 4 array elements to make one integer.
1520					if(temp_4_digit_prime == 0) {temp_4_digit_prime++;}
1521					temp_4_digit_prime *= 10;
1522					temp_4_digit_prime += Authorship_private[read_bookmark + 1];
1523					temp_4_digit_prime *= 10;
1524					temp_4_digit_prime += Authorship_private[read_bookmark + 2];
1525					temp_4_digit_prime *= 10;
1526					temp_4_digit_prime += Authorship_private[read_bookmark + 3];
1527					
1528					while(sieve[temp_4_digit_prime] == 1) //Adjusts temp_4_digit_prime for primality (tests current value & searches in pos dir.)
1529					{	if(temp_4_digit_prime > 9999) {temp_4_digit_prime = 9973; break;} //If exceeds length of 4, sets it to largest 4-digit prime.
1530						temp_4_digit_prime++;
1531					}
1532					
1533					sub_plaintext_SUB4[write_bookmark_SUB4 + 3] = (temp_4_digit_prime % 10); //Writes prime to sub_plaintext_SUB4[].
1534					temp_4_digit_prime /= 10;
1535					sub_plaintext_SUB4[write_bookmark_SUB4 + 2] = (temp_4_digit_prime % 10);
1536					temp_4_digit_prime /= 10;
1537					sub_plaintext_SUB4[write_bookmark_SUB4 + 1] = (temp_4_digit_prime % 10);
1538					temp_4_digit_prime /= 10;
1539					sub_plaintext_SUB4[write_bookmark_SUB4] = temp_4_digit_prime;
1540					
1541					write_bookmark_SUB4 += 4;
1542					read_bookmark += 4;
1543					continue;
1544				}
1545				
1546				if(prime_lengths_in_order_SUB4[a] == 5) //Randomly generates a five-digit prime.
1547				{	int temp_5_digit_prime;
1548					temp_5_digit_prime = Authorship_private[read_bookmark]; //Unloads 5 array elements to make one integer.
1549					if(temp_5_digit_prime == 0) {temp_5_digit_prime++;}
1550					temp_5_digit_prime *= 10;
1551					temp_5_digit_prime += Authorship_private[read_bookmark + 1];
1552					temp_5_digit_prime *= 10;
1553					temp_5_digit_prime += Authorship_private[read_bookmark + 2];
1554					temp_5_digit_prime *= 10;
1555					temp_5_digit_prime += Authorship_private[read_bookmark + 3];
1556					temp_5_digit_prime *= 10;
1557					temp_5_digit_prime += Authorship_private[read_bookmark + 4];
1558					
1559					while(sieve[temp_5_digit_prime] == 1) //Adjusts temp_5_digit_prime for primality (tests current value & searches in pos dir.)
1560					{	if(temp_5_digit_prime > 99999) {temp_5_digit_prime = 99991; break;} //If exceeds length of 5, sets it to largest 5-digit prime.
1561						temp_5_digit_prime++;
1562					}
1563					
1564					sub_plaintext_SUB4[write_bookmark_SUB4 + 4] = (temp_5_digit_prime % 10); //Writes prime to sub_plaintext_SUB4[].
1565					temp_5_digit_prime /= 10;
1566					sub_plaintext_SUB4[write_bookmark_SUB4 + 3] = (temp_5_digit_prime % 10);
1567					temp_5_digit_prime /= 10;
1568					sub_plaintext_SUB4[write_bookmark_SUB4 + 2] = (temp_5_digit_prime % 10);
1569					temp_5_digit_prime /= 10;
1570					sub_plaintext_SUB4[write_bookmark_SUB4 + 1] = (temp_5_digit_prime % 10);
1571					temp_5_digit_prime /= 10;
1572					sub_plaintext_SUB4[write_bookmark_SUB4] = temp_5_digit_prime;
1573					
1574					write_bookmark_SUB4 += 5;
1575					read_bookmark += 5;
1576					continue;
1577				}
1578			}
1579			
1580			for(int a = 0; a < 2000; a++) //Generates fourth sub-ciphertext of current function and writes it to Authorship_private[].
1581			{	Authorship_private[write_bookmark] = sub_key[a];
1582				Authorship_private[write_bookmark] += sub_plaintext_SUB4[a];
1583				Authorship_private[write_bookmark] %= 10;
1584				write_bookmark++;
1585			}
1586			
1587			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
1588			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
1589			
1590			for(int a = 0; a < 1996; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 5.)
1591			{	sub_key[a] += transformation_determinant[a];
1592				sub_key[a] = ((sub_key[a] + transformation_determinant[a + 4]) % 10); //[a + 4] means do up to 1995 or seg fault.
1593			}
1594			sub_key[1996] = ((sub_key[1996] + transformation_determinant[1030]) % 10); //Last four elements were not transformed so here it is.
1595			sub_key[1997] = ((sub_key[1997] + transformation_determinant[1035]) % 10);
1596			sub_key[1998] = ((sub_key[1998] + transformation_determinant[1040]) % 10);
1597			sub_key[1999] = ((sub_key[1999] + transformation_determinant[1045]) % 10);
1598			//(4th of 5 total transformations per function.) Each one is different.
1599			
1600			
1601			
1602			
1603			
1604			//The following block-bunch generates sub-function 5 for the current function. (Cool zone.)
1605			for(int a = 0; a < 2000; a++) //Generates fifth sub-ciphertext of current function and writes it to Authorship_private[].
1606			{	Authorship_private[write_bookmark] = sub_key[a];
1607				Authorship_private[write_bookmark] += Authorship_private[read_bookmark];
1608				Authorship_private[write_bookmark] %= 10;
1609				read_bookmark++;
1610				write_bookmark++;
1611			}
1612			
1613			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
1614			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
1615			
1616			for(int a = 0; a < 1995; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 6.)
1617			{	sub_key[a] += transformation_determinant[a];
1618				sub_key[a] = ((sub_key[a] + transformation_determinant[a + 5]) % 10); //[a + 5] means do up to 1994 or seg fault.
1619			}
1620			sub_key[1995] = ((sub_key[1995] + transformation_determinant[1050]) % 10); //Last five elements were not transformed so here it is.
1621			sub_key[1996] = ((sub_key[1996] + transformation_determinant[1055]) % 10);
1622			sub_key[1997] = ((sub_key[1997] + transformation_determinant[1060]) % 10);
1623			sub_key[1998] = ((sub_key[1998] + transformation_determinant[1065]) % 10);
1624			sub_key[1999] = ((sub_key[1999] + transformation_determinant[1070]) % 10);
1625			//(5th of 5 total transformations per function.) Each one is different.
1626			
1627			
1628			
1629			
1630			
1631			//The following block-bunch generates sub-function 6 for the current function. (Hot zone.)
1632			int sub_plaintext_SUB6[2000];
1633			int prime_lengths_in_order_SUB6[1000]; //Expected contiguous primes: ~667.
1634			
1635			int length_sum_SUB6 = 0;
1636			int element_SUB6 = 0; //Begins writing to prime_lengths_in_order_SUB6[] from element 0 (basic counter.)
1637			while(length_sum_SUB6 < 2000)
1638			{	if(Authorship_private[read_bookmark] < 5) {	Authorship_private[read_bookmark]++;} //Reassignes (0=1,1=2,2=3,3=4,4=5.)
1639				else //Assignes 5 to: 1, 6 to: 2, 7 to: 3, 8 to: 4, and 9 to: 5. (All prime lengths must be 1-5.)
1640				{	Authorship_private[read_bookmark] += 16;
1641					Authorship_private[read_bookmark] %= 10; //Example: 7: (7+16) = 23, 23 mod 10 = 3. Seven is now 3.
1642				}
1643				
1644				length_sum_SUB6 += Authorship_private[read_bookmark];
1645				prime_lengths_in_order_SUB6[element_SUB6] = Authorship_private[read_bookmark]; //Prime lengths are recorded in
1646				element_SUB6++; //prime_lengths_in_order_SUB6[] so as to later append it near the current ciphertext when complete.
1647				read_bookmark++; //    ...(Written to Authorship_private[].)
1648			}
1649			
1650			element_SUB6--;
1651			if(length_sum_SUB6 > 2000) //Subtracts from last entry in prime_lengths_in_order_SUB6[] so as to ensure sum(entries) = 2,000.
1652			{	int overflow = (length_sum_SUB6 % 10);
1653				prime_lengths_in_order_SUB6[element_SUB6] -= overflow;
1654			}
1655			
1656			int write_bookmark_SUB6 = 0;
1657			for(int a = 0; a <= element_SUB6; a++) //Genetates primes of corresponding length & writes them to sub_plaintext_SUB6[].
1658			{	if(prime_lengths_in_order_SUB6[a] == 1) //Randomly generates a single-digit prime.
1659				{	if(Authorship_private[read_bookmark] < 5)
1660					{	if(Authorship_private[read_bookmark + 1] < 5) {sub_plaintext_SUB6[write_bookmark_SUB6] = 2;} //The prime 2.
1661						else {sub_plaintext_SUB6[write_bookmark_SUB6] = 3;} //The prime 3.
1662					}
1663					
1664					else
1665					{	if(Authorship_private[read_bookmark + 1] < 5) {sub_plaintext_SUB6[write_bookmark_SUB6] = 5;} //The prime 5.
1666						else {sub_plaintext_SUB6[write_bookmark_SUB6] = 7;} //The prime 7.
1667					}
1668					
1669					write_bookmark_SUB6++;
1670					read_bookmark += 2;
1671					continue;
1672				}
1673				
1674				if(prime_lengths_in_order_SUB6[a] == 2) //Randomly generates a two-digit prime.
1675				{	int temp_2_digit_prime;
1676					temp_2_digit_prime = Authorship_private[read_bookmark]; //Unloads 2 array elements to make one integer.
1677					if(temp_2_digit_prime == 0) {temp_2_digit_prime++;}
1678					temp_2_digit_prime *= 10;
1679					temp_2_digit_prime += Authorship_private[read_bookmark + 1];
1680					
1681					while(sieve[temp_2_digit_prime] == 1) //Adjusts temp_2_digit_prime for primality (tests current value & searches in pos dir.)
1682					{	if(temp_2_digit_prime > 99) {temp_2_digit_prime = 97; break;} //If exceeds length of 2, sets it to largest 2-digit prime.
1683						temp_2_digit_prime++;
1684					}
1685					
1686					sub_plaintext_SUB6[write_bookmark_SUB6 + 1] = (temp_2_digit_prime % 10); //Writes prime to sub_plaintext_SUB6[].
1687					temp_2_digit_prime /= 10;
1688					sub_plaintext_SUB6[write_bookmark_SUB6] = temp_2_digit_prime;
1689					
1690					write_bookmark_SUB6 += 2;
1691					read_bookmark += 2;
1692					continue;
1693				}
1694				
1695				if(prime_lengths_in_order_SUB6[a] == 3) //Randomly generates a three-digit prime.
1696				{	int temp_3_digit_prime;
1697					temp_3_digit_prime = Authorship_private[read_bookmark]; //Unloads 3 array elements to make one integer.
1698					if(temp_3_digit_prime == 0) {temp_3_digit_prime++;}
1699					temp_3_digit_prime *= 10;
1700					temp_3_digit_prime += Authorship_private[read_bookmark + 1];
1701					temp_3_digit_prime *= 10;
1702					temp_3_digit_prime += Authorship_private[read_bookmark + 2];
1703					
1704					while(sieve[temp_3_digit_prime] == 1) //Adjusts temp_3_digit_prime for primality (tests current value & searches in pos dir.)
1705					{	if(temp_3_digit_prime > 999) {temp_3_digit_prime = 997; break;} //If exceeds length of 3, sets it to largest 3-digit prime.
1706						temp_3_digit_prime++;
1707					}
1708					
1709					sub_plaintext_SUB6[write_bookmark_SUB6 + 2] = (temp_3_digit_prime % 10); //Writes prime to sub_plaintext_SUB6[].
1710					temp_3_digit_prime /= 10;
1711					sub_plaintext_SUB6[write_bookmark_SUB6 + 1] = (temp_3_digit_prime % 10);
1712					temp_3_digit_prime /= 10;
1713					sub_plaintext_SUB6[write_bookmark_SUB6] = temp_3_digit_prime;
1714					
1715					write_bookmark_SUB6 += 3;
1716					read_bookmark += 3;
1717					continue;
1718				}
1719				
1720				if(prime_lengths_in_order_SUB6[a] == 4) //Randomly generates a four-digit prime.
1721				{	int temp_4_digit_prime;
1722					temp_4_digit_prime = Authorship_private[read_bookmark]; //Unloads 4 array elements to make one integer.
1723					if(temp_4_digit_prime == 0) {temp_4_digit_prime++;}
1724					temp_4_digit_prime *= 10;
1725					temp_4_digit_prime += Authorship_private[read_bookmark + 1];
1726					temp_4_digit_prime *= 10;
1727					temp_4_digit_prime += Authorship_private[read_bookmark + 2];
1728					temp_4_digit_prime *= 10;
1729					temp_4_digit_prime += Authorship_private[read_bookmark + 3];
1730					
1731					while(sieve[temp_4_digit_prime] == 1) //Adjusts temp_4_digit_prime for primality (tests current value & searches in pos dir.)
1732					{	if(temp_4_digit_prime > 9999) {temp_4_digit_prime = 9973; break;} //If exceeds length of 4, sets it to largest 4-digit prime.
1733						temp_4_digit_prime++;
1734					}
1735					
1736					sub_plaintext_SUB6[write_bookmark_SUB6 + 3] = (temp_4_digit_prime % 10); //Writes prime to sub_plaintext_SUB6[].
1737					temp_4_digit_prime /= 10;
1738					sub_plaintext_SUB6[write_bookmark_SUB6 + 2] = (temp_4_digit_prime % 10);
1739					temp_4_digit_prime /= 10;
1740					sub_plaintext_SUB6[write_bookmark_SUB6 + 1] = (temp_4_digit_prime % 10);
1741					temp_4_digit_prime /= 10;
1742					sub_plaintext_SUB6[write_bookmark_SUB6] = temp_4_digit_prime;
1743					
1744					write_bookmark_SUB6 += 4;
1745					read_bookmark += 4;
1746					continue;
1747				}
1748				
1749				if(prime_lengths_in_order_SUB6[a] == 5) //Randomly generates a five-digit prime.
1750				{	int temp_5_digit_prime;
1751					temp_5_digit_prime = Authorship_private[read_bookmark]; //Unloads 5 array elements to make one integer.
1752					if(temp_5_digit_prime == 0) {temp_5_digit_prime++;}
1753					temp_5_digit_prime *= 10;
1754					temp_5_digit_prime += Authorship_private[read_bookmark + 1];
1755					temp_5_digit_prime *= 10;
1756					temp_5_digit_prime += Authorship_private[read_bookmark + 2];
1757					temp_5_digit_prime *= 10;
1758					temp_5_digit_prime += Authorship_private[read_bookmark + 3];
1759					temp_5_digit_prime *= 10;
1760					temp_5_digit_prime += Authorship_private[read_bookmark + 4];
1761					
1762					while(sieve[temp_5_digit_prime] == 1) //Adjusts temp_5_digit_prime for primality (tests current value & searches in pos dir.)
1763					{	if(temp_5_digit_prime > 99999) {temp_5_digit_prime = 99991; break;} //If exceeds length of 5, sets it to largest 5-digit prime.
1764						temp_5_digit_prime++;
1765					}
1766					
1767					sub_plaintext_SUB6[write_bookmark_SUB6 + 4] = (temp_5_digit_prime % 10); //Writes prime to sub_plaintext_SUB6[].
1768					temp_5_digit_prime /= 10;
1769					sub_plaintext_SUB6[write_bookmark_SUB6 + 3] = (temp_5_digit_prime % 10);
1770					temp_5_digit_prime /= 10;
1771					sub_plaintext_SUB6[write_bookmark_SUB6 + 2] = (temp_5_digit_prime % 10);
1772					temp_5_digit_prime /= 10;
1773					sub_plaintext_SUB6[write_bookmark_SUB6 + 1] = (temp_5_digit_prime % 10);
1774					temp_5_digit_prime /= 10;
1775					sub_plaintext_SUB6[write_bookmark_SUB6] = temp_5_digit_prime;
1776					
1777					write_bookmark_SUB6 += 5;
1778					read_bookmark += 5;
1779					continue;
1780				}
1781			}
1782			
1783			for(int a = 0; a < 2000; a++) //Generates sixth sub-ciphertext of current function and writes it to Authorship_private[].
1784			{	Authorship_private[write_bookmark] = sub_key[a];
1785				Authorship_private[write_bookmark] += sub_plaintext_SUB6[a];
1786				Authorship_private[write_bookmark] %= 10;
1787				write_bookmark++;
1788			}
1789			
1790			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
1791			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
1792			
1793			
1794			
1795			
1796			
1797			//The following block-bunch generates the Authorship number dynamically. (Its final form is then produced after the 13,500 functions.)
1798			//This sits here (just after the full function is written to array Authorship_private[]) because now temp_write_bookmark fingerprints the
1799			//function right to left so as to build the Authorship number. Then solution ingredients are appended to the current function.
1800			compression_119[0] += compression_119[99];
1801			compression_119[0] %= 10000000000;
1802			
1803			int temp_write_bookmark;
1804			temp_write_bookmark = (write_bookmark - 2);
1805			
1806			for(int a = 0; a < 100; a++)
1807			{	compression_115[a] += Authorship_private[temp_write_bookmark];
1808				compression_115[a] *= 5;
1809				compression_115[a] %= 10000000000;
1810				temp_write_bookmark -= 115;
1811			}
1812			temp_write_bookmark = (write_bookmark - 2); //Resetting the temporary variable.
1813			
1814			for(int a = 0; a < 100; a++)
1815			{	compression_116[a] += Authorship_private[temp_write_bookmark];
1816				compression_116[a] *= 6;
1817				compression_116[a] %= 10000000000;
1818				temp_write_bookmark -= 116;
1819			}
1820			temp_write_bookmark = (write_bookmark - 2); //Resetting the temporary variable.
1821			
1822			for(int a = 0; a < 100; a++)
1823			{	compression_117[a] += Authorship_private[temp_write_bookmark];
1824				compression_117[a] *= 7;
1825				compression_117[a] %= 10000000000;
1826				temp_write_bookmark -= 117;
1827			}
1828			temp_write_bookmark = (write_bookmark - 2); //Resetting the temporary variable.
1829			
1830			for(int a = 0; a < 100; a++)
1831			{	compression_118[a] += Authorship_private[temp_write_bookmark];
1832				compression_118[a] *= 8;
1833				compression_118[a] %= 10000000000;
1834				temp_write_bookmark -= 118;
1835			}
1836			temp_write_bookmark = (write_bookmark - 2); //Resetting the temporary variable.
1837			
1838			for(int a = 0; a < 100; a++)
1839			{	compression_119[a] += Authorship_private[temp_write_bookmark];
1840				compression_119[a] *= 9;
1841				compression_119[a] %= 10000000000;
1842				temp_write_bookmark -= 119;
1843			}
1844			
1845			//Compression snapshots are active in early stages of Authorship number evolution. They are applied to the compression in the end.
1846			if((f == 1000) || (f == 2000) || (f == 3000) || (f == 4000) || (f == 5000) || (f == 6000) || (f == 7000) || (f == 8000))
1847			{	for(int a = 0; a < 100; a++)
1848				{	snapshot_115[a] += compression_115[a];
1849					snapshot_115[a] %= 10000000000; //(10^10, results in last ten digits shown.)
1850					
1851					snapshot_116[a] += compression_116[a];
1852					snapshot_116[a] %= 10000000000;
1853					
1854					snapshot_117[a] += compression_117[a];
1855					snapshot_117[a] %= 10000000000;
1856					
1857					snapshot_118[a] += compression_118[a];
1858					snapshot_118[a] %= 10000000000;
1859					
1860					snapshot_119[a] += compression_119[a];
1861					snapshot_119[a] %= 10000000000;
1862				}
1863			}
1864			
1865			
1866			
1867			
1868			
1869			//The following block-bunch appends to the current function in Authorship_private[]: solution ingredients.
1870			for(int a = 0; a < 2000; a++) //Writes the transformation determinant.
1871			{	Authorship_private[write_bookmark] = transformation_determinant[a];
1872				write_bookmark++;
1873			}
1874			
1875			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
1876			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
1877			
1878			for(int a = 0; a < 2000; a++) //Writes the sub-key.
1879			{	Authorship_private[write_bookmark] = temp_sub_key[a];
1880				write_bookmark++;
1881			}
1882			
1883			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
1884			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
1885			
1886			for(int a = 0; a <= element_SUB2; a++) //Writes the prime_lengths_in_order_SUB2 (hot zone.)
1887			{	Authorship_private[write_bookmark] = prime_lengths_in_order_SUB2[a];
1888				write_bookmark++;
1889			}
1890			
1891			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
1892			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
1893			
1894			for(int a = 0; a <= element_SUB4; a++) //Writes the prime_lengths_in_order_SUB4 (hot zone.)
1895			{	Authorship_private[write_bookmark] = prime_lengths_in_order_SUB4[a];
1896				write_bookmark++;
1897			}
1898			
1899			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
1900			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
1901			
1902			for(int a = 0; a <= element_SUB6; a++) //Writes the prime_lengths_in_order_SUB6 (hot zone.)
1903			{	Authorship_private[write_bookmark] = prime_lengths_in_order_SUB6[a];
1904				write_bookmark++;
1905			}
1906			
1907			Authorship_private[write_bookmark] = '.'; //Separates the entry in Authorship_private[] from the next by one dot because
1908			write_bookmark++;                         //the quantity of contiguous primes is not fixed in length. All entries are separated.
1909			
1910			if((read_bookmark - write_bookmark) < 30000) //Further collision prevention for read/write bookmarks. After each cycle within this
1911			{	read_bookmark += 1000000; //for loop, read_bookmark increases by ~16,000 while write_bookmark increases by ~18,000 and so the
1912			}                             //write_bookmark evenually catches up. This block forces read_bookmark to jump dynamically.
1913		                                  //Consider instead making tiny jumps away from write_bookmark--adjusting only by ~2,000 elements forward.
1914		                                  //That would be okay because you're just following along with write_bookmark and Authorship_private[]
1915		                                  //fits them all just fine. Now consider jumping only once in a while--distancing in bulk. This is no more
1916		                                  //a waste of random numbers than making small jumps. The bookmarks simply and smoothly approach
1917		                                  //one another over time. All that space between them must exist one way or another--in bulk or in parts.
1918		}
1919		
1920		
1921		
1922		
1923		
1924		//Loads old Authorship.private into old[].
1925		static char old[256500000];
1926		ifstream in_stream;
1927		in_stream.open("Authorship.private");
1928		
1929		for(int a = 0; a < 256500000; a++)
1930		{	in_stream >> old[a];
1931			if(old[a] == '\0') {break;}
1932		}
1933		
1934		in_stream.close();
1935		
1936		
1937		
1938		
1939		
1940		//Writes everything to the file Authorship.private including the last dot then the null character.
1941		ofstream out_stream;
1942		out_stream.open("Authorship.private");
1943		
1944		for(int a = 0; a < write_bookmark; a++)
1945		{	if(Authorship_private[a] == '.') {out_stream << '.';}
1946			else {out_stream << int(Authorship_private[a]);}
1947		}
1948		out_stream << '\0'; //These digits will be loaded into RAM one day, null marks when to stop reading them.
1949		
1950		out_stream.close();
1951		
1952		
1953		
1954		
1955		
1956		//Constructively combines the comression tables. compression_119[] will hold it all.
1957		for(int a = 0; a < 100; a++)
1958		{	compression_119[a] += compression_115[a];
1959			if((compression_119[a] % 2) == 0) {compression_119[a] *= 2;}
1960			
1961			compression_119[a] += compression_116[a];
1962			if((compression_119[a] % 2) == 0) {compression_119[a] *= 3;}
1963			
1964			compression_119[a] += compression_117[a];
1965			if((compression_119[a] % 2) == 0) {compression_119[a] *= 5;}
1966			
1967			compression_119[a] += compression_118[a];
1968			if((compression_119[a] % 2) == 0) {compression_119[a] *= 7;}
1969			
1970			compression_119[a] %= 10000000000; //(10^10, results in last ten digits shown.)
1971		}
1972		
1973		//Constructively combines the snapshot tables. snapshot_119[] will hold it all.
1974		for(int a = 0; a < 100; a++)
1975		{	snapshot_119[a] += snapshot_115[a];
1976			if((snapshot_119[a] % 2) == 0) {snapshot_119[a] *= 2;}
1977			
1978			snapshot_119[a] += snapshot_116[a];
1979			if((snapshot_119[a] % 2) == 0) {snapshot_119[a] *= 3;}
1980			
1981			snapshot_119[a] += snapshot_117[a];
1982			if((snapshot_119[a] % 2) == 0) {snapshot_119[a] *= 5;}
1983			
1984			snapshot_119[a] += snapshot_118[a];
1985			if((snapshot_119[a] % 2) == 0) {snapshot_119[a] *= 7;}
1986			
1987			snapshot_119[a] %= 10000000000; //(10^10, results in last ten digits shown.)
1988		}
1989		
1990		//Applies the snapshots to the last stage in compression. (As the Authorship number evolved over time, snapshots made a record of its early stages.)
1991		for(int a = 0; a < 100; a++)
1992		{	compression_119[a] += snapshot_119[a];
1993			compression_119[a] %= 10000000000; //(10^10, results in last ten digits shown.)
1994		}
1995		
1996		for(int a = 0; a < 100; a++) //Ensures each constituent compression integer is 10 digits long. The Authorship number is now complete.
1997		{	if(compression_119[a] < 1000000000)
1998			{	compression_119[a] += 1000000000;
1999			}
2000		}
2001		
2002		//Copies the new number incase the user will want it. Numbers are normally not necessary to handle by the user.
2003		//This option to see the new number allows any newcommer to begin verifying authentication events.
2004		//Perhaps some verifying party had lost your number and wishes to begin again, here.
2005		long long int temp_compression_119[100];
2006		for(int a = 0; a < 100; a++) {temp_compression_119[a] = compression_119[a];}
2007		
2008		
2009		
2010		
2011		
2012		//The following table shows symbol assignment. Every contiguous nine multi-way functions in the list of 13,500 represent something.
2013		//Recall that 5/9 of all special strings of nine are always "1" so as to prevent ambiguity through clever selective censorship.
2014		///          nine functions     Authorship   user's                   original
2015		///            solved = 1         number     message                 ASCII # of
2016		/// ref       unsolved = 0       fragment   character                characters
2017		//#  1		0 0 0 0 1 1 1 1 1		00			 	(blank or space)	(32)
2018		//#  2		0 0 0 1 0 1 1 1 1		01			!						(33)
2019		//#  3		0 0 0 1 1 0 1 1 1		02			"						(34)
2020		//#  4		0 0 0 1 1 1 0 1 1		03			#						(35)
2021		//#  5		0 0 0 1 1 1 1 0 1		04			$						(36)
2022		//#  6		0 0 0 1 1 1 1 1 0		05			%						(37)
2023		//#  7		0 0 1 0 0 1 1 1 1		06			&						(38)
2024		//#  8		0 0 1 0 1 0 1 1 1		07			'						(39)
2025		//#  9		0 0 1 0 1 1 0 1 1		08			(						(40)
2026		//# 10		0 0 1 0 1 1 1 0 1		09			)						(41)
2027		//# 11		0 0 1 0 1 1 1 1 0		10			*						(42)
2028		//# 12		0 0 1 1 0 0 1 1 1		11			+						(43)
2029		//# 13		0 0 1 1 0 1 0 1 1		12			,	(comma)				(44)
2030		//# 14		0 0 1 1 0 1 1 0 1		13			-	(minus)				(45)
2031		//# 15		0 0 1 1 0 1 1 1 0		14			.	(dot)				(46)
2032		//# 16		0 0 1 1 1 0 0 1 1		15			/						(47)
2033		//# 17		0 0 1 1 1 0 1 0 1		16			0						(48)
2034		//# 18		0 0 1 1 1 0 1 1 0		17			1	(the number one)	(49)
2035		//# 19		0 0 1 1 1 1 0 0 1		18			2						(50)
2036		//# 20		0 0 1 1 1 1 0 1 0		19			3						(51)
2037		//# 21		0 0 1 1 1 1 1 0 0		20			4						(52)
2038		//# 22		0 1 0 0 0 1 1 1 1		21			5						(53)
2039		//# 23		0 1 0 0 1 0 1 1 1		22			6						(54)
2040		//# 24		0 1 0 0 1 1 0 1 1		23			7						(55)
2041		//# 25		0 1 0 0 1 1 1 0 1		24			8						(56)
2042		//# 26		0 1 0 0 1 1 1 1 0		25			9						(57)
2043		//# 27		0 1 0 1 0 0 1 1 1		26			:						(58)
2044		//# 28		0 1 0 1 0 1 0 1 1		27			;						(59)
2045		//# 29		0 1 0 1 0 1 1 0 1		28			<						(60)
2046		//# 30		0 1 0 1 0 1 1 1 0		29			=						(61)
2047		//# 31		0 1 0 1 1 0 0 1 1		30			>						(62)
2048		//# 32		0 1 0 1 1 0 1 0 1		31			?						(63)
2049		//# 33		0 1 0 1 1 0 1 1 0		32			@						(64)
2050		//# 34		0 1 0 1 1 1 0 0 1		33			A						(65)
2051		//# 35		0 1 0 1 1 1 0 1 0		34			B						(66)
2052		//# 36		0 1 0 1 1 1 1 0 0		35			C						(67)
2053		//# 37		0 1 1 0 0 0 1 1 1		36			D						(68)
2054		//# 38		0 1 1 0 0 1 0 1 1		37			E						(69)
2055		//# 39		0 1 1 0 0 1 1 0 1		38			F						(70)
2056		//# 40		0 1 1 0 0 1 1 1 0		39			G						(71)
2057		//# 41		0 1 1 0 1 0 0 1 1		40			H						(72)
2058		//# 42		0 1 1 0 1 0 1 0 1		41			I						(73)
2059		//# 43		0 1 1 0 1 0 1 1 0		42			J						(74)
2060		//# 44		0 1 1 0 1 1 0 0 1		43			K						(75)
2061		//# 45		0 1 1 0 1 1 0 1 0		44			L						(76)
2062		//# 46		0 1 1 0 1 1 1 0 0		45			M						(77)
2063		//# 47		0 1 1 1 0 0 0 1 1		46			N						(78)
2064		//# 48		0 1 1 1 0 0 1 0 1		47			O						(79)
2065		//# 49		0 1 1 1 0 0 1 1 0		48			P						(80)
2066		//# 50		0 1 1 1 0 1 0 0 1		49			Q						(81)
2067		//# 51		0 1 1 1 0 1 0 1 0		50			R						(82)
2068		//# 52		0 1 1 1 0 1 1 0 0		51			S						(83)
2069		//# 53		0 1 1 1 1 0 0 0 1		52			T						(84)
2070		//# 54		0 1 1 1 1 0 0 1 0		53			U						(85)
2071		//# 55		0 1 1 1 1 0 1 0 0		54			V						(86)
2072		//# 56		0 1 1 1 1 1 0 0 0		55			W						(87)
2073		//# 57		1 0 0 0 0 1 1 1 1		56			X						(88)
2074		//# 58		1 0 0 0 1 0 1 1 1		57			Y						(89)
2075		//# 59		1 0 0 0 1 1 0 1 1		58			Z						(90)
2076		//# 60		1 0 0 0 1 1 1 0 1		59			[						(91)
2077		//# 61		1 0 0 0 1 1 1 1 0		60			\						(92)
2078		//# 62		1 0 0 1 0 0 1 1 1		61			]						(93)
2079		//# 63		1 0 0 1 0 1 0 1 1		62			^						(94)
2080		//# 64		1 0 0 1 0 1 1 0 1		63			_	(underscore)		(95)
2081		//# 65		1 0 0 1 0 1 1 1 0		64			`	(slant/emphasis)	(96)
2082		//# 66		1 0 0 1 1 0 0 1 1		65			a						(97)
2083		//# 67		1 0 0 1 1 0 1 0 1		66			b						(98)
2084		//# 68		1 0 0 1 1 0 1 1 0		67			c					    (99)
2085		//# 69		1 0 0 1 1 1 0 0 1		68			d					   (100)
2086		//# 70		1 0 0 1 1 1 0 1 0		69			e					   (101)
2087		//# 71		1 0 0 1 1 1 1 0 0		70			f					   (102)
2088		//# 72		1 0 1 0 0 0 1 1 1		71			g					   (103)
2089		//# 73		1 0 1 0 0 1 0 1 1		72			h					   (104)
2090		//# 74		1 0 1 0 0 1 1 0 1		73			i					   (105)
2091		//# 75		1 0 1 0 0 1 1 1 0		74			j					   (106)
2092		//# 76		1 0 1 0 1 0 0 1 1		75			k					   (107)
2093		//# 77		1 0 1 0 1 0 1 0 1		76			l	(l as in lake)	   (108)
2094		//# 78		1 0 1 0 1 0 1 1 0		77			m					   (109)
2095		//# 79		1 0 1 0 1 1 0 0 1		78			n					   (110)
2096		//# 80		1 0 1 0 1 1 0 1 0		79			o					   (111)
2097		//# 81		1 0 1 0 1 1 1 0 0		80			p					   (112)
2098		//# 82		1 0 1 1 0 0 0 1 1		81			q					   (113)
2099		//# 83		1 0 1 1 0 0 1 0 1		82			r					   (114)
2100		//# 84		1 0 1 1 0 0 1 1 0		83			s					   (115)
2101		//# 85		1 0 1 1 0 1 0 0 1		84			t					   (116)
2102		//# 86		1 0 1 1 0 1 0 1 0		85			u					   (117)
2103		//# 87		1 0 1 1 0 1 1 0 0		86			v					   (118)
2104		//# 88		1 0 1 1 1 0 0 0 1		87			w					   (119)
2105		//# 89		1 0 1 1 1 0 0 1 0		88			x					   (120)
2106		//# 90		1 0 1 1 1 0 1 0 0		89			y					   (121)
2107		//# 91		1 0 1 1 1 1 0 0 0		90			z					   (122)
2108		//# 92		1 1 0 0 0 0 1 1 1		91			{					   (123)
2109		//# 93		1 1 0 0 0 1 0 1 1		92			|	(Unix pipe)		   (124)
2110		//# 94		1 1 0 0 0 1 1 0 1		93			}					   (125)
2111		//# 95		1 1 0 0 0 1 1 1 0		94			~					   (126) (And this makes 95 printable ASCII characters.)
2112		//# 96		1 1 0 0 1 0 0 1 1		95			no char
2113		//# 97		1 1 0 0 1 0 1 0 1		96			unassigned
2114		//# 98		1 1 0 0 1 0 1 1 0		97			unassigned
2115		//# 99		1 1 0 0 1 1 0 0 1		98			unassigned
2116		//#100		1 1 0 0 1 1 0 1 0		99			unassigned
2117		//#101		1 1 0 0 1 1 1 0 0		unassigned	unassigned
2118		//#102		1 1 0 1 0 0 0 1 1		unassigned	unassigned
2119		//#103		1 1 0 1 0 0 1 0 1		unassigned	unassigned
2120		//#104		1 1 0 1 0 0 1 1 0		unassigned	unassigned
2121		//#105		1 1 0 1 0 1 0 0 1		unassigned	unassigned
2122		//#106		1 1 0 1 0 1 0 1 0		unassigned	unassigned
2123		//#107		1 1 0 1 0 1 1 0 0		unassigned	unassigned
2124		//#108		1 1 0 1 1 0 0 0 1		unassigned	unassigned
2125		//#109		1 1 0 1 1 0 0 1 0		unassigned	unassigned
2126		//#110		1 1 0 1 1 0 1 0 0		unassigned	unassigned
2127		//#111		1 1 0 1 1 1 0 0 0		unassigned	unassigned
2128		//#112		1 1 1 0 0 0 0 1 1		unassigned	unassigned
2129		//#113		1 1 1 0 0 0 1 0 1		unassigned	unassigned
2130		//#114		1 1 1 0 0 0 1 1 0		unassigned	unassigned
2131		//#115		1 1 1 0 0 1 0 0 1		unassigned	unassigned
2132		//#116		1 1 1 0 0 1 0 1 0		unassigned	unassigned
2133		//#117		1 1 1 0 0 1 1 0 0		unassigned	unassigned
2134		//#118		1 1 1 0 1 0 0 0 1		unassigned	unassigned
2135		//#119		1 1 1 0 1 0 0 1 0		unassigned	unassigned
2136		//#120		1 1 1 0 1 0 1 0 0		unassigned	unassigned
2137		//#121		1 1 1 0 1 1 0 0 0		unassigned	unassigned
2138		//#122		1 1 1 1 0 0 0 0 1		unassigned	unassigned
2139		//#123		1 1 1 1 0 0 0 1 0		unassigned	unassigned
2140		//#124		1 1 1 1 0 0 1 0 0		unassigned	unassigned
2141		//#125		1 1 1 1 0 1 0 0 0		unassigned	unassigned
2142		//#126		1 1 1 1 1 0 0 0 0		unassigned	unassigned
2143		
2144		//Combination 96 (reference # 96) is repeated for all remaining contiguous nine functions if no user message exists.
2145		//For messages shorter than 1,000 characters, remaining unused spaces are also filled with combination 96 (1 1 0 0 1 0 0 1 1.)
2146		//(Combination 96 is a custom assignment in the Authorship program. It is NOT the null character.)
2147		
2148		
2149		
2150		
2151		
2152		//The following block-bunch converts the new number and message information into the "5/9 filled special binary combinations."
2153		int pair[500];
2154		int pair_write_bookmark = 4;
2155		for(int a = 0; a < 100; a++) //Converts number into array (loads number as fragments of 2 digits into each element of pair[].)
2156		{	pair[pair_write_bookmark] = compression_119[a] % 100;
2157			compression_119[a] /= 100;
2158			pair[pair_write_bookmark - 1] = compression_119[a] % 100;
2159			compression_119[a] /= 100;
2160			pair[pair_write_bookmark - 2] = compression_119[a] % 100;
2161			compression_119[a] /= 100;
2162			pair[pair_write_bookmark - 3] = compression_119[a] % 100; //(Don't forget, C++ is sensitive to order, parentheses,
2163			compression_119[a] /= 100;                                //and commands (compression_119[a] mod 100) is performed first.
2164			pair[pair_write_bookmark - 4] = compression_119[a];
2165			
2166			pair_write_bookmark += 5;
2167		}
2168		
2169		bool b[13500]; //b for binary, will hold the final binary super-string.
2170		int m = 0; //Write bookmark for b[].
2171		for(int a = 0; a < 500; a++) //Loads binary expansion for number into b[]. (The first 500 groups of nine in b[] will represent the Authorship number, each group giving a digit pair.)
2172		{
2173		    //         number
2174		    //        fragment      |           |           |           |           |           |           |           |           |
2175			if(pair[a] == 0) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2176			if(pair[a] == 1) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2177			if(pair[a] == 2) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2178			if(pair[a] == 3) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2179			if(pair[a] == 4) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2180			if(pair[a] == 5) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2181			if(pair[a] == 6) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2182			if(pair[a] == 7) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2183			if(pair[a] == 8) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2184			if(pair[a] == 9) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2185			if(pair[a] ==10) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2186			if(pair[a] ==11) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2187			if(pair[a] ==12) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2188			if(pair[a] ==13) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2189			if(pair[a] ==14) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2190			if(pair[a] ==15) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2191			if(pair[a] ==16) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2192			if(pair[a] ==17) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2193			if(pair[a] ==18) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2194			if(pair[a] ==19) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2195			if(pair[a] ==20) {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2196			if(pair[a] ==21) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2197			if(pair[a] ==22) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2198			if(pair[a] ==23) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2199			if(pair[a] ==24) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2200			if(pair[a] ==25) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2201			if(pair[a] ==26) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2202			if(pair[a] ==27) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2203			if(pair[a] ==28) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2204			if(pair[a] ==29) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2205			if(pair[a] ==30) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2206			if(pair[a] ==31) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2207			if(pair[a] ==32) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2208			if(pair[a] ==33) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2209			if(pair[a] ==34) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2210			if(pair[a] ==35) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2211			if(pair[a] ==36) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2212			if(pair[a] ==37) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2213			if(pair[a] ==38) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2214			if(pair[a] ==39) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2215			if(pair[a] ==40) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2216			if(pair[a] ==41) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2217			if(pair[a] ==42) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2218			if(pair[a] ==43) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2219			if(pair[a] ==44) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2220			if(pair[a] ==45) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2221			if(pair[a] ==46) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2222			if(pair[a] ==47) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2223			if(pair[a] ==48) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2224			if(pair[a] ==49) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2225			if(pair[a] ==50) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2226			if(pair[a] ==51) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2227			if(pair[a] ==52) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2228			if(pair[a] ==53) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2229			if(pair[a] ==54) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2230			if(pair[a] ==55) {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2231			if(pair[a] ==56) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2232			if(pair[a] ==57) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2233			if(pair[a] ==58) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2234			if(pair[a] ==59) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2235			if(pair[a] ==60) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2236			if(pair[a] ==61) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2237			if(pair[a] ==62) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2238			if(pair[a] ==63) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2239			if(pair[a] ==64) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2240			if(pair[a] ==65) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2241			if(pair[a] ==66) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2242			if(pair[a] ==67) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2243			if(pair[a] ==68) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2244			if(pair[a] ==69) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2245			if(pair[a] ==70) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2246			if(pair[a] ==71) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2247			if(pair[a] ==72) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2248			if(pair[a] ==73) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2249			if(pair[a] ==74) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2250			if(pair[a] ==75) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2251			if(pair[a] ==76) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2252			if(pair[a] ==77) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2253			if(pair[a] ==78) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2254			if(pair[a] ==79) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2255			if(pair[a] ==80) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2256			if(pair[a] ==81) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2257			if(pair[a] ==82) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2258			if(pair[a] ==83) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2259			if(pair[a] ==84) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2260			if(pair[a] ==85) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2261			if(pair[a] ==86) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2262			if(pair[a] ==87) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2263			if(pair[a] ==88) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2264			if(pair[a] ==89) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2265			if(pair[a] ==90) {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2266			if(pair[a] ==91) {b[m]= 1;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2267			if(pair[a] ==92) {b[m]= 1;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2268			if(pair[a] ==93) {b[m]= 1;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2269			if(pair[a] ==94) {b[m]= 1;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2270			if(pair[a] ==95) {b[m]= 1;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2271			if(pair[a] ==96) {b[m]= 1;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2272			if(pair[a] ==97) {b[m]= 1;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2273			if(pair[a] ==98) {b[m]= 1;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2274			if(pair[a] ==99) {b[m]= 1;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;} //This is 100th (00 - 99.)
2275		}   //                      |           |           |           |           |           |           |           |           |
2276		
2277		m = 4500; //Sets write head of b[] to where the user message will begin in "5/9 binary" as the last operation (above) did m += 9. b[4500] is the 4,501st element.
2278		
2279		//Now b[] is filled with user message information...
2280		//Message or not, remaining b[] elements are filled with reference # 96 (null = 1 1 0 0 1 0 0 1 1.)
2281		{	for(int a = 0; a < 1000; a++) //Remaining 1000 groups of nine.)
2282			{	b[m]= 1;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;
2283			}//       |           |           |           |           |           |           |           |           |
2284		}
2285		
2286		if(message[0] != '\0')
2287		{	m = 4500; //Again, sets write head of b[] to where the user message will begin in "5/9 binary." b[4500] is the 4,501st element.
2288			for(int a = 0; message[a] != '\0'; a++) //Loads binary expansion for user's message. (The remaining 1,000 groups of nine in b[] will represent the user message or data.)
2289			{	
2290				//             message
2291				//            character      |           |           |           |           |           |           |           |           |
2292				if(message[a] == ' ') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;} //(Blank or space.)
2293				if(message[a] == '!') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2294				if(message[a] == '"') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2295				if(message[a] == '#') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2296				if(message[a] == '$') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2297				if(message[a] == '%') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2298				if(message[a] == '&') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2299				if(message[a] =='\'') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2300				if(message[a] == '(') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2301				if(message[a] == ')') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2302				if(message[a] == '*') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2303				if(message[a] == '+') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2304				if(message[a] == ',') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2305				if(message[a] == '-') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2306				if(message[a] == '.') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2307				if(message[a] == '/') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2308				if(message[a] == '0') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2309				if(message[a] == '1') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2310				if(message[a] == '2') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2311				if(message[a] == '3') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2312				if(message[a] == '4') {b[m]= 0;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2313				if(message[a] == '5') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2314				if(message[a] == '6') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2315				if(message[a] == '7') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2316				if(message[a] == '8') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2317				if(message[a] == '9') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2318				if(message[a] == ':') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2319				if(message[a] == ';') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2320				if(message[a] == '<') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2321				if(message[a] == '=') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2322				if(message[a] == '>') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2323				if(message[a] == '?') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2324				if(message[a] == '@') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2325				if(message[a] == 'A') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2326				if(message[a] == 'B') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2327				if(message[a] == 'C') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2328				if(message[a] == 'D') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2329				if(message[a] == 'E') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2330				if(message[a] == 'F') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2331				if(message[a] == 'G') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2332				if(message[a] == 'H') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2333				if(message[a] == 'I') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2334				if(message[a] == 'J') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2335				if(message[a] == 'K') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2336				if(message[a] == 'L') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2337				if(message[a] == 'M') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2338				if(message[a] == 'N') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2339				if(message[a] == 'O') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2340				if(message[a] == 'P') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2341				if(message[a] == 'Q') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2342				if(message[a] == 'R') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2343				if(message[a] == 'S') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2344				if(message[a] == 'T') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2345				if(message[a] == 'U') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2346				if(message[a] == 'V') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2347				if(message[a] == 'W') {b[m]= 0;  b[m+1]= 1;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2348				if(message[a] == 'X') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2349				if(message[a] == 'Y') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2350				if(message[a] == 'Z') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2351				if(message[a] == '[') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2352				if(message[a] =='\\') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2353				if(message[a] == ']') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2354				if(message[a] == '^') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2355				if(message[a] == '_') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2356				if(message[a] == '`') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2357				if(message[a] == 'a') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2358				if(message[a] == 'b') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2359				if(message[a] == 'c') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2360				if(message[a] == 'd') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2361				if(message[a] == 'e') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2362				if(message[a] == 'f') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 0;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2363				if(message[a] == 'g') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2364				if(message[a] == 'h') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2365				if(message[a] == 'i') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2366				if(message[a] == 'j') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2367				if(message[a] == 'k') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2368				if(message[a] == 'l') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2369				if(message[a] == 'm') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2370				if(message[a] == 'n') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2371				if(message[a] == 'o') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2372				if(message[a] == 'p') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 0;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2373				if(message[a] == 'q') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2374				if(message[a] == 'r') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2375				if(message[a] == 's') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2376				if(message[a] == 't') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2377				if(message[a] == 'u') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2378				if(message[a] == 'v') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2379				if(message[a] == 'w') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2380				if(message[a] == 'x') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;}
2381				if(message[a] == 'y') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2382				if(message[a] == 'z') {b[m]= 1;  b[m+1]= 0;  b[m+2]= 1;  b[m+3]= 1;  b[m+4]= 1;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 0;  b[m+8]= 0;  m+=9;continue;}
2383				if(message[a] == '{') {b[m]= 1;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 0;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2384				if(message[a] == '|') {b[m]= 1;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 0;  b[m+7]= 1;  b[m+8]= 1;  m+=9;continue;}
2385				if(message[a] == '}') {b[m]= 1;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 0;  b[m+8]= 1;  m+=9;continue;}
2386				if(message[a] == '~') {b[m]= 1;  b[m+1]= 1;  b[m+2]= 0;  b[m+3]= 0;  b[m+4]= 0;  b[m+5]= 1;  b[m+6]= 1;  b[m+7]= 1;  b[m+8]= 0;  m+=9;continue;} //This makes all 95 printable ASCII characters (but only printable.)
2387			}   //                           |           |           |           |           |           |           |           |           |
2388		}
2389		
2390		
2391		
2392		
2393		
2394		//Selectively writes old[] to Authorship.public BASED ON THE CONTENTS OF b[]. (Authorship.public is a new file created now.)
2395		out_stream.open("Authorship.public");
2396		
2397		///Solution ingredients meant to be destroyed are turned into the single character x. Example with the usual dot separators: 25467132.x.90683471
2398		///The special binary representation has already been established, now the program only writes to file Authorship.public based on b[].
2399		int old_read_bookmark = 0;
2400		for(int revelation = 0; revelation < 13500; revelation++)
2401		{	for(int a = 0; a < 12006; a++) //Writes only the function (six sub-ciphertext and the six separating dots.)
2402			{	if(old[old_read_bookmark] == 46) {out_stream << '.';}
2403				if(old[old_read_bookmark] == 48) {out_stream << '0';}
2404				if(old[old_read_bookmark] == 49) {out_stream << '1';}
2405				if(old[old_read_bookmark] == 50) {out_stream << '2';}
2406				if(old[old_read_bookmark] == 51) {out_stream << '3';}
2407				if(old[old_read_bookmark] == 52) {out_stream << '4';}
2408				if(old[old_read_bookmark] == 53) {out_stream << '5';}
2409				if(old[old_read_bookmark] == 54) {out_stream << '6';}
2410				if(old[old_read_bookmark] == 55) {out_stream << '7';}
2411				if(old[old_read_bookmark] == 56) {out_stream << '8';}
2412				if(old[old_read_bookmark] == 57) {out_stream << '9';}
2413				old_read_bookmark++;
2414			}
2415			
2416			/// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2417			if(b[revelation] == 1) ///Appends the solution ingredients to the function. //////////////////////////////////////////////////////////////////////
2418			{	for(int a = 0; a < 5; a++)
2419				{	while(old[old_read_bookmark] != '.')
2420					{	if(old[old_read_bookmark] == 48) {out_stream << '0';}
2421						if(old[old_read_bookmark] == 49) {out_stream << '1';}
2422						if(old[old_read_bookmark] == 50) {out_stream << '2';}
2423						if(old[old_read_bookmark] == 51) {out_stream << '3';}
2424						if(old[old_read_bookmark] == 52) {out_stream << '4';}
2425						if(old[old_read_bookmark] == 53) {out_stream << '5';}
2426						if(old[old_read_bookmark] == 54) {out_stream << '6';}
2427						if(old[old_read_bookmark] == 55) {out_stream << '7';}
2428						if(old[old_read_bookmark] == 56) {out_stream << '8';}
2429						if(old[old_read_bookmark] == 57) {out_stream << '9';}
2430						old_read_bookmark++;
2431					}
2432					
2433					out_stream << '.';
2434					old_read_bookmark++;
2435				}
2436			}
2437			
2438			/// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2439			else ///Skips through the solution ingredients of the function. //////////////////////////////////////////////////////////////////////////////
2440			{	for(int a = 0; a < 5; a++)
2441				{	while(old[old_read_bookmark] != '.')
2442					{	old_read_bookmark++;
2443					}
2444					
2445					old_read_bookmark++;
2446				}
2447				
2448				out_stream << 'x' << '.';
2449			}
2450		}
2451		out_stream << '\0';
2452		
2453		out_stream.close();
2454		
2455		
2456		
2457		
2458		
2459		//Overwrites RAM of old[].
2460		for(int a = 0; a < 256500000; a++)
2461		{	old[a] = 9;
2462			old[a] = 8;
2463			old[a] = 7;
2464			old[a] = 6;
2465			old[a] = 5;
2466			old[a] = 4;
2467			old[a] = 3;
2468			old[a] = 2;
2469			old[a] = 1;
2470			old[a] = 0;
2471		}
2472		
2473		//Overwrites RAM of Authorship_private[].
2474		for(int a = 0; a < 256500000; a++)
2475		{	Authorship_private[a] = 9;
2476			Authorship_private[a] = 8;
2477			Authorship_private[a] = 7;
2478			Authorship_private[a] = 6;
2479			Authorship_private[a] = 5;
2480			Authorship_private[a] = 4;
2481			Authorship_private[a] = 3;
2482			Authorship_private[a] = 2;
2483			Authorship_private[a] = 1;
2484			Authorship_private[a] = 0;
2485		}
2486		
2487		
2488		
2489		for(int a = 0; a < 100; a++)
2490		{	cout << temp_compression_119[a];
2491		}
2492		
2493		cout << "\n\n\nFinished.\n\n\n";
2494		
2495		cout << "Authorship.private has been overwritten with your new keys.\n";
2496		cout << "Cache them guardedly and destroy the old copy file.\n\n";
2497		
2498		cout << "Authorship.public resides in this directory. Publish it and the\n";
2499		cout << "verifying party will extract your new number from that file.\n";
2500		cout << "Once they have your new number, they can discard any old numbers\n";
2501		cout << "and keys you have published in the past.\n\n";
2502		
2503		cout << "Your new number is printed above incase some verifying party\n";
2504		cout << "had lost your number or began verifying at a later time.\n\n\n";
2505	}
2506	
2507	
2508	
2509	
2510	
2511	//________________________________________________________________________________________________________________________
2512	//                                                                                                                       |
2513	//                                         3   Verifiy number modification                                               |
2514	//_______________________________________________________________________________________________________________________|
2515	if(user_option == 3)
2516	{	//Basic layout:
2517		//1. Reads file Authirship.public then generates the compression.
2518		//2. Reads file Authorship.number and compares it to the compression from step 1. Fails if mismatch.
2519		//3. Tests the transformation determinants, keys, key transformations, and primes of the file in step 1. Fails on error.
2520		//4. Extracts the new number & message from the file in step 1 and tests for additional properties. Fails on error.
2521		//5. Writes the number to now-created file Authorship.number.
2522		//This part of the program is spaced out more-so than previously for extra clarity--as this part is more sensitive than options 1 and 2.
2523		
2524		cout << "\n>>>>>>>>>>>>>>>>>>>>>>>>>>(Verify number modification)<<<<<<<<<<<<<<<<<<<<<<<<<<\n";
2525		cout << "Place COPIES the following two files in this directory if not already here.\n\n";
2526		
2527		cout << "    Authorship.number  (User's number as saved on your device.)\n";
2528		cout << "    Authorship.public  (User's published file as downloaded on your device.)\n\n";
2529		
2530		cout << "Continue? y/n: ";
2531		char wait;
2532		cin >> wait;
2533		if(wait != 'y') {return 0;}
2534		
2535		
2536		
2537		
2538		
2539		//Loads Authorship.public into Authorship_public[].
2540		static char Authorship_public[220000000];
2541		ifstream in_stream;
2542		in_stream.open("Authorship.public");
2543		
2544		for(int a = 0; a < 220000000; a++)
2545		{	in_stream >> Authorship_public[a];
2546			if(Authorship_public[a] == '\0') {break;}
2547		}
2548		
2549		in_stream.close();
2550		
2551		for(int a = 0; Authorship_public[a] != '\0'; a++) //Converts Authorship_public[] items to numerical values ('x' and '.' excluded.)
2552		{	if(Authorship_public[a] == 48) {Authorship_public[a] = 0;}
2553			if(Authorship_public[a] == 49) {Authorship_public[a] = 1;}
2554			if(Authorship_public[a] == 50) {Authorship_public[a] = 2;}
2555			if(Authorship_public[a] == 51) {Authorship_public[a] = 3;}
2556			if(Authorship_public[a] == 52) {Authorship_public[a] = 4;}
2557			if(Authorship_public[a] == 53) {Authorship_public[a] = 5;}
2558			if(Authorship_public[a] == 54) {Authorship_public[a] = 6;}
2559			if(Authorship_public[a] == 55) {Authorship_public[a] = 7;}
2560			if(Authorship_public[a] == 56) {Authorship_public[a] = 8;}
2561			if(Authorship_public[a] == 57) {Authorship_public[a] = 9;}
2562		}
2563		
2564		
2565		
2566		
2567		
2568		//The following block-bunch generates the compression.
2569		//The following guardians must ALL sing "true" before the verifying party gets the message "Verification SUCCESSFUL!"
2570		//These guardians exist for exceptional clarity and safety in the many diverse devices who may run the Authorship program.
2571		//Any errors or mismatch in the verification process IMMEDIATELY ends the program with the message "Verification FAILED!"
2572		//This ensures that false authentication events are terminated here long before any chance of sliding under additional guardians.
2573		//Guardians may be controlled by external means at any moment, by accident in overflow or with clever attacks.
2574		//Guardians sing "false" by default. (Sensitive software means safety first!)
2575		bool comparison = false; //The extracted number must match the provided number.
2576		bool keys       = false; //Keys, transformation determinants, key transformations, and prime lengths must satisfy 5/9 of 13,500 functions.
2577		bool digits     = false; //The first 500 groups of nine contiguous functions must correspond to digit pair assignment.
2578		bool characters = false; //The remainig 1,000 groups of nine contiguous functions must correspond to character assignment.
2579		
2580		//Those who wish to harm and slow down some currency circulation or whatever Authorship system, might exhaustively publish Authorship.public
2581		//files who must receive acceptance by large communities using old hardware. This is just another reason to have early fault detection
2582		//as the file is read, however, it seems no elegant solutions exist and so the file Authorship.public is read whole before being processed.
2583		//This is a waste of time and resources since most machines download and read content slowly which becomes problematic with serious quantity.
2584		//Consider generating deductive lossy compression of the first few functions, then overwriting that to a few integers in the final number.
2585		//Then, while reading the file, if its first few functions produce certain integers who match those in a list of Authorship numbers, file
2586		//reading continues. Attackers can place highly curated faulty files to do just that and get away with wasting the time it takes your machine
2587		//to read and verify the remaining 207.0999MB. But let's get clever. Suppose the first string read from the file contains a cryptographic key
2588		//who unlocks a portion of some number in a public list. Certainly, you can halt reading faulty files without a correct key. In fact, you can
2589		//even halt the download early as you can process dowloaded data sequentially. Surprisingly, this is not a solution still. And given the
2590		//untraceable and anonymous capabilities of Authorship, you can bet that any and all systems will utilize those capabilities--which makes it
2591		//impossible to know who's uploading the garbage. And just as they are free to sabotage, you are free to hunt them down. Attackers will take
2592		//advantage of the high traffic in such systems--machines just can't get to every file as soon as it's released. And so the key strings who are
2593		//first in the files can be inserted into their faulty files. Now let's go even further--combine the cryptographic key guard with the compression
2594		//in the first considerstion. This helps pin-point which number the file inquires to modify, however, the remaining file content could be faulty
2595		//for the purpose of wasting time as the genuine file could have been automatically curated by machines looking through the published
2596		//Authorship.public files. This adds garbage to the pile yet the pile must be processed. Please solve for x and let me know.
2597		
2598		//These declarations are for deductive lossy compression, they produce the Authorship number dynamically.
2599		long long int compression_115[100]; //Hops by -115
2600		long long int snapshot_115[100]; //Takes a snapshot of compression_115[] every once in a while.
2601		
2602		long long int compression_116[100]; //Hops by -116
2603		long long int snapshot_116[100]; //Takes a snapshot of compression_116[] every once in a while.
2604		
2605		long long int compression_117[100]; //Hops by -117
2606		long long int snapshot_117[100]; //Takes a snapshot of compression_117[] every once in a while.
2607		
2608		long long int compression_118[100]; //Hops by -118
2609		long long int snapshot_118[100]; //Takes a snapshot of compression_118[] every once in a while.
2610		
2611		long long int compression_119[100]; //Hops by -119
2612		long long int snapshot_119[100]; //Takes a snapshot of compression_119[] every once in a while.
2613		
2614		for(int a = 0; a < 100; a++)
2615		{	compression_115[a] = 5555555555;
2616			snapshot_115[a] = 5555555555;
2617			
2618			compression_116[a] = 5555555555;
2619			snapshot_116[a] = 5555555555;
2620			
2621			compression_117[a] = 5555555555;
2622			snapshot_117[a] = 5555555555;
2623			
2624			compression_118[a] = 5555555555;
2625			snapshot_118[a] = 5555555555;
2626			
2627			compression_119[a] = 5555555555;
2628			snapshot_119[a] = 5555555555;
2629		}
2630		
2631		//Generates compression
2632		int read_bookmark = 0;
2633		for(int f = 0; f < 13500; f++) //Chronologically reads through 13,500 functions in Authorship_public.
2634		{	read_bookmark += 12006;
2635			
2636			compression_119[0] += compression_119[99];
2637			compression_119[0] %= 10000000000;
2638			
2639			int temp_read_bookmark;
2640			temp_read_bookmark = (read_bookmark - 2);
2641			
2642			for(int a = 0; a < 100; a++)
2643			{	compression_115[a] += Authorship_public[temp_read_bookmark];
2644				compression_115[a] *= 5;
2645				compression_115[a] %= 10000000000;
2646				temp_read_bookmark -= 115;
2647			}
2648			temp_read_bookmark = (read_bookmark - 2); //Resetting the temporary variable.
2649			
2650			for(int a = 0; a < 100; a++)
2651			{	compression_116[a] += Authorship_public[temp_read_bookmark];
2652				compression_116[a] *= 6;
2653				compression_116[a] %= 10000000000;
2654				temp_read_bookmark -= 116;
2655			}
2656			temp_read_bookmark = (read_bookmark - 2); //Resetting the temporary variable.
2657			
2658			for(int a = 0; a < 100; a++)
2659			{	compression_117[a] += Authorship_public[temp_read_bookmark];
2660				compression_117[a] *= 7;
2661				compression_117[a] %= 10000000000;
2662				temp_read_bookmark -= 117;
2663			}
2664			temp_read_bookmark = (read_bookmark - 2); //Resetting the temporary variable.
2665			
2666			for(int a = 0; a < 100; a++)
2667			{	compression_118[a] += Authorship_public[temp_read_bookmark];
2668				compression_118[a] *= 8;
2669				compression_118[a] %= 10000000000;
2670				temp_read_bookmark -= 118;
2671			}
2672			temp_read_bookmark = (read_bookmark - 2); //Resetting the temporary variable.
2673			
2674			for(int a = 0; a < 100; a++)
2675			{	compression_119[a] += Authorship_public[temp_read_bookmark];
2676				compression_119[a] *= 9;
2677				compression_119[a] %= 10000000000;
2678				temp_read_bookmark -= 119;
2679			}
2680			
2681			//Compression snapshots are active in early stages of Authorship number evolution. They are applied to the compression in the end.
2682			if((f == 1000) || (f == 2000) || (f == 3000) || (f == 4000) || (f == 5000) || (f == 6000) || (f == 7000) || (f == 8000))
2683			{	for(int a = 0; a < 100; a++)
2684				{	snapshot_115[a] += compression_115[a];
2685					snapshot_115[a] %= 10000000000; //(10^10, results in last ten digits shown.)
2686					
2687					snapshot_116[a] += compression_116[a];
2688					snapshot_116[a] %= 10000000000;
2689					
2690					snapshot_117[a] += compression_117[a];
2691					snapshot_117[a] %= 10000000000;
2692					
2693					snapshot_118[a] += compression_118[a];
2694					snapshot_118[a] %= 10000000000;
2695					
2696					snapshot_119[a] += compression_119[a];
2697					snapshot_119[a] %= 10000000000;
2698				}
2699			}
2700			
2701			if(Authorship_public[read_bookmark] == 'x')
2702			{	read_bookmark += 2;
2703			}
2704			
2705			else
2706			{	for(int a = 0; a < 5; a++)
2707				{	while(Authorship_public[read_bookmark] != '.')
2708					{	read_bookmark++;
2709					}
2710					
2711					read_bookmark++;
2712				}
2713			}
2714		}
2715		
2716		//Constructively combines the comression tables. compression_119[] will hold it all.
2717		for(int a = 0; a < 100; a++)
2718		{	compression_119[a] += compression_115[a];
2719			if((compression_119[a] % 2) == 0) {compression_119[a] *= 2;}
2720			
2721			compression_119[a] += compression_116[a];
2722			if((compression_119[a] % 2) == 0) {compression_119[a] *= 3;}
2723			
2724			compression_119[a] += compression_117[a];
2725			if((compression_119[a] % 2) == 0) {compression_119[a] *= 5;}
2726			
2727			compression_119[a] += compression_118[a];
2728			if((compression_119[a] % 2) == 0) {compression_119[a] *= 7;}
2729			
2730			compression_119[a] %= 10000000000; //(10^10, results in last ten digits shown.)
2731		}
2732		
2733		//Constructively combines the snapshot tables. snapshot_119[] will hold it all.
2734		for(int a = 0; a < 100; a++)
2735		{	snapshot_119[a] += snapshot_115[a];
2736			if((snapshot_119[a] % 2) == 0) {snapshot_119[a] *= 2;}
2737			
2738			snapshot_119[a] += snapshot_116[a];
2739			if((snapshot_119[a] % 2) == 0) {snapshot_119[a] *= 3;}
2740			
2741			snapshot_119[a] += snapshot_117[a];
2742			if((snapshot_119[a] % 2) == 0) {snapshot_119[a] *= 5;}
2743			
2744			snapshot_119[a] += snapshot_118[a];
2745			if((snapshot_119[a] % 2) == 0) {snapshot_119[a] *= 7;}
2746			
2747			snapshot_119[a] %= 10000000000; //(10^10, results in last ten digits shown.)
2748		}
2749		
2750		//Applies the snapshots to the last stage in compression. (As the Authorship number evolved over time, snapshots made a record of its early stages.)
2751		for(int a = 0; a < 100; a++)
2752		{	compression_119[a] += snapshot_119[a];
2753			compression_119[a] %= 10000000000; //(10^10, results in last ten digits shown.)
2754		}
2755		
2756		for(int a = 0; a < 100; a++) //Ensures each constituent compression integer is 10 digits long. The Authorship number is now complete.
2757		{	if(compression_119[a] < 1000000000)
2758			{	compression_119[a] += 1000000000;
2759			}
2760		}
2761		
2762		//The following block-bunch compares the generated number with the given number.
2763		//Converts the here-generated number (100 integers in compression_119[]) to type array for loading into compression[].
2764		int compression[1000] = {0};
2765		int compression_write_bookmark = 0;
2766		for(int a = 0; a < 100; a++)
2767		{	compression[compression_write_bookmark] =  (compression_119[a] / 1000000000);
2768			compression_write_bookmark++;
2769			compression[compression_write_bookmark] = ((compression_119[a] / 100000000) % 10);
2770			compression_write_bookmark++;
2771			compression[compression_write_bookmark] = ((compression_119[a] / 10000000) % 10);
2772			compression_write_bookmark++;
2773			compression[compression_write_bookmark] = ((compression_119[a] / 1000000) % 10);
2774			compression_write_bookmark++;
2775			compression[compression_write_bookmark] = ((compression_119[a] / 100000) % 10);
2776			compression_write_bookmark++;
2777			compression[compression_write_bookmark] = ((compression_119[a] / 10000) % 10);
2778			compression_write_bookmark++;
2779			compression[compression_write_bookmark] = ((compression_119[a] / 1000) % 10);
2780			compression_write_bookmark++;
2781			compression[compression_write_bookmark] = ((compression_119[a] / 100) % 10);
2782			compression_write_bookmark++;
2783			compression[compression_write_bookmark] = ((compression_119[a] / 10) % 10);
2784			compression_write_bookmark++;
2785			compression[compression_write_bookmark] =  (compression_119[a]      % 10);
2786			compression_write_bookmark++;
2787		}
2788		
2789		//Loads file Authorship.number into Authorship_number[].
2790		char Authorship_number[1000];
2791		in_stream.open("Authorship.number");
2792		
2793		for(int a = 0; a < 1000; a++)
2794		{	in_stream >> Authorship_number[a];
2795			if(Authorship_number[a] == 48) {Authorship_number[a] = 0;} //(Loaded ASCII characters from file) so converting them to our familiar numbers!
2796			if(Authorship_number[a] == 49) {Authorship_number[a] = 1;} //Look to the ASCII table & character assignment in option 2.
2797			if(Authorship_number[a] == 50) {Authorship_number[a] = 2;}
2798			if(Authorship_number[a] == 51) {Authorship_number[a] = 3;}
2799			if(Authorship_number[a] == 52) {Authorship_number[a] = 4;}
2800			if(Authorship_number[a] == 53) {Authorship_number[a] = 5;}
2801			if(Authorship_number[a] == 54) {Authorship_number[a] = 6;}
2802			if(Authorship_number[a] == 55) {Authorship_number[a] = 7;}
2803			if(Authorship_number[a] == 56) {Authorship_number[a] = 8;}
2804			if(Authorship_number[a] == 57) {Authorship_number[a] = 9;}
2805		}
2806		
2807		in_stream.close();
2808		
2809		//Compares the given number with the generated number.
2810		bool existence_after_comparison = false;
2811		for(int a = 0; a < 1000; a++)
2812		{	if(compression[a] != Authorship_number[a]) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;}
2813			
2814			if(a == 999) {existence_after_comparison = true;} //Is set to true if and only if comparison succeeds to the last iteration
2815		}                                                     //where each and every test would end the program on mismatch.
2816		
2817		
2818		
2819		
2820		
2821		///The following block-bunch tests the transformation determinants, sub-keys and their five transformations, and the
2822		///hot zones. (Testing only the functions to which solution ingredients are included in the file Authorship.public.)
2823		//This is a boolean sieve of Eratosthenes. Zeros are prime, conveniently mapped to their element index. (It is used here like the following
2824		//example: if(sieve[my_candidate] == 0) then my_candidate is prime.)
2825		bool sieve[100000] = {1, 1};
2826		for(int prime = 2; prime < 317; prime++) //317 is sqrt(100000)
2827		{	for(int a = prime + prime; a < 100000; a += prime) {sieve[a] = 1;}
2828		}
2829		
2830		int read_bookmark_crypt = 0; //Reads from Authorship_public[] but for the purpose of testing solition ingredients.
2831		bool existence_after_keys = false;
2832		for(int f = 0; f < 13500; f++) //Chronologically reads through 13,500 functions in Authorship_public[]. This for loop contains three items.
2833		{	if(Authorship_public[read_bookmark_crypt + 12006] == 'x') ///If no solution ingredients, skips to the contiguous function ahead.
2834			{	read_bookmark_crypt += 12008;                         /// //////////////////////////////////////////////////////////////////
2835			}
2836			
2837			else ///If solution ingredients are present, they are tested against the current function.
2838			{	 /// /////////////////////////////////////////////////////////////////////////////////
2839				//Reads & grabs the ciphertext, transformation determinant, first sub-key, and the prime-lengths-in-order (identifying properties.)
2840				int sub_ciphertext_SUB2[2000];
2841				int sub_ciphertext_SUB4[2000];
2842				int sub_ciphertext_SUB6[2000];
2843				
2844				int transformation_determinant[2000];
2845				int sub_key[2000];
2846				int prime_lengths_in_order_SUB2[1000] = {0};
2847				int prime_lengths_in_order_SUB4[1000] = {0};
2848				int prime_lengths_in_order_SUB6[1000] = {0};
2849				
2850				for(int a = 0; a < 2000; a++) {read_bookmark_crypt++;} //Skips through 1st sub-ciphertext.
2851				read_bookmark_crypt++;
2852				
2853				for(int a = 0; a < 2000; a++) //Loads sub_ciphertext_SUB2[].
2854				{	sub_ciphertext_SUB2[a] = Authorship_public[read_bookmark_crypt];
2855					read_bookmark_crypt++;
2856				}
2857				read_bookmark_crypt++;
2858				
2859				for(int a = 0; a < 2000; a++) {read_bookmark_crypt++;} //Skips through 3rd sub-ciphertext.
2860				read_bookmark_crypt++;
2861				
2862				for(int a = 0; a < 2000; a++) //Loads sub_ciphertext_SUB4[].
2863				{	sub_ciphertext_SUB4[a] = Authorship_public[read_bookmark_crypt];
2864					read_bookmark_crypt++;
2865				}
2866				read_bookmark_crypt++;
2867				
2868				for(int a = 0; a < 2000; a++) {read_bookmark_crypt++;} //Skips through 5th sub-ciphertext.
2869				read_bookmark_crypt++;
2870				
2871				for(int a = 0; a < 2000; a++) //Loads sub_ciphertext_SUB6[].
2872				{	sub_ciphertext_SUB6[a] = Authorship_public[read_bookmark_crypt];
2873					read_bookmark_crypt++;
2874				}
2875				read_bookmark_crypt++;
2876				
2877				for(int a = 0; a < 2000; a++) //Loads transformation_determinant[].
2878				{	transformation_determinant[a] = Authorship_public[read_bookmark_crypt];
2879					read_bookmark_crypt++;
2880				}
2881				read_bookmark_crypt++;
2882				
2883				for(int a = 0; a < 2000; a++) //Loads sub_key[].
2884				{	sub_key[a] = Authorship_public[read_bookmark_crypt];
2885					read_bookmark_crypt++;
2886				}
2887				read_bookmark_crypt++;
2888				
2889				for(int a = 0; Authorship_public[read_bookmark_crypt] != '.'; a++) //Loads prime_lengths_in_order_SUB2[].
2890				{	prime_lengths_in_order_SUB2[a] = Authorship_public[read_bookmark_crypt];
2891					read_bookmark_crypt++;
2892				}
2893				read_bookmark_crypt++;
2894				
2895				for(int a = 0; Authorship_public[read_bookmark_crypt] != '.'; a++) //Loads prime_lengths_in_order_SUB4[].
2896				{	prime_lengths_in_order_SUB4[a] = Authorship_public[read_bookmark_crypt];
2897					read_bookmark_crypt++;
2898				}
2899				read_bookmark_crypt++;
2900				
2901				for(int a = 0; Authorship_public[read_bookmark_crypt] != '.'; a++) //Loads prime_lengths_in_order_SUB6[].
2902				{	prime_lengths_in_order_SUB6[a] = Authorship_public[read_bookmark_crypt];
2903					read_bookmark_crypt++;
2904				}
2905				read_bookmark_crypt++;
2906				
2907				
2908				
2909				
2910				
2911				//Now that the function and its solution ingredients have been loaded, the testing begins.
2912				//The sub-key is transformed once for sub-function 2.
2913				for(int a = 0; a < 1999; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 2.)
2914				{	sub_key[a] += transformation_determinant[a];
2915					sub_key[a] = ((sub_key[a] + transformation_determinant[a + 1]) % 10); //[a + 1] means do up to 1998 or seg fault.
2916				}
2917				sub_key[1999] = ((sub_key[1999] + transformation_determinant[1000]) % 10); //Last element was not transformed so here it is.
2918				//(1st of 5 total transformations per function.) Each one is different.
2919				
2920				
2921				
2922				
2923				
2924				//Generates 2nd sub-plaintext (hot zone) through deductive reasoning since the key
2925				//and output are present. The following formula helps extract plaintext quickly.
2926				//      ______________________________________________ ________________________________________________
2927				//     |                                              |                                                |
2928				//     |          if sub-key <= ciphertext            |                     else                       |
2929				//     |   then plaintext = (ciphertext - sub-key)    |    plaintext = ((10 - sub-key) + ciphertext)   |
2930				//     |______________________________________________|________________________________________________|
2931				//
2932				int sub_plaintext_SUB2[2000];
2933				for(int a = 0; a < 2000; a++)
2934				{	if(sub_key[a] <= sub_ciphertext_SUB2[a]) {sub_plaintext_SUB2[a] = (sub_ciphertext_SUB2[a] - sub_key[a]);}
2935					else {sub_plaintext_SUB2[a] = ((10 - sub_key[a]) + sub_ciphertext_SUB2[a]);}
2936				}
2937				
2938				
2939				
2940				
2941				
2942				//Checks if sub_ciphertext_SUB2[] is composed entirely of whatever quantity of contiguous primes of digit lengths one to five.
2943				int read_bookmark_sub_plaintext_SUB2 = 0;
2944				for(int assembled_candidate, a = 0; prime_lengths_in_order_SUB2[a] > 0; a++) //(prime_lengths_in_order[] contains positive integers 1-5 then all zeros.)
2945				{	if(prime_lengths_in_order_SUB2[a] == 1) //If expected prime length is 1, grabs 1 digit from sub_plaintext_SUB2[].
2946					{	assembled_candidate = sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2];
2947						
2948						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
2949						read_bookmark_sub_plaintext_SUB2++;
2950					}
2951					
2952					if(prime_lengths_in_order_SUB2[a] == 2) //If expected prime length is 2, assembles 2-digit integer from 2 elements in sub_plaintext_SUB2[].
2953					{	assembled_candidate = sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2];
2954						assembled_candidate *= 10;
2955						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 1];
2956						
2957						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
2958						read_bookmark_sub_plaintext_SUB2 += 2;
2959					}
2960					
2961					if(prime_lengths_in_order_SUB2[a] == 3) //If expected prime length is 3, assembles 3-digit integer from 3 elements in sub_plaintext_SUB2[].
2962					{	assembled_candidate = sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2];
2963						assembled_candidate *= 10;
2964						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 1];
2965						assembled_candidate *= 10;
2966						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 2];
2967						
2968						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
2969						read_bookmark_sub_plaintext_SUB2 += 3;
2970					}
2971					
2972					if(prime_lengths_in_order_SUB2[a] == 4) //If expected prime length is 4, assembles 4-digit integer from 4 elements in sub_plaintext_SUB2[].
2973					{	assembled_candidate = sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2];
2974						assembled_candidate *= 10;
2975						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 1];
2976						assembled_candidate *= 10;
2977						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 2];
2978						assembled_candidate *= 10;
2979						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 3];
2980						
2981						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
2982						read_bookmark_sub_plaintext_SUB2 += 4;
2983					}
2984					
2985					if(prime_lengths_in_order_SUB2[a] == 5) //If expected prime length is 5, assembles 5-digit integer from 5 elements in sub_plaintext_SUB2[].
2986					{	assembled_candidate = sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2];
2987						assembled_candidate *= 10;
2988						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 1];
2989						assembled_candidate *= 10;
2990						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 2];
2991						assembled_candidate *= 10;
2992						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 3];
2993						assembled_candidate *= 10;
2994						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 4];
2995						
2996						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
2997						read_bookmark_sub_plaintext_SUB2 += 5;
2998					}
2999				}
3000				
3001				
3002				
3003				
3004				
3005				for(int a = 0; a < 1998; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 3.)
3006				{	sub_key[a] += transformation_determinant[a];
3007					sub_key[a] = ((sub_key[a] + transformation_determinant[a + 2]) % 10); //[a + 2] means do up to 1997 or seg fault.
3008				}
3009				sub_key[1998] = ((sub_key[1998] + transformation_determinant[1005]) % 10); //Last two elements were not transformed so here it is.
3010				sub_key[1999] = ((sub_key[1999] + transformation_determinant[1010]) % 10);
3011				//(2nd of 5 total transformations per function.) Each one is different.
3012				//
3013				//
3014				//		(Since only the hot zones are checked, transformation continues in preparation for the next hot zone.)
3015				//
3016				//
3017				for(int a = 0; a < 1997; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 4.)
3018				{	sub_key[a] += transformation_determinant[a];
3019					sub_key[a] = ((sub_key[a] + transformation_determinant[a + 3]) % 10); //[a + 3] means do up to 1996 or seg fault.
3020				}
3021				sub_key[1997] = ((sub_key[1997] + transformation_determinant[1015]) % 10); //Last three elements were not transformed so here it is.
3022				sub_key[1998] = ((sub_key[1998] + transformation_determinant[1020]) % 10);
3023				sub_key[1999] = ((sub_key[1999] + transformation_determinant[1025]) % 10);
3024				//(3rd of 5 total transformations per function.) Each one is different.
3025				
3026				
3027				
3028				
3029				
3030				//Generates 4th sub-plaintext (hot zone) through deductive reasoning since the key
3031				//and output are present. The following formula helps extract plaintext quickly.
3032				//      ______________________________________________ ________________________________________________
3033				//     |                                              |                                                |
3034				//     |          if sub-key <= ciphertext            |                     else                       |
3035				//     |   then plaintext = (ciphertext - sub-key)    |    plaintext = ((10 - sub-key) + ciphertext)   |
3036				//     |______________________________________________|________________________________________________|
3037				//
3038				int sub_plaintext_SUB4[2000];
3039				for(int a = 0; a < 2000; a++)
3040				{	if(sub_key[a] <= sub_ciphertext_SUB4[a]) {sub_plaintext_SUB4[a] = (sub_ciphertext_SUB4[a] - sub_key[a]);}
3041					else {sub_plaintext_SUB4[a] = ((10 - sub_key[a]) + sub_ciphertext_SUB4[a]);}
3042				}
3043				
3044				
3045				
3046				
3047				
3048				//Checks if sub_ciphertext_SUB4[] is composed entirely of whatever quantity of contiguous primes of digit lengths one to five.
3049				int read_bookmark_sub_plaintext_SUB4 = 0;
3050				for(int assembled_candidate, a = 0; prime_lengths_in_order_SUB4[a] > 0; a++) //(prime_lengths_in_order[] contains positive integers 1-5 then all zeros.)
3051				{	if(prime_lengths_in_order_SUB4[a] == 1) //If expected prime length is 1, grabs 1 digit from sub_plaintext_SUB4[].
3052					{	assembled_candidate = sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4];
3053						
3054						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3055						read_bookmark_sub_plaintext_SUB4++;
3056					}
3057					
3058					if(prime_lengths_in_order_SUB4[a] == 2) //If expected prime length is 2, assembles 2-digit integer from 2 elements in sub_plaintext_SUB4[].
3059					{	assembled_candidate = sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4];
3060						assembled_candidate *= 10;
3061						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 1];
3062						
3063						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3064						read_bookmark_sub_plaintext_SUB4 += 2;
3065					}
3066					
3067					if(prime_lengths_in_order_SUB4[a] == 3) //If expected prime length is 3, assembles 3-digit integer from 3 elements in sub_plaintext_SUB4[].
3068					{	assembled_candidate = sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4];
3069						assembled_candidate *= 10;
3070						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 1];
3071						assembled_candidate *= 10;
3072						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 2];
3073						
3074						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3075						read_bookmark_sub_plaintext_SUB4 += 3;
3076					}
3077					
3078					if(prime_lengths_in_order_SUB4[a] == 4) //If expected prime length is 4, assembles 4-digit integer from 4 elements in sub_plaintext_SUB4[].
3079					{	assembled_candidate = sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4];
3080						assembled_candidate *= 10;
3081						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 1];
3082						assembled_candidate *= 10;
3083						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 2];
3084						assembled_candidate *= 10;
3085						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 3];
3086						
3087						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3088						read_bookmark_sub_plaintext_SUB4 += 4;
3089					}
3090					
3091					if(prime_lengths_in_order_SUB4[a] == 5) //If expected prime length is 5, assembles 5-digit integer from 5 elements in sub_plaintext_SUB4[].
3092					{	assembled_candidate = sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4];
3093						assembled_candidate *= 10;
3094						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 1];
3095						assembled_candidate *= 10;
3096						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 2];
3097						assembled_candidate *= 10;
3098						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 3];
3099						assembled_candidate *= 10;
3100						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 4];
3101						
3102						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3103						read_bookmark_sub_plaintext_SUB4 += 5;
3104					}
3105				}
3106				
3107				
3108				
3109				
3110				
3111				for(int a = 0; a < 1996; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 5.)
3112				{	sub_key[a] += transformation_determinant[a];
3113					sub_key[a] = ((sub_key[a] + transformation_determinant[a + 4]) % 10); //[a + 4] means do up to 1995 or seg fault.
3114				}
3115				sub_key[1996] = ((sub_key[1996] + transformation_determinant[1030]) % 10); //Last four elements were not transformed so here it is.
3116				sub_key[1997] = ((sub_key[1997] + transformation_determinant[1035]) % 10);
3117				sub_key[1998] = ((sub_key[1998] + transformation_determinant[1040]) % 10);
3118				sub_key[1999] = ((sub_key[1999] + transformation_determinant[1045]) % 10);
3119				//(4th of 5 total transformations per function.) Each one is different.
3120				//
3121				//
3122				//		(Since only the hot zones are checked, transformation continues in preparation for the next hot zone.)
3123				//
3124				//
3125				for(int a = 0; a < 1995; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 6.)
3126				{	sub_key[a] += transformation_determinant[a];
3127					sub_key[a] = ((sub_key[a] + transformation_determinant[a + 5]) % 10); //[a + 5] means do up to 1994 or seg fault.
3128				}
3129				sub_key[1995] = ((sub_key[1995] + transformation_determinant[1050]) % 10); //Last five elements were not transformed so here it is.
3130				sub_key[1996] = ((sub_key[1996] + transformation_determinant[1055]) % 10);
3131				sub_key[1997] = ((sub_key[1997] + transformation_determinant[1060]) % 10);
3132				sub_key[1998] = ((sub_key[1998] + transformation_determinant[1065]) % 10);
3133				sub_key[1999] = ((sub_key[1999] + transformation_determinant[1070]) % 10);
3134				//(5th of 5 total transformations per function.) Each one is different.
3135				
3136				
3137				
3138				
3139				
3140				//Generates 6th sub-plaintext (hot zone) through deductive reasoning since the key
3141				//and output are present. The following formula helps extract plaintext quickly.
3142				//      ______________________________________________ ________________________________________________
3143				//     |                                              |                                                |
3144				//     |          if sub-key <= ciphertext            |                     else                       |
3145				//     |   then plaintext = (ciphertext - sub-key)    |    plaintext = ((10 - sub-key) + ciphertext)   |
3146				//     |______________________________________________|________________________________________________|
3147				//
3148				int sub_plaintext_SUB6[2000];
3149				for(int a = 0; a < 2000; a++)
3150				{	if(sub_key[a] <= sub_ciphertext_SUB6[a]) {sub_plaintext_SUB6[a] = (sub_ciphertext_SUB6[a] - sub_key[a]);}
3151					else {sub_plaintext_SUB6[a] = ((10 - sub_key[a]) + sub_ciphertext_SUB6[a]);}
3152				}
3153				
3154				
3155				
3156				
3157				
3158				//Checks if sub_ciphertext_SUB6[] is composed entirely of whatever quantity of contiguous primes of digit lengths one to five.
3159				int read_bookmark_sub_plaintext_SUB6 = 0;
3160				for(int assembled_candidate, a = 0; prime_lengths_in_order_SUB6[a] > 0; a++) //(prime_lengths_in_order[] contains positive integers 1-5 then all zeros.)
3161				{	if(prime_lengths_in_order_SUB6[a] == 1) //If expected prime length is 1, grabs 1 digit from sub_plaintext_SUB6[].
3162					{	assembled_candidate = sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6];
3163						
3164						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3165						read_bookmark_sub_plaintext_SUB6++;
3166					}
3167					
3168					if(prime_lengths_in_order_SUB6[a] == 2) //If expected prime length is 2, assembles 2-digit integer from 2 elements in sub_plaintext_SUB6[].
3169					{	assembled_candidate = sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6];
3170						assembled_candidate *= 10;
3171						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 1];
3172						
3173						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3174						read_bookmark_sub_plaintext_SUB6 += 2;
3175					}
3176					
3177					if(prime_lengths_in_order_SUB6[a] == 3) //If expected prime length is 3, assembles 3-digit integer from 3 elements in sub_plaintext_SUB6[].
3178					{	assembled_candidate = sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6];
3179						assembled_candidate *= 10;
3180						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 1];
3181						assembled_candidate *= 10;
3182						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 2];
3183						
3184						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3185						read_bookmark_sub_plaintext_SUB6 += 3;
3186					}
3187					
3188					if(prime_lengths_in_order_SUB6[a] == 4) //If expected prime length is 4, assembles 4-digit integer from 4 elements in sub_plaintext_SUB6[].
3189					{	assembled_candidate = sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6];
3190						assembled_candidate *= 10;
3191						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 1];
3192						assembled_candidate *= 10;
3193						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 2];
3194						assembled_candidate *= 10;
3195						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 3];
3196						
3197						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3198						read_bookmark_sub_plaintext_SUB6 += 4;
3199					}
3200					
3201					if(prime_lengths_in_order_SUB6[a] == 5) //If expected prime length is 5, assembles 5-digit integer from 5 elements in sub_plaintext_SUB6[].
3202					{	assembled_candidate = sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6];
3203						assembled_candidate *= 10;
3204						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 1];
3205						assembled_candidate *= 10;
3206						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 2];
3207						assembled_candidate *= 10;
3208						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 3];
3209						assembled_candidate *= 10;
3210						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 4];
3211						
3212						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3213						read_bookmark_sub_plaintext_SUB6 += 5;
3214					}
3215				}
3216			}
3217			
3218			//You might wonder why then even include cool zones in the Authorship files
3219			//if they hold only random plaintext, and are excluded in the key_pass test.
3220			//The ciphertext is produced via (sub_key[a] + plaintext[a]) mod 10.
3221			//Cool zones utilize random numbers for their plaintext which are then
3222			//reproduced exactly and as expected. This leaves quite the space
3223			//for those who need to stuff as much data into these files as possible.
3224			//And everyone's file being ~207MB, who inserted data and who didn't?
3225			
3226			//The read/write_bookmarks and little templates make editing a breeze.
3227			//Authorship provides these subtle expansion possibilities--awaiting
3228			//the many problems and needs of heroes yet to come.
3229			
3230			if(f == 13499) {existence_after_keys = true;} //Is set to true if and only if the testing of these items succeeds to the last iteration.
3231		}
3232		
3233		
3234		
3235		
3236		
3237		//The following block-bunch extracts the new number & message, and tests the symbol assignments and correspondence to 5/9.
3238		bool b[13500]; //b for binary, will hold the final binary super-string.
3239		
3240		int zeros_counter = 0; //6,000 functions of 13,500 must remain unsolved.  (4/9)
3241		int ones_counter = 0;  //7,500 functions of 13,500 must be solved.        (5/9)
3242		
3243		int read_bookmark_symbol = 0;
3244		for(int f = 0; f < 13500; f++) //Flies over the functions and looks for the .x. markers.
3245		{	read_bookmark_symbol += 12006;
3246			
3247			if(Authorship_public[read_bookmark_symbol] == 'x')
3248			{	b[f] = 0;
3249				zeros_counter++;
3250				
3251				read_bookmark_symbol += 2;
3252			}
3253			
3254			else
3255			{	b[f] = 1;
3256				ones_counter++;
3257				
3258				for(int a = 0; a < 5; a++) //This one thoroughly walks through solution ingredients to find the next function beginning.
3259				{	while(Authorship_public[read_bookmark_symbol] != '.')
3260					{	read_bookmark_symbol++;
3261					}
3262					
3263					read_bookmark_symbol++;
3264				}
3265			}
3266		}
3267		
3268		if(zeros_counter != 6000) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //6,000 functions of 13,500 must remain unsolved.  (4/9)
3269		if(ones_counter  != 7500) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //7,500 functions of 13,500 must be solved.        (5/9)
3270		
3271		//Please refer to the table of digit pair and character assignment from Authorship option 2: "Modify Authorship number."
3272		
3273		//Extracts the new number from b[] and applies it to extracted_number[].
3274		int extracted_number[500];
3275		int r = 0;  //Read bookmark for b[]. Here, it reads the first 500 groups of nine contiguous functions.
3276		bool existence_after_digits = false;
3277		for(int a = 0; a < 500; a++)
3278		{	//                                                                                                                                                              number
3279			//              |              |              |              |              |              |              |              |              |                      fragment
3280			     if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]= 0; r+=9;}
3281			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]= 1; r+=9;}
3282			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]= 2; r+=9;}
3283			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]= 3; r+=9;}
3284			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]= 4; r+=9;}
3285			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]= 5; r+=9;}
3286			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]= 6; r+=9;}
3287			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]= 7; r+=9;}
3288			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]= 8; r+=9;}
3289			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]= 9; r+=9;}
3290			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=10; r+=9;}
3291			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=11; r+=9;}
3292			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=12; r+=9;}
3293			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=13; r+=9;}
3294			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=14; r+=9;}
3295			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=15; r+=9;}
3296			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=16; r+=9;}
3297			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=17; r+=9;}
3298			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=18; r+=9;}
3299			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=19; r+=9;}
3300			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_number[a]=20; r+=9;}
3301			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=21; r+=9;}
3302			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=22; r+=9;}
3303			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=23; r+=9;}
3304			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=24; r+=9;}
3305			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=25; r+=9;}
3306			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=26; r+=9;}
3307			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=27; r+=9;}
3308			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=28; r+=9;}
3309			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=29; r+=9;}
3310			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=30; r+=9;}
3311			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=31; r+=9;}
3312			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=32; r+=9;}
3313			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=33; r+=9;}
3314			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=34; r+=9;}
3315			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_number[a]=35; r+=9;}
3316			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=36; r+=9;}
3317			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=37; r+=9;}
3318			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=38; r+=9;}
3319			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=39; r+=9;}
3320			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=40; r+=9;}
3321			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=41; r+=9;}
3322			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=42; r+=9;}
3323			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=43; r+=9;}
3324			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=44; r+=9;}
3325			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_number[a]=45; r+=9;}
3326			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=46; r+=9;}
3327			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=47; r+=9;}
3328			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=48; r+=9;}
3329			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=49; r+=9;}
3330			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=50; r+=9;}
3331			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_number[a]=51; r+=9;}
3332			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=52; r+=9;}
3333			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=53; r+=9;}
3334			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_number[a]=54; r+=9;}
3335			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_number[a]=55; r+=9;}
3336			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=56; r+=9;}
3337			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=57; r+=9;}
3338			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=58; r+=9;}
3339			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=59; r+=9;}
3340			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=60; r+=9;}
3341			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=61; r+=9;}
3342			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=62; r+=9;}
3343			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=63; r+=9;}
3344			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=64; r+=9;}
3345			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=65; r+=9;}
3346			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=66; r+=9;}
3347			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=67; r+=9;}
3348			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=68; r+=9;}
3349			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=69; r+=9;}
3350			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_number[a]=70; r+=9;}
3351			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=71; r+=9;}
3352			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=72; r+=9;}
3353			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=73; r+=9;}
3354			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=74; r+=9;}
3355			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=75; r+=9;}
3356			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=76; r+=9;}
3357			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=77; r+=9;}
3358			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=78; r+=9;}
3359			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=79; r+=9;}
3360			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_number[a]=80; r+=9;}
3361			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=81; r+=9;}
3362			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=82; r+=9;}
3363			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=83; r+=9;}
3364			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=84; r+=9;}
3365			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=85; r+=9;}
3366			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_number[a]=86; r+=9;}
3367			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=87; r+=9;}
3368			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=88; r+=9;}
3369			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_number[a]=89; r+=9;}
3370			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_number[a]=90; r+=9;}
3371			else if((b[r]== 1 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=91; r+=9;}
3372			else if((b[r]== 1 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=92; r+=9;}
3373			else if((b[r]== 1 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=93; r+=9;}
3374			else if((b[r]== 1 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=94; r+=9;}
3375			else if((b[r]== 1 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_number[a]=95; r+=9;}
3376			else if((b[r]== 1 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=96; r+=9;}
3377			else if((b[r]== 1 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=97; r+=9;}
3378			else if((b[r]== 1 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_number[a]=98; r+=9;}
3379			else if((b[r]== 1 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_number[a]=99; r+=9;} //This is 100th (00 - 99.)
3380			//              |              |              |              |              |              |              |              |              |
3381			
3382			else {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;}
3383			
3384			if(a == 499) {existence_after_digits = true;} //Is set to true if and only if the testing/extraction of these items succeeds to the last iteration.
3385		}
3386		
3387		
3388		
3389		
3390		
3391		//Reminder: the read bookmark 'r' for b[] is useful here and is not reset.
3392		//It continues reading the remaining 1,000 groups of nine contoguous functions.
3393		
3394		//The following block-bunch extracts the user's message, and tests the symbol assignments and correspondence to 5/9.
3395		//Extracts the message from b[]
3396		char extracted_message[1001]; //This, thing, is filled in the following loop (first 1,000 elements.)
3397		bool existence_after_characters = false;
3398		for(int a = 0; a < 1000; a++)
3399		{	
3400			// Note the first symbol is reference # 96 (the Authorship null symbol.) It being first, speeds up the process. (Ref #96 = 1 1 0 0 1 0 0 1 1)
3401			//                                                                                                                                                                message
3402			//              |              |              |              |              |              |              |              |              |                        character
3403			     if((b[r]== 1 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]='\0'; r+=9;} ///Note the "no char symbol" (reference # 96.)
3404			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= ' '; r+=9;} //(Blank or space.)
3405			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= '!'; r+=9;}
3406			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= '"'; r+=9;}
3407			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= '#'; r+=9;}
3408			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= '$'; r+=9;}
3409			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= '%'; r+=9;}
3410			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= '&'; r+=9;}
3411			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]='\''; r+=9;}
3412			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= '('; r+=9;}
3413			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= ')'; r+=9;}
3414			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= '*'; r+=9;}
3415			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= '+'; r+=9;}
3416			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= ','; r+=9;}
3417			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= '-'; r+=9;}
3418			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= '.'; r+=9;}
3419			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= '/'; r+=9;}
3420			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= '0'; r+=9;}
3421			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= '1'; r+=9;}
3422			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= '2'; r+=9;}
3423			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= '3'; r+=9;}
3424			else if((b[r]== 0 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_message[a]= '4'; r+=9;}
3425			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= '5'; r+=9;}
3426			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= '6'; r+=9;}
3427			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= '7'; r+=9;}
3428			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= '8'; r+=9;}
3429			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= '9'; r+=9;}
3430			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= ':'; r+=9;}
3431			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= ';'; r+=9;}
3432			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= '<'; r+=9;}
3433			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= '='; r+=9;}
3434			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= '>'; r+=9;}
3435			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= '?'; r+=9;}
3436			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= '@'; r+=9;}
3437			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= 'A'; r+=9;}
3438			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= 'B'; r+=9;}
3439			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_message[a]= 'C'; r+=9;}
3440			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= 'D'; r+=9;}
3441			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= 'E'; r+=9;}
3442			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= 'F'; r+=9;}
3443			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= 'G'; r+=9;}
3444			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= 'H'; r+=9;}
3445			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= 'I'; r+=9;}
3446			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= 'J'; r+=9;}
3447			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= 'K'; r+=9;}
3448			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= 'L'; r+=9;}
3449			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_message[a]= 'M'; r+=9;}
3450			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= 'N'; r+=9;}
3451			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= 'O'; r+=9;}
3452			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= 'P'; r+=9;}
3453			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= 'Q'; r+=9;}
3454			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= 'R'; r+=9;}
3455			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_message[a]= 'S'; r+=9;}
3456			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= 'T'; r+=9;}
3457			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= 'U'; r+=9;}
3458			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_message[a]= 'V'; r+=9;}
3459			else if((b[r]== 0 )&&(b[r+1]== 1 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_message[a]= 'W'; r+=9;}
3460			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= 'X'; r+=9;}
3461			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= 'Y'; r+=9;}
3462			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= 'Z'; r+=9;}
3463			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= '['; r+=9;}
3464			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]='\\'; r+=9;}
3465			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= ']'; r+=9;}
3466			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= '^'; r+=9;}
3467			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= '_'; r+=9;}
3468			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= '`'; r+=9;}
3469			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= 'a'; r+=9;}
3470			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= 'b'; r+=9;}
3471			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= 'c'; r+=9;}
3472			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= 'd'; r+=9;}
3473			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= 'e'; r+=9;}
3474			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 0 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_message[a]= 'f'; r+=9;}
3475			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= 'g'; r+=9;}
3476			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= 'h'; r+=9;}
3477			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= 'i'; r+=9;}
3478			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= 'j'; r+=9;}
3479			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= 'k'; r+=9;}
3480			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= 'l'; r+=9;}
3481			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= 'm'; r+=9;}
3482			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= 'n'; r+=9;}
3483			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= 'o'; r+=9;}
3484			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 0 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_message[a]= 'p'; r+=9;}
3485			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= 'q'; r+=9;}
3486			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= 'r'; r+=9;}
3487			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= 's'; r+=9;}
3488			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= 't'; r+=9;}
3489			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= 'u'; r+=9;}
3490			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_message[a]= 'v'; r+=9;}
3491			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= 'w'; r+=9;}
3492			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= 'x'; r+=9;}
3493			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_message[a]= 'y'; r+=9;}
3494			else if((b[r]== 1 )&&(b[r+1]== 0 )&&(b[r+2]== 1 )&&(b[r+3]== 1 )&&(b[r+4]== 1 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 0 )&&(b[r+8]== 0 )) {extracted_message[a]= 'z'; r+=9;}
3495			else if((b[r]== 1 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 0 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= '{'; r+=9;}
3496			else if((b[r]== 1 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 0 )&&(b[r+7]== 1 )&&(b[r+8]== 1 )) {extracted_message[a]= '|'; r+=9;}
3497			else if((b[r]== 1 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 0 )&&(b[r+8]== 1 )) {extracted_message[a]= '}'; r+=9;}
3498			else if((b[r]== 1 )&&(b[r+1]== 1 )&&(b[r+2]== 0 )&&(b[r+3]== 0 )&&(b[r+4]== 0 )&&(b[r+5]== 1 )&&(b[r+6]== 1 )&&(b[r+7]== 1 )&&(b[r+8]== 0 )) {extracted_message[a]= '~'; r+=9;} //This makes all 95 printable ASCII characters (but only printable.)
3499			//              |              |              |              |              |              |              |              |              |
3500			
3501			else {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;}
3502			
3503			if(a == 999) {existence_after_characters = true;} //Is set to true if and only if the testing/extraction of these items succeeds to the last iteration.
3504		}
3505		
3506		
3507		
3508		
3509		
3510		//The following safety procedure attempts to prevent side-channel and block-skipping attacks.
3511		//These "existence" variables must have been initialized in the last iterations of their testing loops,
3512		//surpassing many termination commands for failed verification.
3513		
3514		if(existence_after_comparison == true) {comparison = true; cout << "\n\tCompression matches old number.       (1 of 4)";}
3515		if(existence_after_keys       == true) {keys       = true; cout << "\n\tKeys satisfy 5/9 of 13,500 functions. (2 of 4)";}
3516		if(existence_after_digits     == true) {digits     = true; cout << "\n\tNew number corresponds to assignment. (3 of 4)";}
3517		if(existence_after_characters == true) {characters = true; cout << "\n\tCharacters correspond to assignment.  (4 of 4)";}
3518		
3519		if((comparison == true) &&
3520		   (keys       == true) &&
3521		   (digits     == true) &&
3522		   (characters == true))
3523		{	
3524			//Writes the new number to file Authorship.number (overwrites.)
3525			ofstream out_stream;
3526			out_stream.open("Authorship.number");
3527			
3528			for(int a = 0; a < 500; a++)
3529			{	if(extracted_number[a] < 10) {out_stream << '0';} //This ensures for example, "4" turns into "04" (digit pair.)
3530				out_stream << extracted_number[a];
3531			}
3532			
3533			out_stream.close();
3534			
3535			
3536			
3537			
3538			
3539			cout << "\n\n\tVerification SUCCESSFUL!\n\n";
3540			
3541			cout << "Authorship.number has been overwritten with their new number.\n";
3542			cout << "You can discard any and all old modification information.\n";
3543			
3544			if(extracted_message[0] != '\0')
3545			{	cout << "The user included a message for this authentication event: \n\n";
3546				
3547				for(int a = 0; a < 1000; a++) {cout << extracted_message[a];}
3548				cout << "\n\n";
3549			}
3550			else
3551			{	cout << "There is no message for this authentication event.\n";
3552			}
3553		}
3554		
3555		else {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;}
3556	}
3557	
3558	return 0;
3559}
3560