HrAFAQU0

1/// Authorship - infinite authentication tool.
2/// Version 2, function type: 12,000-digit multi-way, purposely unsolved functions are not published. Lightly refactored for safety and speed.
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.)       1kB
34Authorship.public   (Number modification information meant to be published. This file will construct a new number.)  ~207.1MB
35Authorship.private  (*SENSITIVE* Dynamic storage for your Authorship info & keys. This produces Authorship.public.)  ~243.2MB
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 2)\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		int 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 a = 12004; a > 0; a -= 115) {hash_digits_table[a] = 1;}
2410		for(int a = 12004; a > 0; a -= 116) {hash_digits_table[a] = 1;}
2411		for(int a = 12004; a > 0; a -= 117) {hash_digits_table[a] = 1;}
2412		for(int a = 12004; a > 0; a -= 118) {hash_digits_table[a] = 1;}
2413		for(int a = 12004; a > 0; a -= 119) {hash_digits_table[a] = 1;}
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 OVERWRITTEN function and the six separating dots. //////////////////////////////////////
2423				{	if(hash_digits_table[a] == 0) {out_stream << '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						if(old[old_read_bookmark] == 46) {out_stream << '.'; old_read_bookmark++; continue;}
2436					}
2437				}
2438			}
2439			
2440			else
2441			{	/// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2442				for(int a = 0; a < 12006; a++) ///Writes only the function (six sub-ciphertext and the six separating dots.) /////////////////////////////
2443				{	if(old[old_read_bookmark] == 48) {out_stream << '0'; old_read_bookmark++; continue;}
2444					if(old[old_read_bookmark] == 49) {out_stream << '1'; old_read_bookmark++; continue;}
2445					if(old[old_read_bookmark] == 50) {out_stream << '2'; old_read_bookmark++; continue;}
2446					if(old[old_read_bookmark] == 51) {out_stream << '3'; old_read_bookmark++; continue;}
2447					if(old[old_read_bookmark] == 52) {out_stream << '4'; old_read_bookmark++; continue;}
2448					if(old[old_read_bookmark] == 53) {out_stream << '5'; old_read_bookmark++; continue;}
2449					if(old[old_read_bookmark] == 54) {out_stream << '6'; old_read_bookmark++; continue;}
2450					if(old[old_read_bookmark] == 55) {out_stream << '7'; old_read_bookmark++; continue;}
2451					if(old[old_read_bookmark] == 56) {out_stream << '8'; old_read_bookmark++; continue;}
2452					if(old[old_read_bookmark] == 57) {out_stream << '9'; old_read_bookmark++; continue;}
2453					if(old[old_read_bookmark] == 46) {out_stream << '.'; old_read_bookmark++; continue;}
2454				}
2455			}
2456			
2457			//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2458			if(b[revelation] == 1) ///Appends the solution ingredients to the function. //////////////////////////////////////////////////////////////////
2459			{	for(int a = 0; a < 5; a++)
2460				{	while(old[old_read_bookmark] != '.')
2461					{	if(old[old_read_bookmark] == 48) {out_stream << '0'; old_read_bookmark++; continue;}
2462						if(old[old_read_bookmark] == 49) {out_stream << '1'; old_read_bookmark++; continue;}
2463						if(old[old_read_bookmark] == 50) {out_stream << '2'; old_read_bookmark++; continue;}
2464						if(old[old_read_bookmark] == 51) {out_stream << '3'; old_read_bookmark++; continue;}
2465						if(old[old_read_bookmark] == 52) {out_stream << '4'; old_read_bookmark++; continue;}
2466						if(old[old_read_bookmark] == 53) {out_stream << '5'; old_read_bookmark++; continue;}
2467						if(old[old_read_bookmark] == 54) {out_stream << '6'; old_read_bookmark++; continue;}
2468						if(old[old_read_bookmark] == 55) {out_stream << '7'; old_read_bookmark++; continue;}
2469						if(old[old_read_bookmark] == 56) {out_stream << '8'; old_read_bookmark++; continue;}
2470						if(old[old_read_bookmark] == 57) {out_stream << '9'; old_read_bookmark++; continue;}
2471					}
2472					
2473					out_stream << '.';
2474					old_read_bookmark++;
2475				}
2476			}
2477			
2478			//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2479			else ///Skips through the solution ingredients of the function. //////////////////////////////////////////////////////////////////////////////
2480			{	for(int a = 0; a < 5; a++)
2481				{	while(old[old_read_bookmark] != '.')
2482					{	old_read_bookmark++;
2483					}
2484					
2485					old_read_bookmark++;
2486				}
2487				
2488				out_stream << 'x' << '.';
2489			}
2490		}
2491		out_stream << '\0';
2492		
2493		out_stream.close();
2494		
2495		
2496		
2497		
2498		
2499		//Overwrites RAM of old[] and Authorship_private[].
2500		for(int a = 0; a < 256500000; a++)
2501		{	old[a] = 9;
2502			old[a] = 8;
2503			old[a] = 7;
2504			old[a] = 6;
2505			old[a] = 5;
2506			old[a] = 4;
2507			old[a] = 3;
2508			old[a] = 2;
2509			old[a] = 1;
2510			old[a] = 0;
2511			Authorship_private[a] = 9;
2512			Authorship_private[a] = 8;
2513			Authorship_private[a] = 7;
2514			Authorship_private[a] = 6;
2515			Authorship_private[a] = 5;
2516			Authorship_private[a] = 4;
2517			Authorship_private[a] = 3;
2518			Authorship_private[a] = 2;
2519			Authorship_private[a] = 1;
2520			Authorship_private[a] = 0;
2521		}
2522		
2523		
2524		
2525		
2526		
2527		cout << "\n\n\n";
2528		for(int a = 0; a < 100; a++) //Prints the new number incase some verifying party needs it.
2529		{	cout << temp_compression_119[a];
2530		}
2531		
2532		cout << "\n\n\n\n\n\n\n\n\n\n\nFinished.\n\n\n";
2533		
2534		cout << "Authorship.private has been overwritten with your new keys.\n";
2535		cout << "Cache them guardedly and destroy the old copy file.\n\n";
2536		
2537		cout << "Authorship.public resides in this directory. Publish it and the\n";
2538		cout << "verifying party will extract your new number from that file.\n";
2539		cout << "Once they have your new number, they can discard any old numbers\n";
2540		cout << "and keys you have published in the past.\n\n";
2541		
2542		cout << "Your new number is printed above incase some verifying party\n";
2543		cout << "had lost your number or began verifying at a later time.\n\n\n";
2544	}
2545	
2546	
2547	
2548	
2549	
2550	//________________________________________________________________________________________________________________________
2551	//                                                                                                                       |
2552	//                                         3   Verifiy number modification                                               |
2553	//_______________________________________________________________________________________________________________________|
2554	if(user_option == 3)
2555	{	//Basic layout:
2556		//1. Reads file Authirship.public then generates the compression.
2557		//2. Reads file Authorship.number and compares it to the compression from step 1. Fails if mismatch.
2558		//3. Tests the transformation determinants, keys, key transformations, and primes of the file in step 1. Fails on error.
2559		//4. Extracts the new number & message from the file in step 1 and tests for additional properties. Fails on error.
2560		//5. Writes the number to now-created file Authorship.number.
2561		
2562		cout << "\n>>>>>>>>>>>>>>>>>>>>>>>>>>(Verify number modification)<<<<<<<<<<<<<<<<<<<<<<<<<<\n";
2563		cout << "Place COPIES of the following two files in this directory if not already here.\n\n";
2564		
2565		cout << "    Authorship.number  (User's number as saved on your device.)\n";
2566		cout << "    Authorship.public  (User's published file as downloaded on your device.)\n\n";
2567		
2568		cout << "Continue? y/n: ";
2569		char wait;
2570		cin >> wait;
2571		if(wait != 'y') {return 0;}
2572		
2573		
2574		
2575		
2576		
2577		//Loads Authorship.public into Authorship_public[].
2578		static char Authorship_public[220000000];
2579		ifstream in_stream;
2580		in_stream.open("Authorship.public");
2581		
2582		for(int a = 0; a < 220000000; a++)
2583		{	in_stream >> Authorship_public[a];
2584			if(Authorship_public[a] == '\0') {break;}
2585		}
2586		
2587		in_stream.close();
2588		
2589		for(int a = 0; Authorship_public[a] != '\0'; a++) //Converts Authorship_public[] items to numerical values ('x' and '.' excluded.)
2590		{		 if(Authorship_public[a] == 48) {Authorship_public[a] = 0;}
2591			else if(Authorship_public[a] == 49) {Authorship_public[a] = 1;}
2592			else if(Authorship_public[a] == 50) {Authorship_public[a] = 2;}
2593			else if(Authorship_public[a] == 51) {Authorship_public[a] = 3;}
2594			else if(Authorship_public[a] == 52) {Authorship_public[a] = 4;}
2595			else if(Authorship_public[a] == 53) {Authorship_public[a] = 5;}
2596			else if(Authorship_public[a] == 54) {Authorship_public[a] = 6;}
2597			else if(Authorship_public[a] == 55) {Authorship_public[a] = 7;}
2598			else if(Authorship_public[a] == 56) {Authorship_public[a] = 8;}
2599			else if(Authorship_public[a] == 57) {Authorship_public[a] = 9;}
2600			else if(Authorship_public[a] == '.') {continue;}
2601			else if(Authorship_public[a] == 'x') {continue;}
2602			else {cout << "\n\nCosmic ray corruption, line 2602.\n\n"; return 0;}
2603		}
2604		
2605		
2606		
2607		
2608		
2609		//The following block-bunch generates the compression.
2610		//The following guardians must ALL sing "true" before the verifying party gets the message "Verification SUCCESSFUL!"
2611		//These guardians exist for exceptional clarity and safety in the many diverse devices who may run the Authorship program.
2612		//Any errors or mismatch in the verification process IMMEDIATELY ends the program with the message "Verification FAILED!"
2613		//This ensures that false authentication events are terminated here long before any chance of sliding under additional guardians.
2614		//Guardians may be controlled by external means at any moment, by accident in overflow or with clever attacks.
2615		//Guardians sing "false" by default. (Sensitive software means safety first!)
2616		bool comparison = false; //The extracted number must match the provided number.
2617		bool keys       = false; //Keys, transformation determinants, key transformations, and prime lengths must satisfy 5/9 of 13,500 functions.
2618		bool digits     = false; //The first 500 groups of nine contiguous functions must correspond to digit pair assignment.
2619		bool characters = false; //The remainig 1,000 groups of nine contiguous functions must correspond to character assignment.
2620		
2621		//Those who wish to harm and slow down some currency circulation or whatever Authorship system, might exhaustively publish Authorship.public
2622		//files who must receive acceptance by large communities using old hardware. This is just another reason to have early fault detection
2623		//as the file is read, however, it seems no elegant solutions exist and so the file Authorship.public is read whole before being processed.
2624		//This is a waste of time and resources since most machines download and read content slowly which becomes problematic with serious quantity.
2625		//Consider generating deductive lossy compression of the first few functions, then overwriting that to a few integers in the final number.
2626		//Then, while reading the file, if its first few functions produce certain integers who match those in a list of Authorship numbers, file
2627		//reading continues. Attackers can place highly curated faulty files to do just that and get away with wasting the time it takes your machine
2628		//to read and verify the remaining 207.0999MB. But let's get clever. Suppose the first string read from the file contains a cryptographic key
2629		//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
2630		//even halt the download early as you can process dowloaded data sequentially. Surprisingly, this is not a solution still. And given the
2631		//untraceable and anonymous capabilities of Authorship, you can bet that any and all systems will utilize those capabilities--which makes it
2632		//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
2633		//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
2634		//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
2635		//in the first considerstion. This helps pin-point which number the file inquires to modify, however, the remaining file content could be faulty
2636		//for the purpose of wasting time as the genuine file could have been automatically curated by machines looking through the published
2637		//Authorship.public files. This adds garbage to the pile yet the pile must be processed. Please solve for x and let me know.
2638		
2639		//These declarations are for deductive lossy compression, they produce the Authorship number dynamically.
2640		long long int compression_115[100]; //Hops by -115
2641		long long int snapshot_115[100]; //Takes a snapshot of compression_115[] every once in a while.
2642		
2643		long long int compression_116[100]; //Hops by -116
2644		long long int snapshot_116[100]; //Takes a snapshot of compression_116[] every once in a while.
2645		
2646		long long int compression_117[100]; //Hops by -117
2647		long long int snapshot_117[100]; //Takes a snapshot of compression_117[] every once in a while.
2648		
2649		long long int compression_118[100]; //Hops by -118
2650		long long int snapshot_118[100]; //Takes a snapshot of compression_118[] every once in a while.
2651		
2652		long long int compression_119[100]; //Hops by -119
2653		long long int snapshot_119[100]; //Takes a snapshot of compression_119[] every once in a while.
2654		
2655		for(int a = 0; a < 100; a++)
2656		{	compression_115[a] = 5555555555;
2657			snapshot_115[a] = 5555555555;
2658			
2659			compression_116[a] = 5555555555;
2660			snapshot_116[a] = 5555555555;
2661			
2662			compression_117[a] = 5555555555;
2663			snapshot_117[a] = 5555555555;
2664			
2665			compression_118[a] = 5555555555;
2666			snapshot_118[a] = 5555555555;
2667			
2668			compression_119[a] = 5555555555;
2669			snapshot_119[a] = 5555555555;
2670		}
2671		
2672		//Generates compression
2673		int read_bookmark = 0;
2674		for(int f = 0; f < 13500; f++) //Chronologically reads through 13,500 functions in Authorship_public.
2675		{	read_bookmark += 12006;
2676			
2677			compression_119[0] += compression_119[99];
2678			compression_119[0] %= 10000000000;
2679			
2680			int temp_read_bookmark;
2681			temp_read_bookmark = (read_bookmark - 2);
2682			
2683			for(int a = 0; a < 100; a++)
2684			{	compression_115[a] += Authorship_public[temp_read_bookmark];
2685				compression_115[a] *= 5;
2686				compression_115[a] %= 10000000000;
2687				temp_read_bookmark -= 115;
2688			}
2689			temp_read_bookmark = (read_bookmark - 2); //Resetting the temporary variable.
2690			
2691			for(int a = 0; a < 100; a++)
2692			{	compression_116[a] += Authorship_public[temp_read_bookmark];
2693				compression_116[a] *= 6;
2694				compression_116[a] %= 10000000000;
2695				temp_read_bookmark -= 116;
2696			}
2697			temp_read_bookmark = (read_bookmark - 2); //Resetting the temporary variable.
2698			
2699			for(int a = 0; a < 100; a++)
2700			{	compression_117[a] += Authorship_public[temp_read_bookmark];
2701				compression_117[a] *= 7;
2702				compression_117[a] %= 10000000000;
2703				temp_read_bookmark -= 117;
2704			}
2705			temp_read_bookmark = (read_bookmark - 2); //Resetting the temporary variable.
2706			
2707			for(int a = 0; a < 100; a++)
2708			{	compression_118[a] += Authorship_public[temp_read_bookmark];
2709				compression_118[a] *= 8;
2710				compression_118[a] %= 10000000000;
2711				temp_read_bookmark -= 118;
2712			}
2713			temp_read_bookmark = (read_bookmark - 2); //Resetting the temporary variable.
2714			
2715			for(int a = 0; a < 100; a++)
2716			{	compression_119[a] += Authorship_public[temp_read_bookmark];
2717				compression_119[a] *= 9;
2718				compression_119[a] %= 10000000000;
2719				temp_read_bookmark -= 119;
2720			}
2721			
2722			//Compression snapshots are active in early stages of Authorship number evolution. They are applied to the compression in the end.
2723			if((f == 1000) || (f == 2000) || (f == 3000) || (f == 4000) || (f == 5000) || (f == 6000) || (f == 7000) || (f == 8000))
2724			{	for(int a = 0; a < 100; a++)
2725				{	snapshot_115[a] += compression_115[a];
2726					snapshot_115[a] %= 10000000000; //(10^10, results in last ten digits shown.)
2727					
2728					snapshot_116[a] += compression_116[a];
2729					snapshot_116[a] %= 10000000000;
2730					
2731					snapshot_117[a] += compression_117[a];
2732					snapshot_117[a] %= 10000000000;
2733					
2734					snapshot_118[a] += compression_118[a];
2735					snapshot_118[a] %= 10000000000;
2736					
2737					snapshot_119[a] += compression_119[a];
2738					snapshot_119[a] %= 10000000000;
2739				}
2740			}
2741			
2742			if(Authorship_public[read_bookmark] == 'x')
2743			{	read_bookmark += 2;
2744			}
2745			
2746			else
2747			{	for(int a = 0; a < 5; a++)
2748				{	while(Authorship_public[read_bookmark] != '.')
2749					{	read_bookmark++;
2750					}
2751					
2752					read_bookmark++;
2753				}
2754			}
2755		}
2756		
2757		//Constructively combines the comression tables. compression_119[] will hold it all.
2758		for(int a = 0; a < 100; a++)
2759		{	compression_119[a] += compression_115[a];
2760			if((compression_119[a] % 2) == 0) {compression_119[a] *= 2;}
2761			
2762			compression_119[a] += compression_116[a];
2763			if((compression_119[a] % 2) == 0) {compression_119[a] *= 3;}
2764			
2765			compression_119[a] += compression_117[a];
2766			if((compression_119[a] % 2) == 0) {compression_119[a] *= 5;}
2767			
2768			compression_119[a] += compression_118[a];
2769			if((compression_119[a] % 2) == 0) {compression_119[a] *= 7;}
2770			
2771			compression_119[a] %= 10000000000; //(10^10, results in last ten digits shown.)
2772		}
2773		
2774		//Constructively combines the snapshot tables. snapshot_119[] will hold it all.
2775		for(int a = 0; a < 100; a++)
2776		{	snapshot_119[a] += snapshot_115[a];
2777			if((snapshot_119[a] % 2) == 0) {snapshot_119[a] *= 2;}
2778			
2779			snapshot_119[a] += snapshot_116[a];
2780			if((snapshot_119[a] % 2) == 0) {snapshot_119[a] *= 3;}
2781			
2782			snapshot_119[a] += snapshot_117[a];
2783			if((snapshot_119[a] % 2) == 0) {snapshot_119[a] *= 5;}
2784			
2785			snapshot_119[a] += snapshot_118[a];
2786			if((snapshot_119[a] % 2) == 0) {snapshot_119[a] *= 7;}
2787			
2788			snapshot_119[a] %= 10000000000; //(10^10, results in last ten digits shown.)
2789		}
2790		
2791		//Applies the snapshots to the last stage in compression. (As the Authorship number evolved over time, snapshots made a record of its early stages.)
2792		for(int a = 0; a < 100; a++)
2793		{	compression_119[a] += snapshot_119[a];
2794			compression_119[a] %= 10000000000; //(10^10, results in last ten digits shown.)
2795		}
2796		
2797		for(int a = 0; a < 100; a++) //Ensures each constituent compression integer is 10 digits long. The Authorship number is now complete.
2798		{	if(compression_119[a] < 1000000000)
2799			{	compression_119[a] += 1000000000;
2800			}
2801		}
2802		
2803		//The following block-bunch compares the generated number with the given number.
2804		//Converts the here-generated number (100 integers in compression_119[]) to type array for loading into compression[].
2805		int compression[1000] = {0};
2806		int compression_write_bookmark = 0;
2807		for(int a = 0; a < 100; a++)
2808		{	compression[compression_write_bookmark] =  (compression_119[a] / 1000000000);
2809			compression_write_bookmark++;
2810			compression[compression_write_bookmark] = ((compression_119[a] / 100000000) % 10);
2811			compression_write_bookmark++;
2812			compression[compression_write_bookmark] = ((compression_119[a] / 10000000) % 10);
2813			compression_write_bookmark++;
2814			compression[compression_write_bookmark] = ((compression_119[a] / 1000000) % 10);
2815			compression_write_bookmark++;
2816			compression[compression_write_bookmark] = ((compression_119[a] / 100000) % 10);
2817			compression_write_bookmark++;
2818			compression[compression_write_bookmark] = ((compression_119[a] / 10000) % 10);
2819			compression_write_bookmark++;
2820			compression[compression_write_bookmark] = ((compression_119[a] / 1000) % 10);
2821			compression_write_bookmark++;
2822			compression[compression_write_bookmark] = ((compression_119[a] / 100) % 10);
2823			compression_write_bookmark++;
2824			compression[compression_write_bookmark] = ((compression_119[a] / 10) % 10);
2825			compression_write_bookmark++;
2826			compression[compression_write_bookmark] =  (compression_119[a]      % 10);
2827			compression_write_bookmark++;
2828		}
2829		
2830		//Loads file Authorship.number into Authorship_number[].
2831		char Authorship_number[1000];
2832		in_stream.open("Authorship.number");
2833		
2834		for(int a = 0; a < 1000; a++)
2835		{	in_stream >> Authorship_number[a];
2836				 if(Authorship_number[a] == 48) {Authorship_number[a] = 0;} //(Loaded ASCII characters from file) so converting them to our familiar numbers!
2837			else if(Authorship_number[a] == 49) {Authorship_number[a] = 1;} //Look to the ASCII table & character assignment in option 2.
2838			else if(Authorship_number[a] == 50) {Authorship_number[a] = 2;}
2839			else if(Authorship_number[a] == 51) {Authorship_number[a] = 3;}
2840			else if(Authorship_number[a] == 52) {Authorship_number[a] = 4;}
2841			else if(Authorship_number[a] == 53) {Authorship_number[a] = 5;}
2842			else if(Authorship_number[a] == 54) {Authorship_number[a] = 6;}
2843			else if(Authorship_number[a] == 55) {Authorship_number[a] = 7;}
2844			else if(Authorship_number[a] == 56) {Authorship_number[a] = 8;}
2845			else if(Authorship_number[a] == 57) {Authorship_number[a] = 9;}
2846			else {cout << "\n\nCosmic ray file corruption, line 2846.\n\n"; return 0;}
2847		}
2848		
2849		in_stream.close();
2850		
2851		//Compares the given number with the generated number.
2852		bool existence_after_comparison = false;
2853		for(int a = 0; a < 1000; a++)
2854		{	if(compression[a] != Authorship_number[a]) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;}
2855			
2856			if(a == 999) {existence_after_comparison = true;} //Is set to true if and only if comparison succeeds to the last iteration
2857		}                                                     //where each and every test would end the program on mismatch.
2858		
2859		
2860		
2861		
2862		
2863		//The following block-bunch tests the transformation determinants, sub-keys and their five transformations, and the
2864		//hot zones. (Testing only the functions to which solution ingredients are included in the file Authorship.public.)
2865		//This is a boolean sieve of Eratosthenes. Zeros are prime, conveniently mapped to their element index.
2866		//(It is used here like the following example: if(sieve[my_candidate] == 0) then my_candidate is prime.)
2867		bool sieve[100000] = {1, 1};
2868		for(int prime = 2; prime < 317; prime++) //317 is sqrt(100000)
2869		{	for(int a = prime + prime; a < 100000; a += prime) {sieve[a] = 1;}
2870		}
2871		
2872		int read_bookmark_crypt = 0; //Reads from Authorship_public[] but for the purpose of testing solution ingredients.
2873		bool existence_after_keys = false;
2874		for(int f = 0; f < 13500; f++) //Chronologically reads through 13,500 functions in Authorship_public[]. This for loop contains three items.
2875		{	/// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2876			/// If no solution ingredients, skips to the contiguous function ahead. //////////////////////////////////////////////////////////////////////
2877			if(Authorship_public[read_bookmark_crypt + 12006] == 'x')
2878			{	read_bookmark_crypt += 12008;
2879			}
2880			
2881			/// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2882			/// If solution ingredients are present, they are tested against the current function. ///////////////////////////////////////////////////////
2883			else
2884			{	//Reads & grabs the ciphertext, transformation determinant, first sub-key, and the prime-lengths-in-order (identifying properties.)
2885				int sub_ciphertext_SUB2[2000];
2886				int sub_ciphertext_SUB4[2000];
2887				int sub_ciphertext_SUB6[2000];
2888				
2889				int transformation_determinant[2000];
2890				int sub_key[2000];
2891				int prime_lengths_in_order_SUB2[1000] = {0};
2892				int prime_lengths_in_order_SUB4[1000] = {0};
2893				int prime_lengths_in_order_SUB6[1000] = {0};
2894				
2895				for(int a = 0; a < 2000; a++) {read_bookmark_crypt++;} //Skips through 1st sub-ciphertext.
2896				read_bookmark_crypt++;
2897				
2898				for(int a = 0; a < 2000; a++) //Loads sub_ciphertext_SUB2[].
2899				{	sub_ciphertext_SUB2[a] = Authorship_public[read_bookmark_crypt];
2900					read_bookmark_crypt++;
2901				}
2902				read_bookmark_crypt++;
2903				
2904				for(int a = 0; a < 2000; a++) {read_bookmark_crypt++;} //Skips through 3rd sub-ciphertext.
2905				read_bookmark_crypt++;
2906				
2907				for(int a = 0; a < 2000; a++) //Loads sub_ciphertext_SUB4[].
2908				{	sub_ciphertext_SUB4[a] = Authorship_public[read_bookmark_crypt];
2909					read_bookmark_crypt++;
2910				}
2911				read_bookmark_crypt++;
2912				
2913				for(int a = 0; a < 2000; a++) {read_bookmark_crypt++;} //Skips through 5th sub-ciphertext.
2914				read_bookmark_crypt++;
2915				
2916				for(int a = 0; a < 2000; a++) //Loads sub_ciphertext_SUB6[].
2917				{	sub_ciphertext_SUB6[a] = Authorship_public[read_bookmark_crypt];
2918					read_bookmark_crypt++;
2919				}
2920				read_bookmark_crypt++;
2921				
2922				for(int a = 0; a < 2000; a++) //Loads transformation_determinant[].
2923				{	transformation_determinant[a] = Authorship_public[read_bookmark_crypt];
2924					read_bookmark_crypt++;
2925				}
2926				read_bookmark_crypt++;
2927				
2928				for(int a = 0; a < 2000; a++) //Loads sub_key[].
2929				{	sub_key[a] = Authorship_public[read_bookmark_crypt];
2930					read_bookmark_crypt++;
2931				}
2932				read_bookmark_crypt++;
2933				
2934				for(int a = 0; Authorship_public[read_bookmark_crypt] != '.'; a++) //Loads prime_lengths_in_order_SUB2[].
2935				{	prime_lengths_in_order_SUB2[a] = Authorship_public[read_bookmark_crypt];
2936					read_bookmark_crypt++;
2937				}
2938				read_bookmark_crypt++;
2939				
2940				for(int a = 0; Authorship_public[read_bookmark_crypt] != '.'; a++) //Loads prime_lengths_in_order_SUB4[].
2941				{	prime_lengths_in_order_SUB4[a] = Authorship_public[read_bookmark_crypt];
2942					read_bookmark_crypt++;
2943				}
2944				read_bookmark_crypt++;
2945				
2946				for(int a = 0; Authorship_public[read_bookmark_crypt] != '.'; a++) //Loads prime_lengths_in_order_SUB6[].
2947				{	prime_lengths_in_order_SUB6[a] = Authorship_public[read_bookmark_crypt];
2948					read_bookmark_crypt++;
2949				}
2950				read_bookmark_crypt++;
2951				
2952				
2953				
2954				
2955				
2956				//Now that the function and its solution ingredients have been loaded, the testing begins.
2957				//The sub-key is transformed once for sub-function 2.
2958				for(int a = 0; a < 1999; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 2.)
2959				{	sub_key[a] += transformation_determinant[a];
2960					sub_key[a] = ((sub_key[a] + transformation_determinant[a + 1]) % 10); //[a + 1] means do up to 1998 or seg fault.
2961				}
2962				sub_key[1999] = ((sub_key[1999] + transformation_determinant[1000]) % 10); //Last element was not transformed so here it is.
2963				//(1st of 5 total transformations per function.) Each one is different.
2964				
2965				
2966				
2967				
2968				
2969				//Generates 2nd sub-plaintext (hot zone) through deductive reasoning since the key
2970				//and output are present. The following formula helps extract plaintext quickly.
2971				//      ______________________________________________ ________________________________________________
2972				//     |                                              |                                                |
2973				//     |          if sub-key <= ciphertext            |                     else                       |
2974				//     |   then plaintext = (ciphertext - sub-key)    |    plaintext = ((10 - sub-key) + ciphertext)   |
2975				//     |______________________________________________|________________________________________________|
2976				//
2977				int sub_plaintext_SUB2[2000];
2978				for(int a = 0; a < 2000; a++)
2979				{	if(sub_key[a] <= sub_ciphertext_SUB2[a]) {sub_plaintext_SUB2[a] = (sub_ciphertext_SUB2[a] - sub_key[a]);}
2980					else {sub_plaintext_SUB2[a] = ((10 - sub_key[a]) + sub_ciphertext_SUB2[a]);}
2981				}
2982				
2983				
2984				
2985				
2986				
2987				//Checks if sub_ciphertext_SUB2[] is composed entirely of whatever quantity of contiguous primes of digit lengths one to five.
2988				int read_bookmark_sub_plaintext_SUB2 = 0;
2989				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.)
2990				{	if(prime_lengths_in_order_SUB2[a] == 1) //If expected prime length is 1, grabs 1 digit from sub_plaintext_SUB2[].
2991					{	assembled_candidate = sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2];
2992						
2993						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
2994						read_bookmark_sub_plaintext_SUB2++;
2995					}
2996					
2997					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[].
2998					{	assembled_candidate = sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2];
2999						assembled_candidate *= 10;
3000						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 1];
3001						
3002						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3003						read_bookmark_sub_plaintext_SUB2 += 2;
3004					}
3005					
3006					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[].
3007					{	assembled_candidate = sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2];
3008						assembled_candidate *= 10;
3009						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 1];
3010						assembled_candidate *= 10;
3011						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 2];
3012						
3013						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3014						read_bookmark_sub_plaintext_SUB2 += 3;
3015					}
3016					
3017					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[].
3018					{	assembled_candidate = sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2];
3019						assembled_candidate *= 10;
3020						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 1];
3021						assembled_candidate *= 10;
3022						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 2];
3023						assembled_candidate *= 10;
3024						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 3];
3025						
3026						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3027						read_bookmark_sub_plaintext_SUB2 += 4;
3028					}
3029					
3030					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[].
3031					{	assembled_candidate = sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2];
3032						assembled_candidate *= 10;
3033						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 1];
3034						assembled_candidate *= 10;
3035						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 2];
3036						assembled_candidate *= 10;
3037						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 3];
3038						assembled_candidate *= 10;
3039						assembled_candidate += sub_plaintext_SUB2[read_bookmark_sub_plaintext_SUB2 + 4];
3040						
3041						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3042						read_bookmark_sub_plaintext_SUB2 += 5;
3043					}
3044				}
3045				
3046				
3047				
3048				
3049				
3050				for(int a = 0; a < 1998; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 3.)
3051				{	sub_key[a] += transformation_determinant[a];
3052					sub_key[a] = ((sub_key[a] + transformation_determinant[a + 2]) % 10); //[a + 2] means do up to 1997 or seg fault.
3053				}
3054				sub_key[1998] = ((sub_key[1998] + transformation_determinant[1005]) % 10); //Last two elements were not transformed so here it is.
3055				sub_key[1999] = ((sub_key[1999] + transformation_determinant[1010]) % 10);
3056				//(2nd of 5 total transformations per function.) Each one is different.
3057				//
3058				//
3059				//		(Since only the hot zones are checked, transformation continues in preparation for the next hot zone.)
3060				//
3061				//
3062				for(int a = 0; a < 1997; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 4.)
3063				{	sub_key[a] += transformation_determinant[a];
3064					sub_key[a] = ((sub_key[a] + transformation_determinant[a + 3]) % 10); //[a + 3] means do up to 1996 or seg fault.
3065				}
3066				sub_key[1997] = ((sub_key[1997] + transformation_determinant[1015]) % 10); //Last three elements were not transformed so here it is.
3067				sub_key[1998] = ((sub_key[1998] + transformation_determinant[1020]) % 10);
3068				sub_key[1999] = ((sub_key[1999] + transformation_determinant[1025]) % 10);
3069				//(3rd of 5 total transformations per function.) Each one is different.
3070				
3071				
3072				
3073				
3074				
3075				//Generates 4th sub-plaintext (hot zone) through deductive reasoning since the key
3076				//and output are present. The following formula helps extract plaintext quickly.
3077				//      ______________________________________________ ________________________________________________
3078				//     |                                              |                                                |
3079				//     |          if sub-key <= ciphertext            |                     else                       |
3080				//     |   then plaintext = (ciphertext - sub-key)    |    plaintext = ((10 - sub-key) + ciphertext)   |
3081				//     |______________________________________________|________________________________________________|
3082				//
3083				int sub_plaintext_SUB4[2000];
3084				for(int a = 0; a < 2000; a++)
3085				{	if(sub_key[a] <= sub_ciphertext_SUB4[a]) {sub_plaintext_SUB4[a] = (sub_ciphertext_SUB4[a] - sub_key[a]);}
3086					else {sub_plaintext_SUB4[a] = ((10 - sub_key[a]) + sub_ciphertext_SUB4[a]);}
3087				}
3088				
3089				
3090				
3091				
3092				
3093				//Checks if sub_ciphertext_SUB4[] is composed entirely of whatever quantity of contiguous primes of digit lengths one to five.
3094				int read_bookmark_sub_plaintext_SUB4 = 0;
3095				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.)
3096				{	if(prime_lengths_in_order_SUB4[a] == 1) //If expected prime length is 1, grabs 1 digit from sub_plaintext_SUB4[].
3097					{	assembled_candidate = sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4];
3098						
3099						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3100						read_bookmark_sub_plaintext_SUB4++;
3101					}
3102					
3103					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[].
3104					{	assembled_candidate = sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4];
3105						assembled_candidate *= 10;
3106						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 1];
3107						
3108						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3109						read_bookmark_sub_plaintext_SUB4 += 2;
3110					}
3111					
3112					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[].
3113					{	assembled_candidate = sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4];
3114						assembled_candidate *= 10;
3115						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 1];
3116						assembled_candidate *= 10;
3117						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 2];
3118						
3119						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3120						read_bookmark_sub_plaintext_SUB4 += 3;
3121					}
3122					
3123					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[].
3124					{	assembled_candidate = sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4];
3125						assembled_candidate *= 10;
3126						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 1];
3127						assembled_candidate *= 10;
3128						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 2];
3129						assembled_candidate *= 10;
3130						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 3];
3131						
3132						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3133						read_bookmark_sub_plaintext_SUB4 += 4;
3134					}
3135					
3136					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[].
3137					{	assembled_candidate = sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4];
3138						assembled_candidate *= 10;
3139						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 1];
3140						assembled_candidate *= 10;
3141						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 2];
3142						assembled_candidate *= 10;
3143						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 3];
3144						assembled_candidate *= 10;
3145						assembled_candidate += sub_plaintext_SUB4[read_bookmark_sub_plaintext_SUB4 + 4];
3146						
3147						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3148						read_bookmark_sub_plaintext_SUB4 += 5;
3149					}
3150				}
3151				
3152				
3153				
3154				
3155				
3156				for(int a = 0; a < 1996; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 5.)
3157				{	sub_key[a] += transformation_determinant[a];
3158					sub_key[a] = ((sub_key[a] + transformation_determinant[a + 4]) % 10); //[a + 4] means do up to 1995 or seg fault.
3159				}
3160				sub_key[1996] = ((sub_key[1996] + transformation_determinant[1030]) % 10); //Last four elements were not transformed so here it is.
3161				sub_key[1997] = ((sub_key[1997] + transformation_determinant[1035]) % 10);
3162				sub_key[1998] = ((sub_key[1998] + transformation_determinant[1040]) % 10);
3163				sub_key[1999] = ((sub_key[1999] + transformation_determinant[1045]) % 10);
3164				//(4th of 5 total transformations per function.) Each one is different.
3165				//
3166				//
3167				//		(Since only the hot zones are checked, transformation continues in preparation for the next hot zone.)
3168				//
3169				//
3170				for(int a = 0; a < 1995; a++) //Transformation determinant transforms sub-key at current stage (preparation for sub-function 6.)
3171				{	sub_key[a] += transformation_determinant[a];
3172					sub_key[a] = ((sub_key[a] + transformation_determinant[a + 5]) % 10); //[a + 5] means do up to 1994 or seg fault.
3173				}
3174				sub_key[1995] = ((sub_key[1995] + transformation_determinant[1050]) % 10); //Last five elements were not transformed so here it is.
3175				sub_key[1996] = ((sub_key[1996] + transformation_determinant[1055]) % 10);
3176				sub_key[1997] = ((sub_key[1997] + transformation_determinant[1060]) % 10);
3177				sub_key[1998] = ((sub_key[1998] + transformation_determinant[1065]) % 10);
3178				sub_key[1999] = ((sub_key[1999] + transformation_determinant[1070]) % 10);
3179				//(5th of 5 total transformations per function.) Each one is different.
3180				
3181				
3182				
3183				
3184				
3185				//Generates 6th sub-plaintext (hot zone) through deductive reasoning since the key
3186				//and output are present. The following formula helps extract plaintext quickly.
3187				//      ______________________________________________ ________________________________________________
3188				//     |                                              |                                                |
3189				//     |          if sub-key <= ciphertext            |                     else                       |
3190				//     |   then plaintext = (ciphertext - sub-key)    |    plaintext = ((10 - sub-key) + ciphertext)   |
3191				//     |______________________________________________|________________________________________________|
3192				//
3193				int sub_plaintext_SUB6[2000];
3194				for(int a = 0; a < 2000; a++)
3195				{	if(sub_key[a] <= sub_ciphertext_SUB6[a]) {sub_plaintext_SUB6[a] = (sub_ciphertext_SUB6[a] - sub_key[a]);}
3196					else {sub_plaintext_SUB6[a] = ((10 - sub_key[a]) + sub_ciphertext_SUB6[a]);}
3197				}
3198				
3199				
3200				
3201				
3202				
3203				//Checks if sub_ciphertext_SUB6[] is composed entirely of whatever quantity of contiguous primes of digit lengths one to five.
3204				int read_bookmark_sub_plaintext_SUB6 = 0;
3205				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.)
3206				{	if(prime_lengths_in_order_SUB6[a] == 1) //If expected prime length is 1, grabs 1 digit from sub_plaintext_SUB6[].
3207					{	assembled_candidate = sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6];
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_SUB6++;
3211					}
3212					
3213					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[].
3214					{	assembled_candidate = sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6];
3215						assembled_candidate *= 10;
3216						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 1];
3217						
3218						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3219						read_bookmark_sub_plaintext_SUB6 += 2;
3220					}
3221					
3222					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[].
3223					{	assembled_candidate = sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6];
3224						assembled_candidate *= 10;
3225						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 1];
3226						assembled_candidate *= 10;
3227						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 2];
3228						
3229						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3230						read_bookmark_sub_plaintext_SUB6 += 3;
3231					}
3232					
3233					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[].
3234					{	assembled_candidate = sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6];
3235						assembled_candidate *= 10;
3236						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 1];
3237						assembled_candidate *= 10;
3238						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 2];
3239						assembled_candidate *= 10;
3240						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 3];
3241						
3242						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3243						read_bookmark_sub_plaintext_SUB6 += 4;
3244					}
3245					
3246					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[].
3247					{	assembled_candidate = sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6];
3248						assembled_candidate *= 10;
3249						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 1];
3250						assembled_candidate *= 10;
3251						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 2];
3252						assembled_candidate *= 10;
3253						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 3];
3254						assembled_candidate *= 10;
3255						assembled_candidate += sub_plaintext_SUB6[read_bookmark_sub_plaintext_SUB6 + 4];
3256						
3257						if(sieve[assembled_candidate] != 0) {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;} //Tests if prime.
3258						read_bookmark_sub_plaintext_SUB6 += 5;
3259					}
3260				}
3261			}
3262			
3263			//You might wonder why then even include cool zones in the Authorship files
3264			//if they hold only random plaintext, and are excluded in the key_pass test.
3265			//The ciphertext is produced via (sub_key[a] + plaintext[a]) mod 10.
3266			//Cool zones utilize random numbers for their plaintext which are then
3267			//reproduced exactly and as expected. This leaves quite the space
3268			//for those who need to stuff as much data into these files as possible.
3269			//And everyone's file being ~207MB, who inserted data and who didn't?
3270			
3271			//The read/write_bookmarks and little templates make editing a breeze.
3272			//Authorship provides these subtle expansion possibilities--awaiting
3273			//the many problems and needs of heroes yet to come.
3274			
3275			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.
3276		}
3277		
3278		
3279		
3280		
3281		
3282		//The following block-bunch extracts the new number & message, and tests the symbol assignments and correspondence to 5/9.
3283		bool b[13500]; //b for binary, will hold the final binary super-string.
3284		
3285		int zeros_counter = 0; //6,000 functions of 13,500 must remain unsolved.  (4/9)
3286		int ones_counter = 0;  //7,500 functions of 13,500 must be solved.        (5/9)
3287		
3288		int read_bookmark_symbol = 0;
3289		for(int f = 0; f < 13500; f++) //Flies over the functions and looks for the .x. markers.
3290		{	read_bookmark_symbol += 12006;
3291			
3292			if(Authorship_public[read_bookmark_symbol] == 'x')
3293			{	b[f] = 0;
3294				zeros_counter++;
3295				
3296				read_bookmark_symbol += 2;
3297			}
3298			
3299			else
3300			{	b[f] = 1;
3301				ones_counter++;
3302				
3303				for(int a = 0; a < 5; a++) //This one thoroughly walks through solution ingredients to find the next function beginning.
3304				{	while(Authorship_public[read_bookmark_symbol] != '.')
3305					{	read_bookmark_symbol++;
3306					}
3307					
3308					read_bookmark_symbol++;
3309				}
3310			}
3311		}
3312		
3313		//Please refer to the table of digit pair and character assignment from Authorship option 2: "Modify Authorship number."
3314		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)
3315		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)
3316		
3317		//Extracts the new number from b[] and applies it to extracted_number[].
3318		int extracted_number[500];
3319		int r = 0;  //Read bookmark for b[]. Here, it reads the first 500 groups of nine contiguous functions.
3320		bool existence_after_digits = false;
3321		for(int a = 0; a < 500; a++)
3322		{	//                                                                                                                                                              number
3323			//              |              |              |              |              |              |              |              |              |                      fragment
3324			     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;}
3325			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;}
3326			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;}
3327			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;}
3328			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;}
3329			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;}
3330			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;}
3331			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;}
3332			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;}
3333			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;}
3334			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;}
3335			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;}
3336			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;}
3337			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;}
3338			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;}
3339			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;}
3340			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;}
3341			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;}
3342			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;}
3343			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;}
3344			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;}
3345			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;}
3346			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;}
3347			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;}
3348			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;}
3349			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;}
3350			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;}
3351			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;}
3352			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;}
3353			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;}
3354			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;}
3355			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;}
3356			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;}
3357			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;}
3358			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;}
3359			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;}
3360			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;}
3361			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;}
3362			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;}
3363			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;}
3364			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;}
3365			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;}
3366			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;}
3367			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;}
3368			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;}
3369			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;}
3370			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;}
3371			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;}
3372			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;}
3373			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;}
3374			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;}
3375			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;}
3376			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;}
3377			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;}
3378			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;}
3379			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;}
3380			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;}
3381			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;}
3382			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;}
3383			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;}
3384			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;}
3385			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;}
3386			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;}
3387			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;}
3388			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;}
3389			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;}
3390			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;}
3391			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;}
3392			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;}
3393			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;}
3394			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;}
3395			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;}
3396			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;}
3397			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;}
3398			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;}
3399			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;}
3400			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;}
3401			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;}
3402			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;}
3403			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;}
3404			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;}
3405			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;}
3406			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;}
3407			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;}
3408			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;}
3409			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;}
3410			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;}
3411			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;}
3412			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;}
3413			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;}
3414			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;}
3415			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;}
3416			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;}
3417			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;}
3418			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;}
3419			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;}
3420			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;}
3421			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;}
3422			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;}
3423			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.)
3424			//              |              |              |              |              |              |              |              |              |
3425			
3426			else {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;}
3427			
3428			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.
3429		}
3430		
3431		
3432		
3433		
3434		
3435		//Reminder: the read bookmark 'r' for b[] is useful here and is not reset.
3436		//It continues reading the remaining 1,000 groups of nine contiguous functions.
3437		
3438		//The following block-bunch extracts the user's message, and tests the symbol assignments and correspondence to 5/9.
3439		//Extracts the message from b[]
3440		char extracted_message[1001]; //This, thing, is filled in the following loop (first 1,000 elements.)
3441		bool existence_after_characters = false;
3442		for(int a = 0; a < 1000; a++)
3443		{	
3444			// 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)
3445			//                                                                                                                                                                message
3446			//              |              |              |              |              |              |              |              |              |                        character
3447			     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.)
3448			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.)
3449			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;}
3450			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;}
3451			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;}
3452			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;}
3453			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;}
3454			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;}
3455			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;}
3456			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;}
3457			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;}
3458			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;}
3459			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;}
3460			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;}
3461			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;}
3462			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;}
3463			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;}
3464			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;}
3465			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;}
3466			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;}
3467			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;}
3468			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;}
3469			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;}
3470			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;}
3471			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;}
3472			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;}
3473			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;}
3474			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;}
3475			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;}
3476			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;}
3477			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;}
3478			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;}
3479			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;}
3480			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;}
3481			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;}
3482			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;}
3483			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;}
3484			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;}
3485			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;}
3486			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;}
3487			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;}
3488			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;}
3489			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;}
3490			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;}
3491			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;}
3492			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;}
3493			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;}
3494			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;}
3495			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;}
3496			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;}
3497			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;}
3498			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;}
3499			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;}
3500			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;}
3501			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;}
3502			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;}
3503			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;}
3504			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;}
3505			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;}
3506			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;}
3507			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;}
3508			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;}
3509			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;}
3510			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;}
3511			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;}
3512			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;}
3513			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;}
3514			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;}
3515			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;}
3516			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;}
3517			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;}
3518			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;}
3519			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;}
3520			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;}
3521			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;}
3522			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;}
3523			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;}
3524			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;}
3525			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;}
3526			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;}
3527			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;}
3528			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;}
3529			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;}
3530			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;}
3531			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;}
3532			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;}
3533			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;}
3534			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;}
3535			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;}
3536			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;}
3537			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;}
3538			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;}
3539			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;}
3540			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;}
3541			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;}
3542			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.)
3543			//              |              |              |              |              |              |              |              |              |
3544			
3545			else {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;}
3546			
3547			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.
3548		}
3549		
3550		
3551		
3552		
3553		
3554		//The following safety procedure attempts to prevent side-channel and block-skipping attacks. These "existence" variables must have
3555		//been initialized in the last iterations of their testing loops, surpassing many termination commands for failed verification.
3556		cout << "\n\n\n\n\n\n\n\n\n\n\n";
3557		
3558		if(existence_after_comparison == true) {comparison = true; cout << "\n\tCompression matches old number.       (1 of 4)";}
3559		if(existence_after_keys       == true) {keys       = true; cout << "\n\tKeys satisfy 5/9 of 13,500 functions. (2 of 4)";}
3560		if(existence_after_digits     == true) {digits     = true; cout << "\n\tNew number corresponds to assignment. (3 of 4)";}
3561		if(existence_after_characters == true) {characters = true; cout << "\n\tCharacters correspond to assignment.  (4 of 4)";}
3562		
3563		if((comparison == true) &&
3564		   (keys       == true) &&
3565		   (digits     == true) &&
3566		   (characters == true))
3567		{	
3568			//Writes the new number to file Authorship.number (overwrites.)
3569			ofstream out_stream;
3570			out_stream.open("Authorship.number");
3571			
3572			for(int a = 0; a < 500; a++)
3573			{	if(extracted_number[a] < 10) {out_stream << '0';} //This ensures for example, "4" turns into "04" (digit pair.)
3574				out_stream << extracted_number[a];
3575			}
3576			
3577			out_stream.close();
3578			
3579			cout << "\n\n\tVerification SUCCESSFUL!\n\n";
3580			
3581			cout << "Authorship.number has been overwritten with their new number.\n";
3582			cout << "You can discard any and all old modification information.\n";
3583			
3584			if(extracted_message[0] != '\0')
3585			{	cout << "The user included a message for this authentication event: \n\n";
3586				
3587				for(int a = 0; a < 1000; a++) {cout << extracted_message[a];}
3588				cout << "\n\n";
3589			}
3590			else
3591			{	cout << "There is no message for this authentication event.\n";
3592			}
3593		}
3594		
3595		else {cout << "\n\n\nVerification FAILED!\n\n\n"; return 0;}
3596	}
3597	
3598	return 0;
3599}
3600