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;
}