#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>

#define N 100
#define M 100

char *scan_sentences(){
    char *s = malloc(N*sizeof(char));
    int counter = 0;
    int size = N;
    char current_symbol;
    current_symbol = getchar();
    while ((current_symbol == ' ') || (current_symbol == '\t')){
        current_symbol = getchar();
    }
    while ((current_symbol!= '\n') && (current_symbol != '.') && (current_symbol != '!')){
        if(counter>=size - 5){
            size+=N;
            s = realloc(s, size);
        }
        s[counter] = current_symbol;
        counter++;
        current_symbol = getchar();

    }
    s[counter++] = current_symbol;
    s[counter++] = '\n';
    s[counter] = '\0';
    return s;
}

bool stcp(char* a, char* b){
    int lena = strlen(a);
    int lenb = strlen(b);
    char* newa = calloc(lena+1, sizeof(char));
    char* newb = calloc(lenb+1, sizeof(char));
    for(int i = 0; i<lena; i++){
        newa[i]=toupper(a[i]);
        if(i==lena-1){
            i++;
            newa[i]='\0';
        }
    }
    for(int i = 0; i<lenb; i++){
        newb[i]=toupper(b[i]);
        if(i==lenb-1){
            i++;
            newb[i]='\0';
        }
    }
    int st = strcmp(newa,newb);
    free(newa);
    free(newb);
    return(st==0) ? true : false;

}


char** find_simmilar_and_kill(char** pointers,int* pointonsizeofmassive){
    const unsigned int sizeofmassive = *(pointonsizeofmassive);
    bool *proverka = malloc(sizeofmassive*sizeof(bool));
    for(int i = 0; i<sizeofmassive; i++){
        proverka[i] = true;
    }
    for(int i = 0; i<(sizeofmassive-1); i++){
        for(int j=i+1; j<sizeofmassive; j++){
            if(stcp(pointers[i],pointers[j])){
                proverka[i]=false;
                proverka[j]=false;
            }
        }
    }
    int suits = 0;
    for(int i = 0; i<sizeofmassive; i++){
        if(proverka[i]!=false){
            suits++;
        }
    }
    char** newpointers = malloc(suits*sizeof(char));
    int j = 0;
    for(int i=0; i<sizeofmassive; i++){
        if(proverka[i]){
            newpointers[j++]=pointers[i];
        }
        else{
            free(pointers[i]);
        }
        free(pointers);
        free(proverka);
        return newpointers;
    }
}


int main(){
    char **pointers = malloc(M*sizeof(char*));
    int counter = 0;
    int size = M;
    char *s;
    int sizeofmymassive = 0;
    do {
        s = scan_sentences();
        if (counter == size - 1) {
            size += M;
            pointers = realloc(pointers, size * sizeof(char *));
        }
        pointers[counter] = s;
        counter++;
        sizeofmymassive++;
    }while(strcmp(s,"\n\n")!=0);
    int* pointonsizeofmassive = &sizeofmymassive;
    pointers = find_simmilar_and_kill(pointers, pointonsizeofmassive);

    for (int i = 0; i < suits; i++) {
        fputs(pointers[i], stdout);
    }
    for(int i = 0; i<counter;i++){
        free(pointers[i]);
    }
    free(pointers);
}