Like Tree1Likes

Very large program. May I ask you for advice on how to make it cleaner or smaller?

This is a discussion on Very large program. May I ask you for advice on how to make it cleaner or smaller? within the C Programming forums, part of the General Programming Boards category; Example: Code: Type 1 to run the program 1 Enter a sentence, all lower case. Rename X and Y with ...

  1. #1
    Registered User
    Join Date
    Apr 2011
    Posts
    229

    Very large program. May I ask you for advice on how to make it cleaner or smaller?

    Example:

    Code:
    Type 1 to run the program
    1
    
    
    Enter a sentence, all lower case.
    Rename X and Y with words, the new word must have both a letter and vowel in it.
    
    Formats of sentences:
    
    no X is Y
    
    no dog is here
    
    __________________________________________
    
    Type Celarent (EAE-1) Syllogism pattern
    
    No M is P
    S are M
    No S is P
    
    
    Celarent
    
    no dog is here.
    bloodhound are dog.
    no bloodhound is here
    
    __________________________________________
    
    
    Was the syllogism logical? 1 for yes, 0 for no:
    The program uses two parts: a sentence generator and a syllogism conclusion maker.
    The user inputs one sentence and the code creates the rest of the syllogism.
    The S word in the minor premise is created by randomly choosing a word from a list of words. I use kelvins word list 12 dictionaries, "2 of 12.txt" from source-forge.

    The way the word is chosen is if it is wrong for the syllogism you mark it zero and one if it is right.
    I posted this before but I have slimmed the program down so only one syllogism is made and not every kind listed at Wikipedia. Now the code has everything it needs but only for one syllogism.

    In the code there is four key words: point, shoot, reload, auto fire.
    These translate into: point = letter as the first letter, and last letter of the word, shoot = letter as the first letter and vowel as the last letter of the word, reload = vowel as the first letter of the word and letter as the last letter of the word, auto fire = vowel as the first and last letter of the word.
    These keywords translate language into four words. so all sentences are made up of these four words. This makes the program easy to design.
    You need these text files in the same folder when you run the program:

    bad.txt

    m_and_s.txt

    readlist.txt

    readtext.txt

    writelist.txt

    readtext1.txt

    readfile.txt, this one needs kevins word list from sourceforge, Official 12Dicts Package, 2 of 12.txt contents.

    Here is the code:

    Code:
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <ctype.h>
    #define C_PLUS 4096
    #define BASELINE 4096
    #define C_PLUS_PLUS 4096
    #define D_PLUS 4096
    #define D_PLUS_PLUS 4096
    #define E_PLUS 4096
    #define E_PLUS_PLUS 4096
    #define F_PLUS 4096
    #define F_PLUS_PLUS 4096
    #define G_PLUS 4096
    #define G_PLUS_PLUS 4096
    #define H_PLUS 4096
    #define H_PLUS_PLUS 4096
    #define I_PLUS 4096
    #define I_PLUS_PLUS 4096
    #define J_PLUS 4096
    #define J_PLUS_PLUS 4096
    #define K_PLUS 4096
    #define REVIEW 4096
    #define LINES 4096
    #define CODELINES 4096
    #define BUFFERLINES 4096
    #define MAX_STRING 4096
    #define SENTENCELINES 4096
    #define WORD_ONE 4096
    #define WORD_TWO 4096	
    #define WORD_THREE 4096
    #define WORD_FOUR 4096
    #define WORD_FIVE 4096
    #define WORD_SIX 4096
    #define WORD_SEVEN 4096
    #define WORD_EIGHT 4096
    #define MAX_STRING 4096
    #define LINES 4096
    #define STRING 4096
    
    #define CELARENT_WORD_ONE 4096
    #define CELARENT_WORD_TWO 4096
    #define CELARENT_WORD_THREE 4096
    #define CELARENT_WORD_FOUR 4096
    #define CELARENT_WORD_FIVE 4096
    #define CELARENT_WORD_SIX 4096
    #define CELARENT_WORD_SEVEN 4096
    
    #define CD_WORD_ONE 4096
    #define CD_WORD_TWO 4096
    #define CD_WORD_THREE 4096
    #define CF_WORD_ONE 4096
    #define CF_WORD_TWO 4096
    #define CF_WORD_THREE 4096
    #define CF_WORD_FOUR 4096
    #define B_WORD_ONE 4096
    #define B_WORD_TWO 4096
    #define B_WORD_THREE 4096
    #define B_WORD_FOUR 4096
    #define B_WORD_FIVE 4096
    
    // These static const chars are for the syllogism program section, but I thought it looked better at the top.
    
    // "shoot\M\nreload\P\S\nautofire\M\n",
    static const char *Celarent[] = {
    	"shoot\npoint\nreload\npoint\npoint\nautofire\npoint\n",
    	"shoot\npoint\nreload\npoint\nshoot\nautofire\npoint\n",
    	"shoot\npoint\nreload\npoint\nreload\nautofire\npoint\n",
    	"shoot\npoint\nreload\npoint\nautofire\nautofire\npoint\n",
    	"shoot\npoint\nreload\nshoot\npoint\nautofire\npoint\n",
    	"shoot\npoint\nreload\nshoot\nshoot\nautofire\npoint\n",
    	"shoot\npoint\nreload\nshoot\nreload\nautofire\npoint\n",
    	"shoot\npoint\nreload\nshoot\nautofire\nautofire\npoint\n",
    	"shoot\npoint\nreload\nreload\npoint\nautofire\npoint\n",
    	"shoot\npoint\nreload\nreload\nshoot\nautofire\npoint\n",
    	"shoot\npoint\nreload\nreload\nreload\nautofire\npoint\n",
    	"shoot\npoint\nreload\nreload\nautofire\nautofire\npoint\n",
    	"shoot\npoint\nreload\nautofire\npoint\nautofire\npoint\n",
    	"shoot\npoint\nreload\nautofire\nshoot\nautofire\npoint\n",
    	"shoot\npoint\nreload\nautofire\nreload\nautofire\npoint\n",
    	"shoot\npoint\nreload\nautofire\nautofire\nautofire\npoint\n",
    	"shoot\nshoot\nreload\npoint\npoint\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\npoint\nshoot\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\npoint\nreload\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\npoint\nautofire\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nshoot\npoint\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nshoot\nshoot\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nshoot\nreload\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nshoot\nautofire\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nreload\npoint\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nreload\nshoot\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nreload\nreload\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nreload\nautofire\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nautofire\npoint\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nautofire\nshoot\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nautofire\nreload\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nautofire\nautofire\nautofire\nshoot\n",
    	"shoot\nreload\nreload\npoint\npoint\nautofire\nreload\n",
    	"shoot\nreload\nreload\npoint\nshoot\nautofire\nreload\n",
    	"shoot\nreload\nreload\npoint\nreload\nautofire\nreload\n",
    	"shoot\nreload\nreload\npoint\nautofire\nautofire\nreload\n",
    	"shoot\nreload\nreload\nshoot\npoint\nautofire\nreload\n",
    	"shoot\nreload\nreload\nshoot\nshoot\nautofire\nreload\n",
    	"shoot\nreload\nreload\nshoot\nreload\nautofire\nreload\n",
    	"shoot\nreload\nreload\nshoot\nautofire\nautofire\nreload\n",
    	"shoot\nreload\nreload\nreload\npoint\nautofire\nreload\n",
    	"shoot\nreload\nreload\nreload\nshoot\nautofire\nreload\n",
    	"shoot\nreload\nreload\nreload\nreload\nautofire\nreload\n",
    	"shoot\nreload\nreload\nreload\nautofire\nautofire\nreload\n",
    	"shoot\nreload\nreload\nautofire\npoint\nautofire\nreload\n",
    	"shoot\nreload\nreload\nautofire\nshoot\nautofire\nreload\n",
    	"shoot\nreload\nreload\nautofire\nreload\nautofire\nreload\n",
    	"shoot\nreload\nreload\nautofire\nautofire\nautofire\nreload\n",
    	"shoot\nautofire\nreload\npoint\npoint\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\npoint\nshoot\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\npoint\nreload\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\npoint\nautofire\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nshoot\npoint\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nshoot\nshoot\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nshoot\nreload\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nshoot\nautofire\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nreload\npoint\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nreload\nshoot\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nreload\nreload\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nreload\nautofire\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nautofire\npoint\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nautofire\nshoot\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nautofire\nreload\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nautofire\nautofire\nautofire\nautofire\n",
    };
    
    static const char *syllogism[] = {
    	"Type Celarent (EAE-1) Syllogism pattern\n\nNo M is P\nS are M\nNo S is P\n\n"
    };
    
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    /* Sentence generator section begin */
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    
    /* The function used to delete the newline character so that the sentences look formatted */
    
    void delete_char(char *src, char n, int len)
    {
    	char *dst;
    	int i;
    
    	// Do not remove NULL characters.
    	if ( n == 0 )
    		return;
    
    	// Small attempt to control a buffer overflow if the
    	// the string is not null-terminated and a proper length
    	// is not specified.
    	if ( len <= 0 )
    		len = MAX_STRING;
    
    	dst = src;
    
    	for ( i = 0; i < len && *src != 0; i++, src++ )
    	{
    		if ( *src != n )
    			*dst++ = *src;
    	}
    
    	// Ensure the string is null-terminated.
    	*dst = 0;
    
    	return;
    }
    /* The function to search text file for compatible word */
    
    void search(char *src, char *a, char *b, char *c)
    {
    	FILE *sp;
    	FILE *read_bad;
    	FILE *write;
    	char used[300] = {0};
    	char byte [4] = {0};
    	char bit [4] = {0};
    	char c_plus[C_PLUS] = {0};
    	char baseline[BASELINE] = {0};
    	char c_plus_plus[C_PLUS_PLUS] = {0};
    	char d_plus[D_PLUS] = {0};
    	char d_plus_plus[D_PLUS_PLUS] = {0};
    	char e_plus[E_PLUS] = {0};
    	char e_plus_plus[E_PLUS_PLUS] = {0};
    	char f_plus[F_PLUS] = {0};
    	char f_plus_plus[F_PLUS_PLUS] = {0};
    	char g_plus[G_PLUS] = {0};
    	char g_plus_plus[G_PLUS_PLUS] = {0};
    	char h_plus[H_PLUS] = {0};
    	char h_plus_plus[H_PLUS_PLUS] = {0};
    	char i_plus[I_PLUS] = {0};
    	char i_plus_plus[I_PLUS_PLUS] = {0};
    	char j_plus[J_PLUS] = {0};
    	char j_plus_plus[J_PLUS_PLUS] = {0};
    	char k_plus[K_PLUS] = {0};
    	char *filedata = malloc(300);
    	char *base = malloc(300);
    	char *c_c = malloc(300);
    	char *_d = malloc(300);
    	char *d_d = malloc(300);
    	char *_e = malloc(300);
    	char *e_e = malloc(300);
    	char *_f = malloc(300);
    	char *f_f = malloc(300);
    	char *_g = malloc(300);
    	char *g_g = malloc(300);
    	char *_h = malloc(300);
    	char *h_h = malloc(300);
    	char *_i = malloc(300);
    	char *i_i = malloc(300);
    	char *_j = malloc(300);
    	char *j_j = malloc(300);
    	char *_k = malloc(300);
    	char *list_of_bad = malloc(300);
    	char *copy = malloc(500);
    	int _c = 0;
    	int _b = 0;
    	int cc = 0;
    	int d = 0;
    	int dd = 0;
    	int e = 0;
    	int ee = 0;
    	int f = 0;
    	int ff = 0;
    	int g = 0;
    	int gg = 0;
    	int h = 0;
    	int hh = 0;
    	int i = 0;
    	int ii = 0;
    	int j = 0;
    	int jj = 0;
    	int k = 0;
    	int number = 0;
    	sp = fopen("readfile.txt", "r");
    	if(!sp)
    	{
    		perror("Error: file readlist.txt was not found or opened");
    		return;
    	}
    	write = fopen("m_and_s.txt", "w");
    	read_bad = fopen("bad.txt", "r");
    	delete_char(c, '\n', 0);
    	// The printf and scanf are for the switch statement code.
    	/*printf("\nEnter a result number\n");
    	scanf("%d", &n);*/
    	while(fgets(filedata, 4096, sp)!=NULL)
    	{
    		bit[0] = filedata[0];
    		byte[0] = filedata[strlen(filedata)-2];
    
    		// I look at the first letter in the word from the file
    		// and compare it to a, and the word from the file must also must have b in it somewhere.
    
    		if( (strpbrk(filedata, a)) && (!strncmp (byte, b, 1)) || (!strncmp (bit, b, 1)) )
    		{
    			number++;
    
    			/* Save the result from this number for later use */
    
    			if(number==17)
    				strcpy(base, filedata);
    			if(number==70)
    				strcpy(c_c, filedata);
    			if(number==71)
    				strcpy(_d, filedata);
    			if(number==72)
    				strcpy(d_d, filedata);
    			if(number==73)
    				strcpy(_e, filedata);
    			if(number==74)
    				strcpy(e_e, filedata);
    			if(number==75)
    				strcpy(_f, filedata);
    			if(number==76)
    				strcpy(f_f, filedata);
    			if(number==77)
    				strcpy(_g, filedata);
    			if(number==78)
    				strcpy(g_g, filedata);
    			if(number==79)
    				strcpy(_h, filedata);
    			if(number==80)
    				strcpy(h_h, filedata);
    			if(number==81)
    				strcpy(_i, filedata);
    			if(number==82)
    				strcpy(i_i, filedata);
    			if(number==83)
    				strcpy(_j, filedata);
    			if(number==84)
    				strcpy(j_j, filedata);
    			if(number==85)
    				strcpy(_k, filedata);
    
    			// I commented out the switch statement. The switch helped me tweak the while loop below number++.
    			/*switch(n)
    			{
    
    
    			case 1:
    			{
    			while(number < 19)
    			{
    			if(number==18)
    			strcat(src, filedata);
    			break;
    			}
    			}
    			break;
    
    			case 2:
    			{
    			while(number < 20)
    			{
    			if(number==19)
    			strcat(src, filedata);
    			break;
    			}
    			}
    			break;
    
    			case 3:
    			{
    			while(number < 21)
    			{
    			if(number==20)
    			strcat(src, filedata);
    			break;
    			}
    			}
    			break;
    
    			case 4:
    			{
    			while(number < 22)
    			{
    			if(number==21)
    			strcat(src, filedata);
    			break;
    			}
    			}
    			break;
    
    			case 5:
    			{
    			while(number < 23)
    			{
    			if(number==22)
    			strcat(src, filedata);
    			break;
    			}
    			}
    			break;
    
    			case 6:
    			{
    			while(number < 24)
    			{
    			if(number==23)
    			strcat(src, filedata);
    			break;
    			}
    			}
    			break;
    
    			case 7:
    			{
    			while(number < 25)
    			{
    			if(number==24)
    			strcat(src, filedata);
    			break;
    			}
    			}
    			break;
    
    			case 8:
    			{
    			while(number < 26)
    			{
    			if(number==25)
    			strcat(src, filedata);
    			break;
    			}
    			}
    			break;
    
    			case 9:
    			{*/
    
    			if(number==86)
    			{
    				/* create a sentence to compare to the sentence in the bad.txt */
    
    				memmove(c_plus, c, strlen(c)+1);
    				strcat(c_plus, " ");
    				strcat(c_plus, filedata);
    
    				memmove(baseline, c, strlen(c)+1);
    				strcat(baseline, " ");
    				strcat(baseline, base);
    
    				memmove(c_plus_plus, c, strlen(c)+1);
    				strcat(c_plus_plus, " ");
    				strcat(c_plus_plus, c_c);
    
    				memmove(d_plus, c, strlen(c)+1);
    				strcat(d_plus, " ");
    				strcat(d_plus, _d);
    
    				memmove(d_plus_plus, c, strlen(c)+1);
    				strcat(d_plus_plus, " ");
    				strcat(d_plus_plus, d_d);
    
    				memmove(e_plus, c, strlen(c)+1);
    				strcat(e_plus, " ");
    				strcat(e_plus, _e);
    
    				memmove(e_plus_plus, c, strlen(c)+1);
    				strcat(e_plus_plus, " ");
    				strcat(e_plus_plus, e_e);
    
    				memmove(f_plus, c, strlen(c)+1);
    				strcat(f_plus, " ");
    				strcat(f_plus, _f);
    
    				memmove(f_plus_plus, c, strlen(c)+1);
    				strcat(f_plus_plus, " ");
    				strcat(f_plus_plus, f_f);
    
    				memmove(g_plus, c, strlen(c)+1);
    				strcat(g_plus, " ");
    				strcat(g_plus, _g);
    
    				memmove(g_plus_plus, c, strlen(c)+1);
    				strcat(g_plus_plus, " ");
    				strcat(g_plus_plus, g_g);
    
    				memmove(h_plus, c, strlen(c)+1);
    				strcat(h_plus, " ");
    				strcat(h_plus, _h);
    				//
    				memmove(h_plus_plus, c, strlen(c)+1);
    				strcat(h_plus_plus, " ");
    				strcat(h_plus_plus, h_h);
    
    				memmove(i_plus, c, strlen(c)+1);
    				strcat(i_plus, " ");
    				strcat(i_plus, _i);
    
    				memmove(i_plus_plus, c, strlen(c)+1);
    				strcat(i_plus_plus, " ");
    				strcat(i_plus_plus, i_i);
    
    				memmove(j_plus, c, strlen(c)+1);
    				strcat(j_plus, " ");
    				strcat(j_plus, _j);
    
    				memmove(j_plus_plus, c, strlen(c)+1);
    				strcat(j_plus_plus, " ");
    				strcat(j_plus_plus, j_j);
    
    				memmove(k_plus, c, strlen(c)+1);
    				strcat(k_plus, " ");
    				strcat(k_plus, _k);
    
    				/* The bad.txt is opened and compared to the sentence made in the previous step */
    
    				while(fgets(list_of_bad, 4096, read_bad)!=NULL)
    				{
    					if(!strcoll(c_plus, list_of_bad))
    					{
    						_c++;
    					}
    					else if(!strcoll(baseline, list_of_bad))
    					{
    						_b++;
    					}
    					else if(!strcoll(c_plus_plus, list_of_bad))
    					{
    						cc++;
    					}
    					else if(!strcoll(d_plus, list_of_bad))
    					{
    						d++;
    					}
    					else if(!strcoll(d_plus_plus, list_of_bad))
    					{
    						dd++;
    					}
    					else if(!strcoll(e_plus, list_of_bad))
    					{
    						e++;
    					}
    					else if(!strcoll(e_plus_plus, list_of_bad))
    					{
    						ee++;
    					}
    					else if(!strcoll(f_plus, list_of_bad))
    					{
    						f++;
    					}
    					else if(!strcoll(f_plus_plus, list_of_bad))
    					{
    						ff++;
    					}
    					else if(!strcoll(g_plus, list_of_bad))
    					{
    						g++;
    					}
    					else if(!strcoll(g_plus_plus, list_of_bad))
    					{
    						gg++;
    					}
    					else if(!strcoll(h_plus, list_of_bad))
    					{
    						h++;
    					}
    					//
    					else if(!strcoll(h_plus_plus, list_of_bad))
    					{
    						hh++;
    					}
    					else if(!strcoll(i_plus, list_of_bad))
    					{
    						i++;
    					}
    					else if(!strcoll(i_plus_plus, list_of_bad))
    					{
    						ii++;
    					}
    					else if(!strcoll(j_plus, list_of_bad))
    					{
    						j++;
    					}
    					else if(!strcoll(j_plus_plus, list_of_bad))
    					{
    						jj++;
    					}
    					else if(!strcoll(k_plus, list_of_bad))
    					{
    						k++;
    					}
    				}
    
    				/* If the result from the previous step added to their int number, then these will not run */
    				if(_c == 0)
    				{
    					strcat(src, filedata);
    					fprintf(write, "%s %s\n", c, filedata);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(cc == 0)
    				{
    					strcat(src, c_c);
    					fprintf(write, "%s %s\n", c, c_c);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(d == 0)
    				{
    					strcat(src, _d);
    					fprintf(write, "%s %s\n", c, _d);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(dd == 0)
    				{
    					strcat(src, d_d);
    					fprintf(write, "%s %s\n", c, d_d);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(e == 0)
    				{
    					strcat(src, _e);
    					fprintf(write, "%s %s\n", c, _e);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(ee == 0)
    				{
    					strcat(src, e_e);
    					fprintf(write, "%s %s\n", c, e_e);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(f == 0)
    				{
    					strcat(src, _f);
    					fprintf(write, "%s %s\n", c, _f);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(ff == 0)
    				{
    					strcat(src, f_f);
    					fprintf(write, "%s %s\n", c, f_f);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(g == 0)
    				{
    					strcat(src, _g);
    					fprintf(write, "%s %s\n", c, _g);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(gg == 0)
    				{
    					strcat(src, g_g);
    					fprintf(write, "%s %s\n", c, g_g);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(h == 0)
    				{
    					strcat(src, _h);
    					fprintf(write, "%s %s\n", c, _h);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(hh == 0)
    				{
    					strcat(src, h_h);
    					fprintf(write, "%s %s\n", c, h_h);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(i == 0)
    				{
    					strcat(src, _i);
    					fprintf(write, "%s %s\n", c, _i);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(ii == 0)
    				{
    					strcat(src,i_i);
    					fprintf(write, "%s %s\n", c, i_i);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(j == 0)
    				{
    					strcat(src, _j);
    					fprintf(write, "%s %s\n", c, _j);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(jj == 0)
    				{
    					strcat(src, j_j);
    					fprintf(write, "%s %s\n", c, j_j);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(k == 0)
    				{
    					strcat(src, _k);
    					fprintf(write, "%s %s\n", c, _k);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(_b == 0)
    				{
    					strcat(src, baseline);
    					fprintf(write, "%s %s\n", c, baseline);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    			}
    
    
    			/*while(number < 38)
    			{
    			if(number==37)
    			strcat(src, filedata);
    			else if(filedata == NULL)
    			{
    			fgets(filedata, 4096, sp);
    			strcat(src, filedata);
    			}
    			break;
    			}*/
    			/*}
    			break;
    
    			default:
    			{
    			while(number < 5)
    			{
    			if(number==4)
    			strcat(src, filedata);
    			break;
    			}
    			}
    
    
    			}*/
    		}
    
    	}
    
    	fclose(read_bad);
    	fclose(write);
    	fclose(sp);
    
    	free(list_of_bad);
    
    	free(_k);
    	free(j_j);
    	free(_j);
    	free(i_i);
    	free(_i);
    	free(h_h);
    	free(_h);
    	free(g_g);
    	free(_g);
    	free(f_f);
    	free(_f);
    	free(e_e);
    	free(_e);
    	free(d_d);
    	free(_d);
    	free(c_c);
    	free(baseline);
    	free(filedata);
    
    	return;
    }
    
    /* the sentence generator program */ 
    void sentence_generator()
    {
    	/* I declare my variables */
    
    	FILE *sp;
    	FILE *fp;
    
    	// These arrays are used in fprintf at the bottom of the program
    
    	char Celarent_one[CELARENT_WORD_ONE] = {0};
    	char Celarent_two[CELARENT_WORD_TWO] = {0};
    	char Celarent_three[CELARENT_WORD_THREE] = {0};
    	char Celarent_four[CELARENT_WORD_FOUR] = {0};
    	char Celarent_five[CELARENT_WORD_FIVE] = {0};
    	char Celarent_six[CELARENT_WORD_SIX] = {0};
    	char Celarent_seven[CELARENT_WORD_SEVEN] = {0};
    
    	// These arrays are used for the program to run
    
    	char C_D_one[CD_WORD_ONE] = {0};
    	char C_D_two[CD_WORD_TWO] = {0};
    	char C_D_three[CD_WORD_THREE] = {0};
    
    	char C_F_one[CF_WORD_ONE] = {0};
    	char C_F_two[CF_WORD_TWO] = {0};
    	char C_F_three[CF_WORD_THREE] = {0};
    	char C_F_four[CF_WORD_FOUR] = {0};
    
    	char B_one[B_WORD_ONE] = {0};
    	char B_two[B_WORD_TWO] = {0};
    	char B_three[B_WORD_THREE] = {0};
    	char B_four[B_WORD_FOUR] = {0};
    	char B_five[B_WORD_FIVE] = {0};
    
    	char mystring[STRING] = {0};
    	char buf1[MAX_STRING];
    	char * pch = malloc(300);
    	int sentence_count = 0;
    	int a = 0;
    	int b = 0;
    	int c = 0;
    	int zero = 0;
    
    	fp = fopen("readtext1.txt", "w");
    
    	if(!fp)   
    	{
    		perror("Error: file readtext1.txt was not found or opened");   
    		return;   
    	}
    	/* I ask the user to enter text */
    
    	fgets(mystring, 4096, stdin);
    
    	/* I input a string and it is checked to see which while loop will process it.
    	I use the while loop to give a word value to a array which is checked by the if statements in the next step */
    	if ((strstr(mystring, "no")) && (strstr(mystring, "is")) &&! (strstr(mystring, "are")) &&! (strstr(mystring,"not")) )
    	{
    		pch = strtok(mystring, " ");
    		while(pch != NULL)
    		{
    			sentence_count++;
    
    			if (sentence_count == 1 )
    			{
    				strcat(C_F_one, pch);
    			}
    			else if (sentence_count == 2 )
    			{
    				strcat(C_F_two, pch);
    			}
    			else if (sentence_count == 3 )
    			{
    				strcat(C_F_three, pch);
    			}
    			else if (sentence_count == 4 )
    			{
    				strcat(C_F_four, pch);
    			}
    
    			pch = strtok (NULL, " ");
    		}
    		b++;                
    	}
    
    	/* I check the word from the while loop to see what char values it has, so these values are passed to the search function.
    	The search function then returns a word value from a list of words.*/
    
    	/* _____________________________________________________________________________ */
    	if(strpbrk(C_F_one, "a"))
    	{
    		if(strpbrk(C_F_one, "b"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "c"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "d"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "f"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "g"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "h"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "j"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "k"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "l"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "m"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "n"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "p"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "q"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "r"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "s"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "t"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "v"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "w"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "x"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "z"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    	}
    	else if(strpbrk(C_F_one, "e"))
    	{
    		if(strpbrk(C_F_one, "b"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "c"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "d"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "f"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "g"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "h"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "j"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "k"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "l"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "m"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "n"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "p"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "q"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "r"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "s"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "t"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "v"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "w"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "x"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "z"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    	}
    	else if(strpbrk(C_F_one, "i"))
    	{
    		if(strpbrk(C_F_one, "b"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "c"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "d"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "f"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "g"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "h"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "j"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "k"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "l"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "m"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "n"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "p"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "q"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "r"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "s"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "t"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "v"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "w"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "x"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "z"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    	}
    	else if(strpbrk(C_F_one, "o"))
    	{
    		if(strpbrk(C_F_one, "b"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "c"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "d"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "f"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "g"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "h"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "j"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "k"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "l"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "m"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "n"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "p"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "q"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "r"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "s"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "t"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "v"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "w"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "x"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "z"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    	}
    	else if(strpbrk(C_F_one, "u"))
    	{
    		if(strpbrk(C_F_one, "b"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "c"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "d"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "f"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "g"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "h"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "j"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "k"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "l"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "m"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "n"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "p"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "q"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "r"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "s"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "t"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "v"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "w"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "x"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "z"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    	}
    	else if(strpbrk(C_F_one, "y"))
    	{
    		if(strpbrk(C_F_one, "b"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "c"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "d"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "f"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "g"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "h"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "j"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "k"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "l"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "m"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "n"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "p"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "q"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "r"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "s"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "t"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "v"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "w"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "x"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    		else if(strpbrk(C_F_one, "z"))
    		{
    			strcat(Celarent_one, C_F_one);
    		}
    	}
    
    	/* _____________________________________________________________________________ */
    	if(strpbrk(C_F_two, "a"))
    	{
    		if(strpbrk(C_F_two, "b"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "b", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "c"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "c", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "d"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "d", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "f"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "f", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "g"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "g", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "h"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "h", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "j"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "j", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "k"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "k", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "l"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "l", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "m"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "m", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "n"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "n", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "p"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "p", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "q"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "q", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "r"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "r", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "s"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "s", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "t"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "t", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "v"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "v", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "w"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "w", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "x"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "x", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "z"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "z", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    	}
    	else if(strpbrk(C_F_two, "e"))
    	{
    		if(strpbrk(C_F_two, "b"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "b", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "c"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "c", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "d"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "d", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "f"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "f", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "g"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "g", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "h"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "h", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "j"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "j", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "k"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "k", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "l"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "l", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "m"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "m", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "n"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "n", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "p"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "p", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "q"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "q", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "r"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "r", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "s"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "s", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "t"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "t", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "v"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "v", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "w"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "w", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "x"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "x", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "z"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "z", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    	}
    	else if(strpbrk(C_F_two, "i"))
    	{
    		if(strpbrk(C_F_two, "b"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "b", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "c"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "c", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "d"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "d", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "f"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "f", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "g"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "g", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "h"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "h", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "j"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "j", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "k"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "k", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "l"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "l", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "m"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "m", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "n"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "n", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "p"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "p", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "q"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "q", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "r"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "r", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "s"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "s", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "t"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "t", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "v"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "v", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "w"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "w", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "x"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "x", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "z"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "z", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    	}
    	else if(strpbrk(C_F_two, "o"))
    	{
    		if(strpbrk(C_F_two, "b"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "b", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "c"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "c", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "d"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "d", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "f"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "f", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "g"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "g", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "h"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "h", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "j"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "j", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "k"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "k", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "l"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "l", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "m"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "m", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "n"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "n", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "p"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "p", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "q"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "q", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "r"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "r", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "s"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "s", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "t"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "t", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "v"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "v", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "w"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "w", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "x"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "x", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "z"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "z", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    	}
    	else if(strpbrk(C_F_two, "u"))
    	{
    		if(strpbrk(C_F_two, "b"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "b", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "c"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "c", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "d"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "d", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "f"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "f", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "g"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "g", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "h"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "h", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "j"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "j", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "k"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "k", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "l"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "l", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "m"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "m", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "n"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "n", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "p"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "p", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "q"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "q", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "r"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "r", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "s"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "s", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "t"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "t", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "v"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "v", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "w"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "w", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "x"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "x", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "z"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "z", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    	}
    	else if(strpbrk(C_F_two, "y"))
    	{
    		if(strpbrk(C_F_two, "b"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "b", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "c"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "c", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "d"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "d", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "f"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "f", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "g"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "g", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "h"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "h", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "j"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "j", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "k"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "k", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "l"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "l", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "m"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "m", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "n"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "n", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "p"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "p", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "q"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "q", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "r"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "r", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "s"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "s", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "t"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "t", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "v"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "v", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "w"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "w", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "x"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "x", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "z"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "z", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    	}
    	/* _____________________________________________________________________________ */
    	if(strpbrk(C_F_three, "a"))
    	{
    		if(strpbrk(C_F_three, "b"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "c"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "d"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "f"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "g"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "h"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "j"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "k"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "l"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "m"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "n"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "p"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "q"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "r"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "s"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "t"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "v"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "w"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "x"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "z"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    	}
    	else if(strpbrk(C_F_three, "e"))
    	{
    		if(strpbrk(C_F_three, "b"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "c"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "d"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "f"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "g"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "h"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "j"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "k"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "l"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "m"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "n"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "p"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "q"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "r"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "s"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "t"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "v"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "w"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "x"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "z"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    	}
    	else if(strpbrk(C_F_three, "i"))
    	{
    		if(strpbrk(C_F_three, "b"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "c"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "d"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "f"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "g"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "h"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "j"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "k"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "l"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "m"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "n"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "p"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "q"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "r"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "s"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "t"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "v"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "w"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "x"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "z"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    	}
    	else if(strpbrk(C_F_three, "o"))
    	{
    		if(strpbrk(C_F_three, "b"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "c"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "d"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "f"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "g"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "h"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "j"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "k"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "l"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "m"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "n"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "p"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "q"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "r"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "s"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "t"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "v"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "w"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "x"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "z"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    	}
    	else if(strpbrk(C_F_three, "u"))
    	{
    		if(strpbrk(C_F_three, "b"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "c"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "d"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "f"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "g"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "h"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "j"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "k"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "l"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "m"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "n"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "p"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "q"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "r"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "s"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "t"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "v"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "w"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "x"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "z"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    	}
    	else if(strpbrk(C_F_three, "y"))
    	{
    		if(strpbrk(C_F_three, "b"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "c"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "d"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "f"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "g"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "h"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "j"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "k"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "l"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "m"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "n"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "p"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "q"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "r"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "s"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "t"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "v"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "w"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "x"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    		else if(strpbrk(C_F_three, "z"))
    		{
    			strcat(Celarent_three, C_F_three);
    		}
    	}
    	/* _____________________________________________________________________________ */
    	if(strpbrk(C_F_four, "a"))
    	{
    		if(strpbrk(C_F_four, "b"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "c"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "d"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "f"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "g"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "h"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "j"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "k"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "l"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "m"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "n"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "p"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "q"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "r"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "s"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "t"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "v"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "w"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "x"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "z"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    	}
    	else if(strpbrk(C_F_four, "e"))
    	{
    		if(strpbrk(C_F_four, "b"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "c"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "d"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "f"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "g"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "h"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "j"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "k"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "l"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "m"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "n"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "p"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "q"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "r"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "s"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "t"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "v"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "w"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "x"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "z"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    	}
    	else if(strpbrk(C_F_four, "i"))
    	{
    		if(strpbrk(C_F_four, "b"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "c"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "d"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "f"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "g"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "h"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "j"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "k"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "l"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "m"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "n"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "p"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "q"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "r"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "s"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "t"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "v"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "w"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "x"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "z"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    	}
    	else if(strpbrk(C_F_four, "o"))
    	{
    		if(strpbrk(C_F_four, "b"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "c"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "d"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "f"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "g"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "h"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "j"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "k"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "l"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "m"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "n"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "p"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "q"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "r"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "s"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "t"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "v"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "w"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "x"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "z"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    	}
    	else if(strpbrk(C_F_four, "u"))
    	{
    		if(strpbrk(C_F_four, "b"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "c"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "d"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "f"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "g"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "h"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "j"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "k"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "l"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "m"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "n"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "p"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "q"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "r"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "s"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "t"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "v"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "w"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "x"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "z"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    	}
    	else if(strpbrk(C_F_four, "y"))
    	{
    		if(strpbrk(C_F_four, "b"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "c"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "d"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "f"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "g"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "h"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "j"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "k"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "l"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "m"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "n"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "p"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "q"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "r"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "s"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "t"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "v"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "w"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "x"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    		else if(strpbrk(C_F_four, "z"))
    		{
    			strcat(Celarent_four, C_F_four);
    		}
    	}
    	/* _____________________________________________________________________________ */
    
    	/* I add string values to the variables not in the previous step. */
    
    	strcat(Celarent_six, "are");
    	strcat(Celarent_seven, Celarent_two);
    
    	/* I get rid of the newline so the sentences look formated, or else the sentences are on different lines */
    
    	delete_char(Celarent_one, '\n', 0);
    	delete_char(Celarent_two, '\n', 0);
    	delete_char(Celarent_three, '\n', 0);
    	delete_char(Celarent_four, '\n', 0);
    	delete_char(Celarent_five, '\n', 0);
    	delete_char(Celarent_six, '\n', 0);
    	delete_char(Celarent_seven, '\n', 0);
    
    	/* I write the results to file */
    
    	if(b > zero)
    	{
    		fprintf(fp, "%s %s %s %s.\n%s %s %s.\n", Celarent_one, Celarent_two, Celarent_three, Celarent_four, 
    			Celarent_five, Celarent_six, Celarent_seven);
    	}
    
    	/* I memset the arrays */
    
    	memset(&Celarent_one[0], 0, sizeof(Celarent_one));
    	memset(&Celarent_two[0], 0, sizeof(Celarent_two));
    	memset(&Celarent_three[0], 0, sizeof(Celarent_three));
    	memset(&Celarent_four[0], 0, sizeof(Celarent_four));
    	memset(&Celarent_five[0], 0, sizeof(Celarent_five));
    	memset(&Celarent_six[0], 0, sizeof(Celarent_six));
    	memset(&Celarent_seven[0], 0, sizeof(Celarent_seven));
    
    	memset(&C_D_one[0], 0, sizeof(C_D_one));
    	memset(&C_D_two[0], 0, sizeof(C_D_two));
    	memset(&C_D_three[0], 0, sizeof(C_D_three));
    
    	memset(&C_F_one[0], 0, sizeof(C_F_one));
    	memset(&C_F_two[0], 0, sizeof(C_F_two));
    	memset(&C_F_three[0], 0, sizeof(C_F_three));
    	memset(&C_F_four[0], 0, sizeof(C_F_four));
    
    	memset(&B_one[0], 0, sizeof(B_one));
    	memset(&B_two[0], 0, sizeof(B_two));
    	memset(&B_three[0], 0, sizeof(B_three));
    	memset(&B_four[0], 0, sizeof(B_four));
    	memset(&B_five[0], 0, sizeof(B_five));
    
    	free(mystring);
    	free(pch);
    	sentence_count = 0;
    	a = 0;
    	b = 0;
    	c = 0;
    	fclose(fp);
    	return;
    }
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    /* Sentence generator section end */
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    /* Syllogism section begin */
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    char red;
    
    /* The function to split the input into a sentence per line */
    int split_by_sentence(void)
    {
    	int character, file_character=0;
    	char buffer[1024];
    	FILE *book=fopen("readtext1.txt", "r");
    	FILE *book2=fopen("readtext.txt", "a+");
    	if(!book) {printf("Error: unable to open input file!\n"); return 1;}
    	if(!book2) {printf("Error: unable to open output file!\n"); return 1;}
    
    	while(file_character!=EOF)
    	{
    		buffer[0]='\0';
    		for(character=0;character<sizeof(buffer);character++) 
    		{
    			file_character=fgetc(book);
    			if(file_character==EOF)
    				break;
    
    			if(file_character=='.')
    			{
    				buffer[character]='\0';  
    				break;
    			}
    
    			if(file_character=='?')
    			{
    				buffer[character]='\0';  
    				break;
    			}
    
    			if(file_character=='!')
    			{
    				buffer[character]='\0';  
    				break;
    			}
    
    			buffer[character]=file_character;
    		}
    
    		if(file_character==EOF)
    			break;
    		fprintf(book2, "%s.\n", buffer);
    	}
    	fclose(book);
    	fclose(book2);
    	putchar('\n');
    
    	return 0;
    }
    
    /* The function to find the first letter in the word */
    char find_letter (char* a, char* b)
    {
    	char string = strlen(b);
    	strncpy (a,b,1);
    	a[1]='\0';
    	return 0;
    }
    
    /* The function to reverse the characters in a string */
    char *reverse(char *s)
    {
    	int c, i, j;
    
    	for (i = 0, j = strlen(s)-1; i < j; i++, j--) {
    		c = s[i];
    		s[i] = s[j];
    		s[j] = c;
    	}
    	return 0;
    }
    
    /* The function to find the Celarent syllogism */
    char *Celarent_conclusion(char *sentence, int sentence_count, char *Celarent_word_one, char *Celarent_word_two, char *Celarent_word_three, char *Celarent_word_four, char *Celarent_word_five, char *Celarent_word_six, char *Celarent_word_seven)
    {
    	strtok(sentence, " ");
    	while(sentence != NULL)
    	{
    		sentence_count++;
    
    		if (sentence_count == 1 )
    		{
    			strcat(Celarent_word_one, sentence);
    		}
    		else if (sentence_count == 2 )
    		{
    			strcat(Celarent_word_two, sentence);
    		}
    		else if (sentence_count == 3 )
    		{
    			strcat(Celarent_word_three, sentence);
    		}
    		else if (sentence_count == 4 )
    		{
    			strcat(Celarent_word_four, sentence);
    		}
    		else if (sentence_count == 5 )
    		{
    			strcat(Celarent_word_five, sentence);
    		}
    		else if (sentence_count == 6 )
    		{
    			strcat(Celarent_word_six, sentence);
    		}
    		else if (sentence_count == 7 )
    		{
    			strcat(Celarent_word_seven, sentence);
    		}
    
    		else
    			printf("**\nno match\n");
    
    		sentence = strtok (NULL, " ");
    	}
    	printf("Celarent\n\n");
    	printf("%s %s %s %s.\n", Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four);
    	printf("%s %s %s.\n", Celarent_word_five, Celarent_word_six, Celarent_word_two);
    	printf("%s %s %s %s\n\n", Celarent_word_one, Celarent_word_five, Celarent_word_three, Celarent_word_four);
    
    
    
    	memset(&Celarent_word_one[0], 0, sizeof(Celarent_word_one));
    	memset(&Celarent_word_two[0], 0, sizeof(Celarent_word_two));
    	memset(&Celarent_word_three[0], 0, sizeof(Celarent_word_three));
    	memset(&Celarent_word_four[0], 0, sizeof(Celarent_word_four));
    	memset(&Celarent_word_five[0], 0, sizeof(Celarent_word_five));
    	memset(&Celarent_word_six[0], 0, sizeof(Celarent_word_six));
    	memset(&Celarent_word_seven[0], 0, sizeof(Celarent_word_seven));
    	sentence_count = 0;
    	return sentence;
    }
    
    void Celarent_percentage_calculation_numbers(char* a_pch)
    {
    	FILE *read;
    	FILE *fp;
    	char vowels[] = "aeiouyAEIOUY";
    	char letters[] = "bcdfghjklmnpqrstvwxzBCDFGHJKLMNPQRSTVWXYZ";
    	char alphabet[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    	char * pch = malloc(300);
    	char str2[7] = {0};
    	char buf1[MAX_STRING];
    	char Celarent_word_one[WORD_ONE] = {0};
    	char Celarent_word_two[WORD_TWO] = {0};
    	char Celarent_word_three[WORD_THREE] = {0};
    	char Celarent_word_four[WORD_FOUR] = {0};
    	char Celarent_word_five[WORD_FIVE] = {0};
    	char Celarent_word_six[WORD_SIX] = {0};
    	char Celarent_word_seven[WORD_SEVEN] = {0};
    	char code[CODELINES] = {0};
    	char buffer[BUFFERLINES] = {0};
    	char sentence[SENTENCELINES] = {0};
    	int period = 0;
    	int count = 0;
    	int sentence_count = 0;
    	float one;
    	float two;
    	float three;
    	float four;
    	float total;
    	float five;
    	float six;
    	float seven;
    	float eight;
    	float total_2;
    	float percentage_1;
    	float percentage_2;
    	float percentage_3;
    	float percentage_4;
    
    	one = 0;
    	two = 0;
    	three = 0;
    	four = 0;
    	total = 0;
    	five = 0;
    	six = 0;
    	seven = 0;
    	eight = 0;
    	total_2 = 0;
    	percentage_1 = 0;
    	percentage_2 = 0;
    	percentage_3 = 0;
    	percentage_4 = 0;
    
    	/* open text file or report error */
    	fp = fopen("writelist.txt", "w");
    
    	if(!fp) {printf("Error: unable to open input file!\n");}
    
    	/* Tokenize the input for the while loop */
    	strncpy(buf1, a_pch, sizeof(buf1));
    	delete_char(buf1, '.', 0);
    	delete_char(buf1, '\n', 0);
    	delete_char(buf1, '`', 0);
    	delete_char(buf1, '1', 0);
    	delete_char(buf1, '2', 0);
    	delete_char(buf1, '3', 0);
    	delete_char(buf1, '4', 0);
    	delete_char(buf1, '5', 0);
    	delete_char(buf1, '6', 0);
    	delete_char(buf1, '7', 0);
    	delete_char(buf1, '8', 0);
    	delete_char(buf1, '9', 0);
    	delete_char(buf1, '0', 0);
    	delete_char(buf1, '-', 0);
    	delete_char(buf1, '=', 0);
    	delete_char(buf1, '~', 0);
    	delete_char(buf1, '!', 0);
    	delete_char(buf1, '@', 0);
    	delete_char(buf1, '#', 0);
    	delete_char(buf1, '$', 0);
    	delete_char(buf1, '%', 0);
    	delete_char(buf1, '^', 0);
    	delete_char(buf1, '&', 0);
    	delete_char(buf1, '*', 0);
    	delete_char(buf1, '(', 0);
    	delete_char(buf1, ')', 0);
    	delete_char(buf1, '_', 0);
    	delete_char(buf1, '+', 0);
    	delete_char(buf1, '[', 0);
    	delete_char(buf1, ']', 0);
    	delete_char(buf1, '\\', 0);
    	delete_char(buf1, '{', 0);
    	delete_char(buf1, '}', 0);
    	delete_char(buf1, '|', 0);
    	delete_char(buf1, ';', 0);
    	delete_char(buf1, '\'', 0);
    	delete_char(buf1, ':', 0);
    	delete_char(buf1, '"', 0);
    	delete_char(buf1, ',', 0);
    	delete_char(buf1, '/', 0);
    	delete_char(buf1, '<', 0);
    	delete_char(buf1, '>', 0);
    	delete_char(buf1, '?', 0);
    
    	pch = strtok (buf1, " ");
    
    	/* The while loop gives value to five, six, seven, eight, which is used for the percentage calculation */
    
    	while(pch != NULL)
    	{
    		strcat(sentence, pch);
    		strcat(sentence, " ");
    		/*printf("test %s\n", pch);*/
    		/* identify the first letter in the word begin */
    
    		red = find_letter(str2, pch);
    
    		if(strpbrk(str2, letters))
    		{
    			one++;
    		}
    
    		if(strpbrk(str2, vowels))
    		{
    			two++;
    		}
    
    		/* identify the first letter in the word end */
    
    		/* identify the last letter in the word begin */
    		reverse(pch);
    
    		red = find_letter(str2, pch);
    
    		if(strpbrk(str2, letters))
    		{
    			three++;
    		}
    
    		if(strpbrk(str2, vowels))
    		{
    			four++;
    		}
    
    		/* identify the last letter in the word end */
    
    		/* The math using the first and last letter begin */
    
    		/* pch is backwards, so I use rev to reverse it back */
    		/*printf("%s uncomment to test to see if the string is backwards", pch);*/
    		reverse(pch);
    
    		/*The math using the first and last letter begin
    		Here I give the word a new string value, based on how the vowel is situated in the word.*/
    
    		if(total = (one && three))
    		{
    			five++;
    			fprintf(fp, "point\n", pch);
    		}
    
    		else if(total = (one && four))
    		{
    			six++;
    			fprintf(fp, "shoot\n", pch);
    		}
    
    		else if(total = (two && three))
    		{
    			seven++;
    			fprintf(fp, "reload\n", pch);
    		}
    
    		else if(total = (two && four))
    		{
    			eight++;
    			fprintf(fp, "autofire\n", pch);
    		}
    
    		/* The math using the first and last letter end */
    
    		/* Reset the pointers */
    
    		one = 0;
    		two = 0;
    		three = 0;
    		four = 0;
    		total = 0;
    
    		pch = strtok (NULL, " ");
    	}
    
    	/* Count the pointers */
    	total_2 = (five + six + seven + eight);
    	percentage_1 = ((five)/ total_2);
    	percentage_2 = ((six)/ total_2);
    	percentage_3 = ((seven)/ total_2);
    	percentage_4 = ((eight)/ total_2);
    
    	/* puts a period into the textfile after a sentence is processed
    	This way I can count the number of periods in the text file */
    	fprintf(fp, ".\n");
    	fclose(fp);
    	free(pch);
    	memset(&buf1[0], 0, sizeof(buf1));
    	memset(&str2[0], 0, sizeof(str2));
    	read=fopen("writelist.txt", "r");
    	if(!read) {printf("Error: unable to open input file!\n");}
    	while(fgets(buffer, sizeof(buffer), read)!=NULL)
    	{
    		/* Find the word then add it the the pch string */
    		if (strstr(buffer, "point\n"))
    		{
    			strcat(code, buffer);
    		}
    		if (strstr(buffer, "shoot\n"))
    		{
    			strcat(code, buffer);
    		}
    		if (strstr(buffer, "reload\n"))
    		{
    			strcat(code, buffer);
    		}
    		if (strstr(buffer, "autofire\n"))
    		{
    			strcat(code, buffer);
    		}
    
    		/* counting the periods in the input text file*/
    		if (strstr(buffer, "."))
    		{
    			period++;
    		}
    
    		/* After two periods are counted the while loop is exited */
    		if(period > count)
    		{
    			if(!strcoll(code, Celarent[0]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[1]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[2]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[3]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[4]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[5]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[6]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[7]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[8]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[9]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[10]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[11]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[12]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[13]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[14]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[15]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[16]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[17]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[18]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[19]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[20]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[21]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[22]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[23]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[24]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[25]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[26]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[27]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[28]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[29]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[30]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[31]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[32]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[33]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[34]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[35]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[36]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[37]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[38]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[39]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[40]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[41]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[42]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[43]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[44]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[45]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[46]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[47]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[48]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[49]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[50]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[51]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[52]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[53]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[54]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[55]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[56]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[57]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[58]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[59]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[60]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[61]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[62]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[63]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[64]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[65]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[66]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[67]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[68]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[69]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[70]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[71]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[72]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[73]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[74]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[75]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[76]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[77]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[78]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[79]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[80]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[81]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[82]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[83]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[84]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[85]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[86]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[87]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[88]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[89]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[90]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[91]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[92]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[93]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[94]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[95]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[96]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[97]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[98]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[99]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[100]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[101]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[102]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[103]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[104]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[105]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[106]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[107]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[108]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[109]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[110]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[111]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[112]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[113]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[114]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[115]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[116]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[117]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[118]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[119]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[120]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[121]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[122]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[123]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[124]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[125]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[126]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[127]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[128]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[129]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[130]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[131]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[132]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[133]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[134]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[135]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[136]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[137]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[138]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[139]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[140]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[141]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[142]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[143]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[144]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[145]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[146]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[147]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[148]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[149]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[150]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[151]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[152]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[153]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[154]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[155]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[156]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[157]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[158]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[159]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[160]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[161]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[162]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[163]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[164]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[165]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[166]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[167]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[168]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[169]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[170]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[171]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[172]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[173]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[174]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[175]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[176]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[177]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[178]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[179]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[180]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[181]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[182]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[183]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[184]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[185]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[186]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[187]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[188]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[189]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[190]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[191]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[192]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[193]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[194]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[195]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[196]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[197]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[198]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[199]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[200]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[201]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[202]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[203]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[204]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[205]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[206]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[207]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[208]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[209]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[210]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[211]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[212]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[213]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[214]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[215]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[216]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[217]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[218]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[219]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[220]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[221]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[222]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[223]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[224]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[225]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[226]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[227]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[228]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[229]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[230]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[231]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[232]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[233]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[234]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[235]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[236]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[237]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[238]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[239]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[240]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[241]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[242]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[243]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[244]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[245]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[246]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[247]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[248]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[249]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[250]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[251]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[252]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[253]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[254]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    			else if(!strcoll(code, Celarent[255]))
    			{
    				printf("__________________________________________\n\n%s\n", syllogism[0]);
    				Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    			}
    
    			if(period > count)
    			{
    				memset(&code[0], 0, sizeof(code));
    				memset(&buffer[0], 0, sizeof(buffer));
    				memset(&sentence[0], 0, sizeof(sentence));
    			}
    			period = 0;
    		}
    	}
    	fclose(read);
    }
    
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    /* Syllogism section end */
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    
    /* function so I don't have to type getch all over the place */
    void MyExit(void) { system("pause"); }
    
    /* the main program */ 
    int main ()
    {   
    	/* declaring and initiaizing variables */
    	FILE *read_to_review;
    	FILE *bad_list;
    	FILE *book;
    	FILE *a;
    	FILE *b;
    	FILE *c;
    	char * pch = malloc(300);
    	char alphabet[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    	char buffer[LINES];
    	char copy_review[REVIEW];
    	int period = 0;
    	int test_result = 0;
    	int x = 0;
    	int good = 0;
    	int one = 1;
    	char sentence[4096] = {0};
    	/* The function is called so I don't have to type getch */
    	atexit(MyExit);    
    
    	/* X recieves 1 so the program can run */
    	printf("Type 1 to run the program\n");
    	scanf("%d", &x);
    	printf("\n\nEnter a sentence, all lower case.\n");
    	printf("Rename X and Y with words, the new word must have both a letter and vowel in it.\n");
    	printf("Formats of sentences:\n\n");
    	printf("no X is Y\n");
    	while(!good) 
    	{
    		switch(x)
    		{
    		case 1:
    			{
    				/* The sentence generator section is run*/
    				sentence_generator();
    
    
    				/* Now the syllogism section begins */
    
    				/* The function is called and creates the text file */
    				split_by_sentence();
    
    				/* The text file just created is opened */
    				book = fopen("readtext.txt", "r");
    				read_to_review = fopen("m_and_s.txt", "r");
    				bad_list = fopen("bad.txt", "a+");
    				if(!book)   
    				{
    					perror("Error: file readtext.txt was not found or opened");   
    					return 0;   
    				}
    
    				/* read from file */
    				while(fgets(buffer, sizeof(buffer), book)!=NULL)
    				{ 
    					/* join two sentences */
    
    					strcat(sentence, buffer);
    					strcat(sentence, " ");
    
    					/* counting the periods in the input text file*/
    
    					if (strstr(buffer, "."))
    					{
    						period++;
    					}
    
    					/* After two periods are counted the while loop is exited */
    
    					if(period > one)
    					{
    						/* I find the alphabet in pch after it's run through strtok */
    						Celarent_percentage_calculation_numbers(sentence);
    
    						/* The printf asks if I want to keep running the program or close it */
    						fgets(copy_review, sizeof(copy_review), read_to_review);
    						printf("__________________________________________\n\n\nWas the syllogism logical? 1 for yes, 0 for no: ");
    						scanf("%d",&test_result);
    						if(test_result==0)
    							fprintf(bad_list, "%s\n", copy_review);
    						printf("Close program? 1 for yes, 0 for no: ");
    						scanf("%d",&good);
    						putchar('\n');
    						if(good==0)
    						{
    							printf("\n\nEnter a sentence, all lower case.\n");
    							printf("Rename X and Y with words, the new word must have both a letter and vowel in it.\n");
    							printf("Formats of sentences:\n\n");
    							printf("no X is Y\n");
    						}
    						if(period > one)
    						{
    							memset(&sentence[0], 0, sizeof(sentence));
    						}
    						period = 0;
    						free(pch);
    						break;
    					}
    				}
    				fclose(book);
    				fclose(bad_list);
    				fclose(read_to_review);
    				/* emptying the files so the program doesn't build them up each time it's used */
    
    				a = fopen("readtext.txt", "w");
    				if(!a)   
    				{
    					perror("Error: file readtext.txt was not found or opened");   
    					return 0;   
    				}
    				b = fopen("readtext1.txt", "w");
    				if(!b)   
    				{
    					perror("Error: file readtext1.txt was not found or opened");   
    					return 0;   
    				}
    				c = fopen("writelist.txt", "w");
    				if(!c)   
    				{
    					perror("Error: file writelist.txt was not found or opened");   
    					return 0;   
    				}
    				fprintf(a, "");
    				fprintf(b, "");
    				fprintf(c, "");
    				fclose(a);
    				fclose(b);
    				fclose(c);
    			}
    		}
    	}
    
    	return 0;
    }

  2. #2
    Registered User
    Join Date
    Nov 2011
    Location
    Saratoga, California, USA
    Posts
    334
    Starting at line 2530
    Code:
    if( strpbrk( C_F_three, "aeiouy"))
      if( strpbrk( C_F_three, "bcdfghjklmnpqrstvwxz" ))
        strcat( Celarent_three, C_F_three ) ;
    That's 500 lines of your code condensed.

    You need to recognize that when you are doing the same thing over and over again and only the parameters are changing that you should be writing it once.

    Starting at line 3969,
    Code:
    if(!strcoll(code, Celarent[0]))            {
                    printf("__________________________________________\n\n%s\n", syllogism[0]);
                    Celarent_conclusion(sentence,  sentence_count, Celarent_word_one, Celarent_word_two,  Celarent_word_three, Celarent_word_four, Celarent_word_five,  Celarent_word_six, Celarent_word_seven);
                }
    You don't hardcode indexes. Use a for() loop and an index variable to move linearly through an array. There's another 1270 lines of code to condense.

  3. #3
    - - - - - - - - oogabooga's Avatar
    Join Date
    Jan 2008
    Posts
    2,808
    I guarantee you that this 5400-line program is at least 10 times larger than it needs to be. A monument to brute-force engineering. You generally shouldn't have so many variables defined in a function, and they should have better names. That's often a clue to a bad structure/algorithm. And clearly the program cannot work as is since it has huge amounts of repetitive (unfinished or meaningless) code. And what's the logic behind the choice of words: point, shoot, reload, auto fire?

  4. #4
    Registered User
    Join Date
    Apr 2011
    Posts
    229
    It works fine. Those words are what I chose for my language interpretation, to port sentences to use only those four words. Do you want to know why I picked those words?
    Last edited by jeremy duncan; 12-22-2011 at 08:24 PM.

  5. #5
    Registered User
    Join Date
    Apr 2011
    Posts
    229
    Here's the newer version, thanks.

    Code:
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <ctype.h>
    #define C_PLUS 4096
    #define BASELINE 4096
    #define C_PLUS_PLUS 4096
    #define D_PLUS 4096
    #define D_PLUS_PLUS 4096
    #define E_PLUS 4096
    #define E_PLUS_PLUS 4096
    #define F_PLUS 4096
    #define F_PLUS_PLUS 4096
    #define G_PLUS 4096
    #define G_PLUS_PLUS 4096
    #define H_PLUS 4096
    #define H_PLUS_PLUS 4096
    #define I_PLUS 4096
    #define I_PLUS_PLUS 4096
    #define J_PLUS 4096
    #define J_PLUS_PLUS 4096
    #define K_PLUS 4096
    #define REVIEW 4096
    #define LINES 4096
    #define CODELINES 4096
    #define BUFFERLINES 4096
    #define MAX_STRING 4096
    #define SENTENCELINES 4096
    #define WORD_ONE 4096
    #define WORD_TWO 4096	
    #define WORD_THREE 4096
    #define WORD_FOUR 4096
    #define WORD_FIVE 4096
    #define WORD_SIX 4096
    #define WORD_SEVEN 4096
    #define WORD_EIGHT 4096
    #define MAX_STRING 4096
    #define LINES 4096
    #define STRING 4096
    
    #define CELARENT_WORD_ONE 4096
    #define CELARENT_WORD_TWO 4096
    #define CELARENT_WORD_THREE 4096
    #define CELARENT_WORD_FOUR 4096
    #define CELARENT_WORD_FIVE 4096
    #define CELARENT_WORD_SIX 4096
    #define CELARENT_WORD_SEVEN 4096
    
    #define CD_WORD_ONE 4096
    #define CD_WORD_TWO 4096
    #define CD_WORD_THREE 4096
    #define CF_WORD_ONE 4096
    #define CF_WORD_TWO 4096
    #define CF_WORD_THREE 4096
    #define CF_WORD_FOUR 4096
    #define B_WORD_ONE 4096
    #define B_WORD_TWO 4096
    #define B_WORD_THREE 4096
    #define B_WORD_FOUR 4096
    #define B_WORD_FIVE 4096
    
    // These static const chars are for the syllogism program section, but I thought it looked better at the top.
    
    // "shoot\M\nreload\P\S\nautofire\M\n",
    static const char *Celarent[] = {
    	"shoot\npoint\nreload\npoint\npoint\nautofire\npoint\n",
    	"shoot\npoint\nreload\npoint\nshoot\nautofire\npoint\n",
    	"shoot\npoint\nreload\npoint\nreload\nautofire\npoint\n",
    	"shoot\npoint\nreload\npoint\nautofire\nautofire\npoint\n",
    	"shoot\npoint\nreload\nshoot\npoint\nautofire\npoint\n",
    	"shoot\npoint\nreload\nshoot\nshoot\nautofire\npoint\n",
    	"shoot\npoint\nreload\nshoot\nreload\nautofire\npoint\n",
    	"shoot\npoint\nreload\nshoot\nautofire\nautofire\npoint\n",
    	"shoot\npoint\nreload\nreload\npoint\nautofire\npoint\n",
    	"shoot\npoint\nreload\nreload\nshoot\nautofire\npoint\n",
    	"shoot\npoint\nreload\nreload\nreload\nautofire\npoint\n",
    	"shoot\npoint\nreload\nreload\nautofire\nautofire\npoint\n",
    	"shoot\npoint\nreload\nautofire\npoint\nautofire\npoint\n",
    	"shoot\npoint\nreload\nautofire\nshoot\nautofire\npoint\n",
    	"shoot\npoint\nreload\nautofire\nreload\nautofire\npoint\n",
    	"shoot\npoint\nreload\nautofire\nautofire\nautofire\npoint\n",
    	"shoot\nshoot\nreload\npoint\npoint\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\npoint\nshoot\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\npoint\nreload\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\npoint\nautofire\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nshoot\npoint\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nshoot\nshoot\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nshoot\nreload\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nshoot\nautofire\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nreload\npoint\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nreload\nshoot\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nreload\nreload\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nreload\nautofire\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nautofire\npoint\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nautofire\nshoot\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nautofire\nreload\nautofire\nshoot\n",
    	"shoot\nshoot\nreload\nautofire\nautofire\nautofire\nshoot\n",
    	"shoot\nreload\nreload\npoint\npoint\nautofire\nreload\n",
    	"shoot\nreload\nreload\npoint\nshoot\nautofire\nreload\n",
    	"shoot\nreload\nreload\npoint\nreload\nautofire\nreload\n",
    	"shoot\nreload\nreload\npoint\nautofire\nautofire\nreload\n",
    	"shoot\nreload\nreload\nshoot\npoint\nautofire\nreload\n",
    	"shoot\nreload\nreload\nshoot\nshoot\nautofire\nreload\n",
    	"shoot\nreload\nreload\nshoot\nreload\nautofire\nreload\n",
    	"shoot\nreload\nreload\nshoot\nautofire\nautofire\nreload\n",
    	"shoot\nreload\nreload\nreload\npoint\nautofire\nreload\n",
    	"shoot\nreload\nreload\nreload\nshoot\nautofire\nreload\n",
    	"shoot\nreload\nreload\nreload\nreload\nautofire\nreload\n",
    	"shoot\nreload\nreload\nreload\nautofire\nautofire\nreload\n",
    	"shoot\nreload\nreload\nautofire\npoint\nautofire\nreload\n",
    	"shoot\nreload\nreload\nautofire\nshoot\nautofire\nreload\n",
    	"shoot\nreload\nreload\nautofire\nreload\nautofire\nreload\n",
    	"shoot\nreload\nreload\nautofire\nautofire\nautofire\nreload\n",
    	"shoot\nautofire\nreload\npoint\npoint\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\npoint\nshoot\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\npoint\nreload\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\npoint\nautofire\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nshoot\npoint\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nshoot\nshoot\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nshoot\nreload\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nshoot\nautofire\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nreload\npoint\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nreload\nshoot\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nreload\nreload\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nreload\nautofire\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nautofire\npoint\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nautofire\nshoot\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nautofire\nreload\nautofire\nautofire\n",
    	"shoot\nautofire\nreload\nautofire\nautofire\nautofire\nautofire\n",
    };
    
    static const char *syllogism[] = {
    	"Type Celarent (EAE-1) Syllogism pattern\n\nNo M is P\nS are M\nNo S is P\n\n"
    };
    
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    /* Sentence generator section begin */
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    
    /* The function used to delete the newline character so that the sentences look formatted */
    
    void delete_char(char *src, char n, int len)
    {
    	char *dst;
    	int i;
    
    	// Do not remove NULL characters.
    	if ( n == 0 )
    		return;
    
    	// Small attempt to control a buffer overflow if the
    	// the string is not null-terminated and a proper length
    	// is not specified.
    	if ( len <= 0 )
    		len = MAX_STRING;
    
    	dst = src;
    
    	for ( i = 0; i < len && *src != 0; i++, src++ )
    	{
    		if ( *src != n )
    			*dst++ = *src;
    	}
    
    	// Ensure the string is null-terminated.
    	*dst = 0;
    
    	return;
    }
    /* The function to search text file for compatible word */
    
    void search(char *src, char *a, char *b, char *c)
    {
    	FILE *sp;
    	FILE *read_bad;
    	FILE *write;
    	char used[300] = {0};
    	char byte [4] = {0};
    	char bit [4] = {0};
    	char c_plus[C_PLUS] = {0};
    	char baseline[BASELINE] = {0};
    	char c_plus_plus[C_PLUS_PLUS] = {0};
    	char d_plus[D_PLUS] = {0};
    	char d_plus_plus[D_PLUS_PLUS] = {0};
    	char e_plus[E_PLUS] = {0};
    	char e_plus_plus[E_PLUS_PLUS] = {0};
    	char f_plus[F_PLUS] = {0};
    	char f_plus_plus[F_PLUS_PLUS] = {0};
    	char g_plus[G_PLUS] = {0};
    	char g_plus_plus[G_PLUS_PLUS] = {0};
    	char h_plus[H_PLUS] = {0};
    	char h_plus_plus[H_PLUS_PLUS] = {0};
    	char i_plus[I_PLUS] = {0};
    	char i_plus_plus[I_PLUS_PLUS] = {0};
    	char j_plus[J_PLUS] = {0};
    	char j_plus_plus[J_PLUS_PLUS] = {0};
    	char k_plus[K_PLUS] = {0};
    	char *filedata = malloc(300);
    	char *base = malloc(300);
    	char *c_c = malloc(300);
    	char *_d = malloc(300);
    	char *d_d = malloc(300);
    	char *_e = malloc(300);
    	char *e_e = malloc(300);
    	char *_f = malloc(300);
    	char *f_f = malloc(300);
    	char *_g = malloc(300);
    	char *g_g = malloc(300);
    	char *_h = malloc(300);
    	char *h_h = malloc(300);
    	char *_i = malloc(300);
    	char *i_i = malloc(300);
    	char *_j = malloc(300);
    	char *j_j = malloc(300);
    	char *_k = malloc(300);
    	char *list_of_bad = malloc(300);
    	char *copy = malloc(500);
    	int _c = 0;
    	int _b = 0;
    	int cc = 0;
    	int d = 0;
    	int dd = 0;
    	int e = 0;
    	int ee = 0;
    	int f = 0;
    	int ff = 0;
    	int g = 0;
    	int gg = 0;
    	int h = 0;
    	int hh = 0;
    	int i = 0;
    	int ii = 0;
    	int j = 0;
    	int jj = 0;
    	int k = 0;
    	int number = 0;
    	sp = fopen("readfile.txt", "r");
    	if(!sp)
    	{
    		perror("Error: file readlist.txt was not found or opened");
    		return;
    	}
    	write = fopen("m_and_s.txt", "w");
    	read_bad = fopen("bad.txt", "r");
    	delete_char(c, '\n', 0);
    	// The printf and scanf are for the switch statement code.
    	/*printf("\nEnter a result number\n");
    	scanf("%d", &n);*/
    	while(fgets(filedata, 4096, sp)!=NULL)
    	{
    		bit[0] = filedata[0];
    		byte[0] = filedata[strlen(filedata)-2];
    
    		// I look at the first letter in the word from the file
    		// and compare it to a, and the word from the file must also must have b in it somewhere.
    
    		if( (strpbrk(filedata, a)) && (!strncmp (byte, b, 1)) || (!strncmp (bit, b, 1)) )
    		{
    			number++;
    
    			/* Save the result from this number for later use */
    
    			if(number==17)
    				strcpy(base, filedata);
    			if(number==70)
    				strcpy(c_c, filedata);
    			if(number==71)
    				strcpy(_d, filedata);
    			if(number==72)
    				strcpy(d_d, filedata);
    			if(number==73)
    				strcpy(_e, filedata);
    			if(number==74)
    				strcpy(e_e, filedata);
    			if(number==75)
    				strcpy(_f, filedata);
    			if(number==76)
    				strcpy(f_f, filedata);
    			if(number==77)
    				strcpy(_g, filedata);
    			if(number==78)
    				strcpy(g_g, filedata);
    			if(number==79)
    				strcpy(_h, filedata);
    			if(number==80)
    				strcpy(h_h, filedata);
    			if(number==81)
    				strcpy(_i, filedata);
    			if(number==82)
    				strcpy(i_i, filedata);
    			if(number==83)
    				strcpy(_j, filedata);
    			if(number==84)
    				strcpy(j_j, filedata);
    			if(number==85)
    				strcpy(_k, filedata);
    
    			// I commented out the switch statement. The switch helped me tweak the while loop below number++.
    			/*switch(n)
    			{
    
    
    			case 1:
    			{
    			while(number < 19)
    			{
    			if(number==18)
    			strcat(src, filedata);
    			break;
    			}
    			}
    			break;
    
    			case 2:
    			{
    			while(number < 20)
    			{
    			if(number==19)
    			strcat(src, filedata);
    			break;
    			}
    			}
    			break;
    
    			case 3:
    			{
    			while(number < 21)
    			{
    			if(number==20)
    			strcat(src, filedata);
    			break;
    			}
    			}
    			break;
    
    			case 4:
    			{
    			while(number < 22)
    			{
    			if(number==21)
    			strcat(src, filedata);
    			break;
    			}
    			}
    			break;
    
    			case 5:
    			{
    			while(number < 23)
    			{
    			if(number==22)
    			strcat(src, filedata);
    			break;
    			}
    			}
    			break;
    
    			case 6:
    			{
    			while(number < 24)
    			{
    			if(number==23)
    			strcat(src, filedata);
    			break;
    			}
    			}
    			break;
    
    			case 7:
    			{
    			while(number < 25)
    			{
    			if(number==24)
    			strcat(src, filedata);
    			break;
    			}
    			}
    			break;
    
    			case 8:
    			{
    			while(number < 26)
    			{
    			if(number==25)
    			strcat(src, filedata);
    			break;
    			}
    			}
    			break;
    
    			case 9:
    			{*/
    
    			if(number==86)
    			{
    				/* create a sentence to compare to the sentence in the bad.txt */
    
    				memmove(c_plus, c, strlen(c)+1);
    				strcat(c_plus, " ");
    				strcat(c_plus, filedata);
    
    				memmove(baseline, c, strlen(c)+1);
    				strcat(baseline, " ");
    				strcat(baseline, base);
    
    				memmove(c_plus_plus, c, strlen(c)+1);
    				strcat(c_plus_plus, " ");
    				strcat(c_plus_plus, c_c);
    
    				memmove(d_plus, c, strlen(c)+1);
    				strcat(d_plus, " ");
    				strcat(d_plus, _d);
    
    				memmove(d_plus_plus, c, strlen(c)+1);
    				strcat(d_plus_plus, " ");
    				strcat(d_plus_plus, d_d);
    
    				memmove(e_plus, c, strlen(c)+1);
    				strcat(e_plus, " ");
    				strcat(e_plus, _e);
    
    				memmove(e_plus_plus, c, strlen(c)+1);
    				strcat(e_plus_plus, " ");
    				strcat(e_plus_plus, e_e);
    
    				memmove(f_plus, c, strlen(c)+1);
    				strcat(f_plus, " ");
    				strcat(f_plus, _f);
    
    				memmove(f_plus_plus, c, strlen(c)+1);
    				strcat(f_plus_plus, " ");
    				strcat(f_plus_plus, f_f);
    
    				memmove(g_plus, c, strlen(c)+1);
    				strcat(g_plus, " ");
    				strcat(g_plus, _g);
    
    				memmove(g_plus_plus, c, strlen(c)+1);
    				strcat(g_plus_plus, " ");
    				strcat(g_plus_plus, g_g);
    
    				memmove(h_plus, c, strlen(c)+1);
    				strcat(h_plus, " ");
    				strcat(h_plus, _h);
    				//
    				memmove(h_plus_plus, c, strlen(c)+1);
    				strcat(h_plus_plus, " ");
    				strcat(h_plus_plus, h_h);
    
    				memmove(i_plus, c, strlen(c)+1);
    				strcat(i_plus, " ");
    				strcat(i_plus, _i);
    
    				memmove(i_plus_plus, c, strlen(c)+1);
    				strcat(i_plus_plus, " ");
    				strcat(i_plus_plus, i_i);
    
    				memmove(j_plus, c, strlen(c)+1);
    				strcat(j_plus, " ");
    				strcat(j_plus, _j);
    
    				memmove(j_plus_plus, c, strlen(c)+1);
    				strcat(j_plus_plus, " ");
    				strcat(j_plus_plus, j_j);
    
    				memmove(k_plus, c, strlen(c)+1);
    				strcat(k_plus, " ");
    				strcat(k_plus, _k);
    
    				/* The bad.txt is opened and compared to the sentence made in the previous step */
    
    				while(fgets(list_of_bad, 4096, read_bad)!=NULL)
    				{
    					if(!strcoll(c_plus, list_of_bad))
    					{
    						_c++;
    					}
    					else if(!strcoll(baseline, list_of_bad))
    					{
    						_b++;
    					}
    					else if(!strcoll(c_plus_plus, list_of_bad))
    					{
    						cc++;
    					}
    					else if(!strcoll(d_plus, list_of_bad))
    					{
    						d++;
    					}
    					else if(!strcoll(d_plus_plus, list_of_bad))
    					{
    						dd++;
    					}
    					else if(!strcoll(e_plus, list_of_bad))
    					{
    						e++;
    					}
    					else if(!strcoll(e_plus_plus, list_of_bad))
    					{
    						ee++;
    					}
    					else if(!strcoll(f_plus, list_of_bad))
    					{
    						f++;
    					}
    					else if(!strcoll(f_plus_plus, list_of_bad))
    					{
    						ff++;
    					}
    					else if(!strcoll(g_plus, list_of_bad))
    					{
    						g++;
    					}
    					else if(!strcoll(g_plus_plus, list_of_bad))
    					{
    						gg++;
    					}
    					else if(!strcoll(h_plus, list_of_bad))
    					{
    						h++;
    					}
    					//
    					else if(!strcoll(h_plus_plus, list_of_bad))
    					{
    						hh++;
    					}
    					else if(!strcoll(i_plus, list_of_bad))
    					{
    						i++;
    					}
    					else if(!strcoll(i_plus_plus, list_of_bad))
    					{
    						ii++;
    					}
    					else if(!strcoll(j_plus, list_of_bad))
    					{
    						j++;
    					}
    					else if(!strcoll(j_plus_plus, list_of_bad))
    					{
    						jj++;
    					}
    					else if(!strcoll(k_plus, list_of_bad))
    					{
    						k++;
    					}
    				}
    
    				/* If the result from the previous step added to their int number, then these will not run */
    				if(_c == 0)
    				{
    					strcat(src, filedata);
    					fprintf(write, "%s %s\n", c, filedata);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(cc == 0)
    				{
    					strcat(src, c_c);
    					fprintf(write, "%s %s\n", c, c_c);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(d == 0)
    				{
    					strcat(src, _d);
    					fprintf(write, "%s %s\n", c, _d);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(dd == 0)
    				{
    					strcat(src, d_d);
    					fprintf(write, "%s %s\n", c, d_d);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(e == 0)
    				{
    					strcat(src, _e);
    					fprintf(write, "%s %s\n", c, _e);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(ee == 0)
    				{
    					strcat(src, e_e);
    					fprintf(write, "%s %s\n", c, e_e);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(f == 0)
    				{
    					strcat(src, _f);
    					fprintf(write, "%s %s\n", c, _f);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(ff == 0)
    				{
    					strcat(src, f_f);
    					fprintf(write, "%s %s\n", c, f_f);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(g == 0)
    				{
    					strcat(src, _g);
    					fprintf(write, "%s %s\n", c, _g);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(gg == 0)
    				{
    					strcat(src, g_g);
    					fprintf(write, "%s %s\n", c, g_g);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(h == 0)
    				{
    					strcat(src, _h);
    					fprintf(write, "%s %s\n", c, _h);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(hh == 0)
    				{
    					strcat(src, h_h);
    					fprintf(write, "%s %s\n", c, h_h);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(i == 0)
    				{
    					strcat(src, _i);
    					fprintf(write, "%s %s\n", c, _i);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(ii == 0)
    				{
    					strcat(src,i_i);
    					fprintf(write, "%s %s\n", c, i_i);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(j == 0)
    				{
    					strcat(src, _j);
    					fprintf(write, "%s %s\n", c, _j);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(jj == 0)
    				{
    					strcat(src, j_j);
    					fprintf(write, "%s %s\n", c, j_j);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(k == 0)
    				{
    					strcat(src, _k);
    					fprintf(write, "%s %s\n", c, _k);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    				else if(_b == 0)
    				{
    					strcat(src, baseline);
    					fprintf(write, "%s %s\n", c, baseline);
    					memset(&used[0], 0, sizeof(used));
    					memset(&byte[0], 0, sizeof(byte));
    					memset(&bit[0], 0, sizeof(bit));
    					memset(&c_plus[0], 0, sizeof(c_plus));
    					memset(&baseline[0], 0, sizeof(baseline));
    					memset(&c_plus_plus[0], 0, sizeof(c_plus_plus));
    					memset(&d_plus[0], 0, sizeof(d_plus));
    					memset(&d_plus_plus[0], 0, sizeof(d_plus_plus));
    					memset(&e_plus[0], 0, sizeof(e_plus));
    					memset(&e_plus_plus[0], 0, sizeof(e_plus_plus));
    					memset(&f_plus[0], 0, sizeof(f_plus));
    					memset(&f_plus_plus[0], 0, sizeof(f_plus_plus));
    					memset(&g_plus[0], 0, sizeof(g_plus));
    					memset(&g_plus_plus[0], 0, sizeof(g_plus_plus));
    					memset(&h_plus[0], 0, sizeof(h_plus));
    					memset(&h_plus_plus[0], 0, sizeof(h_plus_plus));
    					memset(&i_plus[0], 0, sizeof(i_plus));
    					memset(&i_plus_plus[0], 0, sizeof(i_plus_plus));
    					memset(&j_plus[0], 0, sizeof(j_plus));
    					memset(&j_plus_plus[0], 0, sizeof(j_plus_plus));
    					memset(&k_plus[0], 0, sizeof(k_plus));
    				}
    			}
    
    
    			/*while(number < 38)
    			{
    			if(number==37)
    			strcat(src, filedata);
    			else if(filedata == NULL)
    			{
    			fgets(filedata, 4096, sp);
    			strcat(src, filedata);
    			}
    			break;
    			}*/
    			/*}
    			break;
    
    			default:
    			{
    			while(number < 5)
    			{
    			if(number==4)
    			strcat(src, filedata);
    			break;
    			}
    			}
    
    
    			}*/
    		}
    
    	}
    
    	fclose(read_bad);
    	fclose(write);
    	fclose(sp);
    
    	free(list_of_bad);
    
    	free(_k);
    	free(j_j);
    	free(_j);
    	free(i_i);
    	free(_i);
    	free(h_h);
    	free(_h);
    	free(g_g);
    	free(_g);
    	free(f_f);
    	free(_f);
    	free(e_e);
    	free(_e);
    	free(d_d);
    	free(_d);
    	free(c_c);
    	free(baseline);
    	free(filedata);
    
    	return;
    }
    
    /* the sentence generator program */ 
    void sentence_generator()
    {
    	/* I declare my variables */
    
    	FILE *sp;
    	FILE *fp;
    
    	// These arrays are used in fprintf at the bottom of the program
    
    	char Celarent_one[CELARENT_WORD_ONE] = {0};
    	char Celarent_two[CELARENT_WORD_TWO] = {0};
    	char Celarent_three[CELARENT_WORD_THREE] = {0};
    	char Celarent_four[CELARENT_WORD_FOUR] = {0};
    	char Celarent_five[CELARENT_WORD_FIVE] = {0};
    	char Celarent_six[CELARENT_WORD_SIX] = {0};
    	char Celarent_seven[CELARENT_WORD_SEVEN] = {0};
    
    	// These arrays are used for the program to run
    
    	char C_D_one[CD_WORD_ONE] = {0};
    	char C_D_two[CD_WORD_TWO] = {0};
    	char C_D_three[CD_WORD_THREE] = {0};
    
    	char C_F_one[CF_WORD_ONE] = {0};
    	char C_F_two[CF_WORD_TWO] = {0};
    	char C_F_three[CF_WORD_THREE] = {0};
    	char C_F_four[CF_WORD_FOUR] = {0};
    
    	char B_one[B_WORD_ONE] = {0};
    	char B_two[B_WORD_TWO] = {0};
    	char B_three[B_WORD_THREE] = {0};
    	char B_four[B_WORD_FOUR] = {0};
    	char B_five[B_WORD_FIVE] = {0};
    
    	char mystring[STRING] = {0};
    	char buf1[MAX_STRING];
    	char * pch = malloc(300);
    	int sentence_count = 0;
    	int a = 0;
    	int b = 0;
    	int c = 0;
    	int zero = 0;
    
    	fp = fopen("readtext1.txt", "w");
    
    	if(!fp)   
    	{
    		perror("Error: file readtext1.txt was not found or opened");   
    		return;   
    	}
    	/* I ask the user to enter text */
    
    	fgets(mystring, 4096, stdin);
    
    	/* I input a string and it is checked to see which while loop will process it.
    	I use the while loop to give a word value to a array which is checked by the if statements in the next step */
    	if ((strstr(mystring, "no")) && (strstr(mystring, "is")) &&! (strstr(mystring, "are")) &&! (strstr(mystring,"not")) )
    	{
    		pch = strtok(mystring, " ");
    		while(pch != NULL)
    		{
    			sentence_count++;
    
    			if (sentence_count == 1 )
    			{
    				strcat(C_F_one, pch);
    			}
    			else if (sentence_count == 2 )
    			{
    				strcat(C_F_two, pch);
    			}
    			else if (sentence_count == 3 )
    			{
    				strcat(C_F_three, pch);
    			}
    			else if (sentence_count == 4 )
    			{
    				strcat(C_F_four, pch);
    			}
    
    			pch = strtok (NULL, " ");
    		}
    		b++;                
    	}
    
    	/* I check the word from the while loop to see what char values it has, so these values are passed to the search function.
    	The search function then returns a word value from a list of words.*/
    
    	/* _____________________________________________________________________________ */
    	if( strpbrk( C_F_one, "aeiouy"))
    		if( strpbrk( C_F_one, "bcdfghjklmnpqrstvwxz" ))
    			strcat( Celarent_one, C_F_one ) ;
    
    	/* _____________________________________________________________________________ */
    	if(strpbrk(C_F_two, "a"))
    	{
    		if(strpbrk(C_F_two, "b"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "b", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "c"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "c", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "d"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "d", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "f"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "f", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "g"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "g", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "h"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "h", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "j"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "j", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "k"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "k", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "l"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "l", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "m"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "m", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "n"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "n", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "p"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "p", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "q"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "q", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "r"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "r", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "s"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "s", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "t"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "t", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "v"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "v", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "w"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "w", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "x"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "x", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "z"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "a", "z", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    	}
    	else if(strpbrk(C_F_two, "e"))
    	{
    		if(strpbrk(C_F_two, "b"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "b", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "c"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "c", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "d"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "d", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "f"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "f", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "g"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "g", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "h"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "h", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "j"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "j", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "k"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "k", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "l"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "l", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "m"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "m", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "n"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "n", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "p"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "p", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "q"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "q", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "r"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "r", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "s"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "s", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "t"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "t", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "v"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "v", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "w"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "w", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "x"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "x", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "z"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "e", "z", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    	}
    	else if(strpbrk(C_F_two, "i"))
    	{
    		if(strpbrk(C_F_two, "b"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "b", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "c"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "c", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "d"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "d", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "f"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "f", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "g"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "g", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "h"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "h", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "j"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "j", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "k"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "k", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "l"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "l", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "m"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "m", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "n"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "n", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "p"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "p", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "q"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "q", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "r"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "r", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "s"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "s", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "t"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "t", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "v"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "v", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "w"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "w", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "x"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "x", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "z"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "i", "z", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    	}
    	else if(strpbrk(C_F_two, "o"))
    	{
    		if(strpbrk(C_F_two, "b"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "b", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "c"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "c", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "d"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "d", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "f"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "f", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "g"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "g", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "h"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "h", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "j"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "j", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "k"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "k", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "l"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "l", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "m"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "m", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "n"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "n", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "p"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "p", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "q"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "q", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "r"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "r", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "s"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "s", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "t"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "t", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "v"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "v", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "w"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "w", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "x"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "x", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "z"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "o", "z", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    	}
    	else if(strpbrk(C_F_two, "u"))
    	{
    		if(strpbrk(C_F_two, "b"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "b", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "c"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "c", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "d"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "d", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "f"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "f", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "g"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "g", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "h"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "h", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "j"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "j", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "k"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "k", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "l"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "l", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "m"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "m", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "n"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "n", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "p"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "p", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "q"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "q", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "r"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "r", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "s"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "s", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "t"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "t", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "v"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "v", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "w"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "w", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "x"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "x", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "z"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "u", "z", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    	}
    	else if(strpbrk(C_F_two, "y"))
    	{
    		if(strpbrk(C_F_two, "b"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "b", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "c"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "c", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "d"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "d", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "f"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "f", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "g"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "g", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "h"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "h", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "j"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "j", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "k"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "k", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "l"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "l", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "m"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "m", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "n"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "n", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "p"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "p", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "q"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "q", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "r"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "r", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "s"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "s", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "t"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "t", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "v"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "v", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "w"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "w", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "x"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "x", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    		else if(strpbrk(C_F_two, "z"))
    		{
    			strcat(Celarent_two, C_F_two);
    			search(buf1, "y", "z", C_F_two);
    			strcat(Celarent_five, buf1);
    			memset(&buf1[0], 0, sizeof(buf1));
    		}
    	}
    	/* _____________________________________________________________________________ */
    	if( strpbrk( C_F_three, "aeiouy"))
    		if( strpbrk( C_F_three, "bcdfghjklmnpqrstvwxz" ))
    			strcat( Celarent_three, C_F_three ) ;
    	/* _____________________________________________________________________________ */
    	if( strpbrk( C_F_four, "aeiouy"))
    		if( strpbrk( C_F_four, "bcdfghjklmnpqrstvwxz" ))
    			strcat( Celarent_four, C_F_four ) ;
    	/* _____________________________________________________________________________ */
    
    	/* I add string values to the variables not in the previous step. */
    
    	strcat(Celarent_six, "are");
    	strcat(Celarent_seven, Celarent_two);
    
    	/* I get rid of the newline so the sentences look formated, or else the sentences are on different lines */
    
    	delete_char(Celarent_one, '\n', 0);
    	delete_char(Celarent_two, '\n', 0);
    	delete_char(Celarent_three, '\n', 0);
    	delete_char(Celarent_four, '\n', 0);
    	delete_char(Celarent_five, '\n', 0);
    	delete_char(Celarent_six, '\n', 0);
    	delete_char(Celarent_seven, '\n', 0);
    
    	/* I write the results to file */
    
    	if(b > zero)
    	{
    		fprintf(fp, "%s %s %s %s.\n%s %s %s.\n", Celarent_one, Celarent_two, Celarent_three, Celarent_four, 
    			Celarent_five, Celarent_six, Celarent_seven);
    	}
    
    	/* I memset the arrays */
    
    	memset(&Celarent_one[0], 0, sizeof(Celarent_one));
    	memset(&Celarent_two[0], 0, sizeof(Celarent_two));
    	memset(&Celarent_three[0], 0, sizeof(Celarent_three));
    	memset(&Celarent_four[0], 0, sizeof(Celarent_four));
    	memset(&Celarent_five[0], 0, sizeof(Celarent_five));
    	memset(&Celarent_six[0], 0, sizeof(Celarent_six));
    	memset(&Celarent_seven[0], 0, sizeof(Celarent_seven));
    
    	memset(&C_D_one[0], 0, sizeof(C_D_one));
    	memset(&C_D_two[0], 0, sizeof(C_D_two));
    	memset(&C_D_three[0], 0, sizeof(C_D_three));
    
    	memset(&C_F_one[0], 0, sizeof(C_F_one));
    	memset(&C_F_two[0], 0, sizeof(C_F_two));
    	memset(&C_F_three[0], 0, sizeof(C_F_three));
    	memset(&C_F_four[0], 0, sizeof(C_F_four));
    
    	memset(&B_one[0], 0, sizeof(B_one));
    	memset(&B_two[0], 0, sizeof(B_two));
    	memset(&B_three[0], 0, sizeof(B_three));
    	memset(&B_four[0], 0, sizeof(B_four));
    	memset(&B_five[0], 0, sizeof(B_five));
    
    	free(mystring);
    	free(pch);
    	sentence_count = 0;
    	a = 0;
    	b = 0;
    	c = 0;
    	fclose(fp);
    	return;
    }
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    /* Sentence generator section end */
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    /* Syllogism section begin */
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    char red;
    
    /* The function to split the input into a sentence per line */
    int split_by_sentence(void)
    {
    	int character, file_character=0;
    	char buffer[1024];
    	FILE *book=fopen("readtext1.txt", "r");
    	FILE *book2=fopen("readtext.txt", "a+");
    	if(!book) {printf("Error: unable to open input file!\n"); return 1;}
    	if(!book2) {printf("Error: unable to open output file!\n"); return 1;}
    
    	while(file_character!=EOF)
    	{
    		buffer[0]='\0';
    		for(character=0;character<sizeof(buffer);character++) 
    		{
    			file_character=fgetc(book);
    			if(file_character==EOF)
    				break;
    
    			if(file_character=='.')
    			{
    				buffer[character]='\0';  
    				break;
    			}
    
    			if(file_character=='?')
    			{
    				buffer[character]='\0';  
    				break;
    			}
    
    			if(file_character=='!')
    			{
    				buffer[character]='\0';  
    				break;
    			}
    
    			buffer[character]=file_character;
    		}
    
    		if(file_character==EOF)
    			break;
    		fprintf(book2, "%s.\n", buffer);
    	}
    	fclose(book);
    	fclose(book2);
    	putchar('\n');
    
    	return 0;
    }
    
    /* The function to find the first letter in the word */
    char find_letter (char* a, char* b)
    {
    	char string = strlen(b);
    	strncpy (a,b,1);
    	a[1]='\0';
    	return 0;
    }
    
    /* The function to reverse the characters in a string */
    char *reverse(char *s)
    {
    	int c, i, j;
    
    	for (i = 0, j = strlen(s)-1; i < j; i++, j--) {
    		c = s[i];
    		s[i] = s[j];
    		s[j] = c;
    	}
    	return 0;
    }
    
    /* The function to find the Celarent syllogism */
    char *Celarent_conclusion(char *sentence, int sentence_count, char *Celarent_word_one, char *Celarent_word_two, char *Celarent_word_three, char *Celarent_word_four, char *Celarent_word_five, char *Celarent_word_six, char *Celarent_word_seven)
    {
    	strtok(sentence, " ");
    	while(sentence != NULL)
    	{
    		sentence_count++;
    
    		if (sentence_count == 1 )
    		{
    			strcat(Celarent_word_one, sentence);
    		}
    		else if (sentence_count == 2 )
    		{
    			strcat(Celarent_word_two, sentence);
    		}
    		else if (sentence_count == 3 )
    		{
    			strcat(Celarent_word_three, sentence);
    		}
    		else if (sentence_count == 4 )
    		{
    			strcat(Celarent_word_four, sentence);
    		}
    		else if (sentence_count == 5 )
    		{
    			strcat(Celarent_word_five, sentence);
    		}
    		else if (sentence_count == 6 )
    		{
    			strcat(Celarent_word_six, sentence);
    		}
    		else if (sentence_count == 7 )
    		{
    			strcat(Celarent_word_seven, sentence);
    		}
    
    		else
    			printf("**\nno match\n");
    
    		sentence = strtok (NULL, " ");
    	}
    	printf("Celarent\n\n");
    	printf("%s %s %s %s.\n", Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four);
    	printf("%s %s %s.\n", Celarent_word_five, Celarent_word_six, Celarent_word_two);
    	printf("%s %s %s %s\n\n", Celarent_word_one, Celarent_word_five, Celarent_word_three, Celarent_word_four);
    
    
    
    	memset(&Celarent_word_one[0], 0, sizeof(Celarent_word_one));
    	memset(&Celarent_word_two[0], 0, sizeof(Celarent_word_two));
    	memset(&Celarent_word_three[0], 0, sizeof(Celarent_word_three));
    	memset(&Celarent_word_four[0], 0, sizeof(Celarent_word_four));
    	memset(&Celarent_word_five[0], 0, sizeof(Celarent_word_five));
    	memset(&Celarent_word_six[0], 0, sizeof(Celarent_word_six));
    	memset(&Celarent_word_seven[0], 0, sizeof(Celarent_word_seven));
    	sentence_count = 0;
    	return sentence;
    }
    
    void Celarent_percentage_calculation_numbers(char* a_pch)
    {
    	FILE *read;
    	FILE *fp;
    	char vowels[] = "aeiouyAEIOUY";
    	char letters[] = "bcdfghjklmnpqrstvwxzBCDFGHJKLMNPQRSTVWXYZ";
    	char alphabet[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    	char * pch = malloc(300);
    	char str2[7] = {0};
    	char buf1[MAX_STRING];
    	char Celarent_word_one[WORD_ONE] = {0};
    	char Celarent_word_two[WORD_TWO] = {0};
    	char Celarent_word_three[WORD_THREE] = {0};
    	char Celarent_word_four[WORD_FOUR] = {0};
    	char Celarent_word_five[WORD_FIVE] = {0};
    	char Celarent_word_six[WORD_SIX] = {0};
    	char Celarent_word_seven[WORD_SEVEN] = {0};
    	char code[CODELINES] = {0};
    	char buffer[BUFFERLINES] = {0};
    	char sentence[SENTENCELINES] = {0};
    	int period = 0;
    	int count = 0;
    	int sentence_count = 0;
    	int abc;
    	float one;
    	float two;
    	float three;
    	float four;
    	float total;
    	float five;
    	float six;
    	float seven;
    	float eight;
    	float total_2;
    	float percentage_1;
    	float percentage_2;
    	float percentage_3;
    	float percentage_4;
    
    	one = 0;
    	two = 0;
    	three = 0;
    	four = 0;
    	total = 0;
    	five = 0;
    	six = 0;
    	seven = 0;
    	eight = 0;
    	total_2 = 0;
    	percentage_1 = 0;
    	percentage_2 = 0;
    	percentage_3 = 0;
    	percentage_4 = 0;
    
    	/* open text file or report error */
    	fp = fopen("writelist.txt", "w");
    
    	if(!fp) {printf("Error: unable to open input file!\n");}
    
    	/* Tokenize the input for the while loop */
    	strncpy(buf1, a_pch, sizeof(buf1));
    	delete_char(buf1, '.', 0);
    	delete_char(buf1, '\n', 0);
    	delete_char(buf1, '`', 0);
    	delete_char(buf1, '1', 0);
    	delete_char(buf1, '2', 0);
    	delete_char(buf1, '3', 0);
    	delete_char(buf1, '4', 0);
    	delete_char(buf1, '5', 0);
    	delete_char(buf1, '6', 0);
    	delete_char(buf1, '7', 0);
    	delete_char(buf1, '8', 0);
    	delete_char(buf1, '9', 0);
    	delete_char(buf1, '0', 0);
    	delete_char(buf1, '-', 0);
    	delete_char(buf1, '=', 0);
    	delete_char(buf1, '~', 0);
    	delete_char(buf1, '!', 0);
    	delete_char(buf1, '@', 0);
    	delete_char(buf1, '#', 0);
    	delete_char(buf1, '$', 0);
    	delete_char(buf1, '%', 0);
    	delete_char(buf1, '^', 0);
    	delete_char(buf1, '&', 0);
    	delete_char(buf1, '*', 0);
    	delete_char(buf1, '(', 0);
    	delete_char(buf1, ')', 0);
    	delete_char(buf1, '_', 0);
    	delete_char(buf1, '+', 0);
    	delete_char(buf1, '[', 0);
    	delete_char(buf1, ']', 0);
    	delete_char(buf1, '\\', 0);
    	delete_char(buf1, '{', 0);
    	delete_char(buf1, '}', 0);
    	delete_char(buf1, '|', 0);
    	delete_char(buf1, ';', 0);
    	delete_char(buf1, '\'', 0);
    	delete_char(buf1, ':', 0);
    	delete_char(buf1, '"', 0);
    	delete_char(buf1, ',', 0);
    	delete_char(buf1, '/', 0);
    	delete_char(buf1, '<', 0);
    	delete_char(buf1, '>', 0);
    	delete_char(buf1, '?', 0);
    
    	pch = strtok (buf1, " ");
    
    	/* The while loop gives value to five, six, seven, eight, which is used for the percentage calculation */
    
    	while(pch != NULL)
    	{
    		strcat(sentence, pch);
    		strcat(sentence, " ");
    		/*printf("test %s\n", pch);*/
    		/* identify the first letter in the word begin */
    
    		red = find_letter(str2, pch);
    
    		if(strpbrk(str2, letters))
    		{
    			one++;
    		}
    
    		if(strpbrk(str2, vowels))
    		{
    			two++;
    		}
    
    		/* identify the first letter in the word end */
    
    		/* identify the last letter in the word begin */
    		reverse(pch);
    
    		red = find_letter(str2, pch);
    
    		if(strpbrk(str2, letters))
    		{
    			three++;
    		}
    
    		if(strpbrk(str2, vowels))
    		{
    			four++;
    		}
    
    		/* identify the last letter in the word end */
    
    		/* The math using the first and last letter begin */
    
    		/* pch is backwards, so I use rev to reverse it back */
    		/*printf("%s uncomment to test to see if the string is backwards", pch);*/
    		reverse(pch);
    
    		/*The math using the first and last letter begin
    		Here I give the word a new string value, based on how the vowel is situated in the word.*/
    
    		if(total = (one && three))
    		{
    			five++;
    			fprintf(fp, "point\n", pch);
    		}
    
    		else if(total = (one && four))
    		{
    			six++;
    			fprintf(fp, "shoot\n", pch);
    		}
    
    		else if(total = (two && three))
    		{
    			seven++;
    			fprintf(fp, "reload\n", pch);
    		}
    
    		else if(total = (two && four))
    		{
    			eight++;
    			fprintf(fp, "autofire\n", pch);
    		}
    
    		/* The math using the first and last letter end */
    
    		/* Reset the pointers */
    
    		one = 0;
    		two = 0;
    		three = 0;
    		four = 0;
    		total = 0;
    
    		pch = strtok (NULL, " ");
    	}
    
    	/* Count the pointers */
    	total_2 = (five + six + seven + eight);
    	percentage_1 = ((five)/ total_2);
    	percentage_2 = ((six)/ total_2);
    	percentage_3 = ((seven)/ total_2);
    	percentage_4 = ((eight)/ total_2);
    
    	/* puts a period into the textfile after a sentence is processed
    	This way I can count the number of periods in the text file */
    	fprintf(fp, ".\n");
    	fclose(fp);
    	free(pch);
    	memset(&buf1[0], 0, sizeof(buf1));
    	memset(&str2[0], 0, sizeof(str2));
    	read=fopen("writelist.txt", "r");
    	if(!read) {printf("Error: unable to open input file!\n");}
    	while(fgets(buffer, sizeof(buffer), read)!=NULL)
    	{
    		/* Find the word then add it the the pch string */
    		if (strstr(buffer, "point\n"))
    		{
    			strcat(code, buffer);
    		}
    		if (strstr(buffer, "shoot\n"))
    		{
    			strcat(code, buffer);
    		}
    		if (strstr(buffer, "reload\n"))
    		{
    			strcat(code, buffer);
    		}
    		if (strstr(buffer, "autofire\n"))
    		{
    			strcat(code, buffer);
    		}
    
    		/* counting the periods in the input text file*/
    		if (strstr(buffer, "."))
    		{
    			period++;
    		}
    
    		/* After two periods are counted the while loop is exited */
    		if(period > count)
    		{
    			for ( abc = 0; abc < 64; ++abc )
    			{
    				if(!strcoll(code, Celarent[abc]))
    				{
    					printf("__________________________________________\n\n%s\n", syllogism[0]);
    					Celarent_conclusion(sentence, sentence_count, Celarent_word_one, Celarent_word_two, Celarent_word_three, Celarent_word_four, Celarent_word_five, Celarent_word_six, Celarent_word_seven);
    				}
    			}
    
    			if(period > count)
    			{
    				memset(&code[0], 0, sizeof(code));
    				memset(&buffer[0], 0, sizeof(buffer));
    				memset(&sentence[0], 0, sizeof(sentence));
    			}
    			period = 0;
    		}
    	}
    	fclose(read);
    }
    
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    /* Syllogism section end */
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    
    /* function so I don't have to type getch all over the place */
    void MyExit(void) { system("pause"); }
    
    /* the main program */ 
    int main ()
    {   
    	/* declaring and initiaizing variables */
    	FILE *read_to_review;
    	FILE *bad_list;
    	FILE *book;
    	FILE *a;
    	FILE *b;
    	FILE *c;
    	char * pch = malloc(300);
    	char alphabet[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    	char buffer[LINES];
    	char copy_review[REVIEW];
    	int period = 0;
    	int test_result = 0;
    	int x = 0;
    	int good = 0;
    	int one = 1;
    	char sentence[4096] = {0};
    	/* The function is called so I don't have to type getch */
    	atexit(MyExit);    
    
    	/* X recieves 1 so the program can run */
    	printf("Type 1 to run the program\n");
    	scanf("%d", &x);
    	printf("\n\nEnter a sentence, all lower case.\n");
    	printf("Rename X and Y with words, the new word must have both a letter and vowel in it.\n");
    	printf("Formats of sentences:\n\n");
    	printf("no X is Y\n");
    	while(!good) 
    	{
    		switch(x)
    		{
    		case 1:
    			{
    				/* The sentence generator section is run*/
    				sentence_generator();
    
    
    				/* Now the syllogism section begins */
    
    				/* The function is called and creates the text file */
    				split_by_sentence();
    
    				/* The text file just created is opened */
    				book = fopen("readtext.txt", "r");
    				read_to_review = fopen("m_and_s.txt", "r");
    				bad_list = fopen("bad.txt", "a+");
    				if(!book)   
    				{
    					perror("Error: file readtext.txt was not found or opened");   
    					return 0;   
    				}
    
    				/* read from file */
    				while(fgets(buffer, sizeof(buffer), book)!=NULL)
    				{ 
    					/* join two sentences */
    
    					strcat(sentence, buffer);
    					strcat(sentence, " ");
    
    					/* counting the periods in the input text file*/
    
    					if (strstr(buffer, "."))
    					{
    						period++;
    					}
    
    					/* After two periods are counted the while loop is exited */
    
    					if(period > one)
    					{
    						/* I find the alphabet in pch after it's run through strtok */
    						Celarent_percentage_calculation_numbers(sentence);
    
    						/* The printf asks if I want to keep running the program or close it */
    						fgets(copy_review, sizeof(copy_review), read_to_review);
    						printf("__________________________________________\n\n\nWas the syllogism logical? 1 for yes, 0 for no: ");
    						scanf("%d",&test_result);
    						if(test_result==0)
    							fprintf(bad_list, "%s\n", copy_review);
    						printf("Close program? 1 for yes, 0 for no: ");
    						scanf("%d",&good);
    						putchar('\n');
    						if(good==0)
    						{
    							printf("\n\nEnter a sentence, all lower case.\n");
    							printf("Rename X and Y with words, the new word must have both a letter and vowel in it.\n");
    							printf("Formats of sentences:\n\n");
    							printf("no X is Y\n");
    						}
    						if(period > one)
    						{
    							memset(&sentence[0], 0, sizeof(sentence));
    						}
    						period = 0;
    						free(pch);
    						break;
    					}
    				}
    				fclose(book);
    				fclose(bad_list);
    				fclose(read_to_review);
    				/* emptying the files so the program doesn't build them up each time it's used */
    
    				a = fopen("readtext.txt", "w");
    				if(!a)   
    				{
    					perror("Error: file readtext.txt was not found or opened");   
    					return 0;   
    				}
    				b = fopen("readtext1.txt", "w");
    				if(!b)   
    				{
    					perror("Error: file readtext1.txt was not found or opened");   
    					return 0;   
    				}
    				c = fopen("writelist.txt", "w");
    				if(!c)   
    				{
    					perror("Error: file writelist.txt was not found or opened");   
    					return 0;   
    				}
    				fprintf(a, "");
    				fprintf(b, "");
    				fprintf(c, "");
    				fclose(a);
    				fclose(b);
    				fclose(c);
    			}
    		}
    	}
    
    	return 0;
    }

  6. #6
    - - - - - - - - oogabooga's Avatar
    Join Date
    Jan 2008
    Posts
    2,808
    You've reduced it to less than half the size of the original code you posted, but I still think it can be reduced by a factor of 10 or so.Can you describe in english what the program is supposed to do exactly?

  7. #7
    Registered User
    Join Date
    Sep 2006
    Posts
    8,868
    Be prepared for your eyes to glaze over Oogabooga! It's a formal logic program - the kind of logic the world used before first order logic was founded.

    Jeremy as you can see, doesn't have much experience in C, but he has worked diligently on this program, and now just needs to get it cut down to size so it can be expanded to include parts that aren't there yet.

    Quite an accomplishment for a beginner.

  8. #8
    Registered User
    Join Date
    Nov 2011
    Location
    Saratoga, California, USA
    Posts
    334
    Look at this code
    Code:
    if(strpbrk(C_F_two, "a"))    {
            if(strpbrk(C_F_two, "b"))
            {
                strcat(Celarent_two, C_F_two);
                search(buf1, "a", "b", C_F_two);
                strcat(Celarent_five, buf1);
                memset(&buf1[0], 0, sizeof(buf1));
            }
    and ask yourself, if "aeiou" and "bcd...z" were char array constants, couldn't I use the 2 return values from strpbrk to call search? (Those char array constants could then be used everywhere else they're called for too).

    And those 40-some calls to delete_char() could be eliminated if you would move the choices *into* the function itself. And you might take a look at your ASCII table and see if you can't use ranges of characters instead of individual ones.

  9. #9
    Registered User
    Join Date
    May 2010
    Posts
    2,684
    Why all the #defines? They all have the same value won't just one do? You may want to consider multidimensional arrays. Couldn't the following be multidimensional arrays?
    Code:
    	char c_plus_plus[C_PLUS_PLUS] = {0};
    	char d_plus[D_PLUS] = {0};
    	char d_plus_plus[D_PLUS_PLUS] = {0};
    	char e_plus[E_PLUS] = {0};
    	char e_plus_plus[E_PLUS_PLUS] = {0};
    	char f_plus[F_PLUS] = {0};
    	char f_plus_plus[F_PLUS_PLUS] = {0};
    	char g_plus[G_PLUS] = {0};
    	char g_plus_plus[G_PLUS_PLUS] = {0};
    	char h_plus[H_PLUS] = {0};
    	char h_plus_plus[H_PLUS_PLUS] = {0};
    	char i_plus[I_PLUS] = {0};
    	char i_plus_plus[I_PLUS_PLUS] = {0};
    	char j_plus[J_PLUS] = {0};
    	char j_plus_plus[J_PLUS_PLUS] = {0};
    	char k_plus[K_PLUS] = {0};
    Watch out for buffer overruns, in the following snippet:
    Code:
    void search(char *src, char *a, char *b, char *c)
    {
    ...
        char *filedata = malloc(300);
    ....
        while(fgets(filedata, 4096, sp)!=NULL)
    You only allocated 300 bytes to this variable, yet you are trying to read up to 4096 bytes, this is a possible buffer overrun.

    Jim

  10. #10
    Registered User
    Join Date
    Sep 2006
    Posts
    8,868
    This part (lines 2308 to 2350 ):
    Code:
    	delete_char(buf1, '.', 0);
    	delete_char(buf1, '\n', 0);
    	delete_char(buf1, '`', 0);
    	delete_char(buf1, '1', 0);
    	delete_char(buf1, '2', 0);
    	delete_char(buf1, '3', 0);
    	delete_char(buf1, '4', 0);
    	delete_char(buf1, '5', 0);
    	delete_char(buf1, '6', 0);
    	delete_char(buf1, '7', 0);
    	delete_char(buf1, '8', 0);
    	delete_char(buf1, '9', 0);
    	delete_char(buf1, '0', 0);
    	delete_char(buf1, '-', 0);
    	delete_char(buf1, '=', 0);
    	delete_char(buf1, '~', 0);
    	delete_char(buf1, '!', 0);
    	delete_char(buf1, '@', 0);
    	delete_char(buf1, '#', 0);
    	delete_char(buf1, '$', 0);
    	delete_char(buf1, '%', 0);
    	delete_char(buf1, '^', 0);
    	delete_char(buf1, '&', 0);
    	delete_char(buf1, '*', 0);
    	delete_char(buf1, '(', 0);
    	delete_char(buf1, ')', 0);
    	delete_char(buf1, '_', 0);
    	delete_char(buf1, '+', 0);
    	delete_char(buf1, '[', 0);
    	delete_char(buf1, ']', 0);
    	delete_char(buf1, '\\', 0);
    	delete_char(buf1, '{', 0);
    	delete_char(buf1, '}', 0);
    	delete_char(buf1, '|', 0);
    	delete_char(buf1, ';', 0);
    	delete_char(buf1, '\'', 0);
    	delete_char(buf1, ':', 0);
    	delete_char(buf1, '"', 0);
    	delete_char(buf1, ',', 0);
    	delete_char(buf1, '/', 0);
    	delete_char(buf1, '<', 0);
    	delete_char(buf1, '>', 0);
    	delete_char(buf1, '?', 0);
    Can be replaced by:
    Code:
        int i=0,n;
        while(buf1[i]) {
           n=isalpha(buf1[i]);
           if(!n) {
              printf("%c, is not an alpha char\n",buf1[i]); //for debug only
              delete_char(buf1[i], 0);
           }
           ++i;
        }
    Last edited by Adak; 12-22-2011 at 10:04 PM.

  11. #11
    Registered User
    Join Date
    Apr 2011
    Posts
    229
    What the program does is it gets the main premise of the syllogism from the user, and uses the M variable from the sentence to make a guess on how to make the S word in the minor premise.

    So this way the code guesses on the answer. That's the sentence generator.
    The syllogism half takes the two sentences from the sentence generator and makes a syllogism conclusion.

    But that's just the syllogism usage, the other usage is to examine how the four words I made are used by the writer and how often a kind of word is used. These two capabilities are supposed to be useful later on when the program is more advanced. It's built in to future proof the code for when I get around to seeing it as useful. basically I wrote how they might be useful to my goal of some chat-bot but the program is still early in development so I haven't been able to use them yet.

    I fixed the buffer overflow, I tried the cons char array and it messed up the answer I was getting so I reverse that change, the idea of using multidimensional arrays is beyond me at this time.

    There's so many defines because each one is supposed to be able to hold the entire lines sentence from the input. This line is compared against the bad.txt file i think.

    I tried the code Adak made but he didn't see that function takes three arguments and i don't know how to write them into the function itself, so I left that code the way it was too.

  12. #12
    Registered User
    Join Date
    Sep 2006
    Posts
    8,868
    If you want to keep all three parameters, then it would be:

    Code:
        int i=0,n;
        while(buf1[i]) {
           n=isalpha(buf1[i]);
           if(!n) {
              printf("%c, is not an alpha char\n",buf1[i]); //for debug only
              delete_char(buff1, buf1[i], 0);
           }
           ++i;
        }

  13. #13
    Registered User
    Join Date
    Sep 2011
    Posts
    111
    Well all your defines, I noticed are the same size, you can eliminate the majority of them (the WORDS things), and use one name for them.

    And there is a chance you can remove a numbe rof those if else with a for loop or a while loop.

  14. #14
    and the hat of wrongness Salem's Avatar
    Join Date
    Aug 2001
    Location
    The edge of the known universe
    Posts
    32,422
    > May I ask you for advice on how to make it cleaner or smaller?
    What makes you think being told "Learn how to program" this time is going to work any better than being told it last time?

    You've learnt about 1% of programming, and the rest is just a massive COPY AND PASTE FEST!

    Every time you copy and paste, you should STOP and think about "function" and "data structures" to help you write much smaller code, which is also more useful in the long run.

    You've got some good talent for solving problems, but you're hurting yourself on the basic programming knowledge.
    King Mir likes this.
    If you dance barefoot on the broken glass of undefined behaviour, you've got to expect the occasional cut.
    If at first you don't succeed, try writing your phone number on the exam paper.
    I support http://www.ukip.org/ as the first necessary step to a free Europe.

  15. #15
    Registered User
    Join Date
    Apr 2011
    Posts
    229
    Hi Adak, I fixed the errors in your code and the results were empty so I undid that, and I put the delete in the sentence generator too, now punctuation doesn't break the program.

    I'll just leave that as is, so no worries about that code you gave me.

    I looked at my code and I need seven of those defines, WORD_ONE through to WORD_SEVEN.

    To Salem, I hear you.

    I'm all finished with this update, thanks to everyone who helped me.

Page 1 of 2 12 LastLast
Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Large STL String into smaller chunks
    By KeithS in forum C++ Programming
    Replies: 6
    Last Post: 05-23-2011, 07:24 PM
  2. make array smaller...bad data i think
    By t014y in forum C Programming
    Replies: 2
    Last Post: 01-27-2009, 01:32 PM
  3. Make something smaller.
    By Yuri in forum C++ Programming
    Replies: 11
    Last Post: 09-29-2005, 02:19 PM
  4. How do I make the font size smaller?
    By oobootsy1 in forum C# Programming
    Replies: 0
    Last Post: 02-24-2005, 09:34 PM
  5. any suggestions on how to make this program smaller?
    By bajan_elf in forum C++ Programming
    Replies: 4
    Last Post: 05-12-2003, 03:24 AM

Tags for this Thread


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21