d0wzqRVp

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