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

#define MAXN 2000


//alokacija matrice integera m[nrl..nrh][ncl..nch] *************************
int **imatrix(long nrl, long nrh, long ncl, long nch){
	long i, nrow=nrh-nrl+1, ncol=nch-ncl+1;
	int **m;

    // allocate pointers to rows
	m=(int **) malloc((size_t)((nrow+1)*sizeof(int*)));
	m+=1;
	m-=nrl;
	//allocate rows and set pointers to them
	m[nrl]=(int *) malloc((size_t)((nrow*ncol+1)*sizeof(int)));
	m[nrl]+=1;
	m[nrl]-=ncl;

	for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
	//return pointer to array of pointers of rows
	return m;
}

//dealokacija matrice
void free_imatrix(int **m, long nrl, long nrh, long ncl, long nch){
	free((char*) (m[nrl]+ ncl-1));
	free((char*)(m+nrl-1));
}




// pridruzivanje aminokiselina <-> broj ******************************

   int broj(char c){
	switch (c){
		case 'A': return 0; break;	
		case 'R': return 1; break;
		case 'N': return 2; break;	
		case 'D': return 3; break;
		case 'B': return 3; break;
		case 'C': return 4; break;	
		case 'Q': return 5; break;
		case 'E': return 6; break;
		case 'Z': return 6; break;
		case 'G': return 7; break;
		case 'H': return 8; break;
		case 'I': return 9; break;
		case 'L': return 10; break;
		case 'K': return 11; break;
		case 'M': return 12; break;
		case 'F': return 13; break;
		case 'P': return 14; break;
		case 'S': return 15; break;
		case 'T': return 16; break;
		case 'W': return 17; break;
		case 'Y': return 18; break;
		case 'V': return 19; break;
		}
	return -1;
   }

// Blosum matrica *********************************************************************

   int B[20][20] = {
        {5, -2, -1, -2, -1, -1, -1, 0, -2, -1, -2, -1, -1, -3, -1,  1,  0, -3, -2,  0},
        {-2, 7,-1, -2, -4,  1,  0, -3,  0, -4, -3, 3, -2, -3, -3, -1, -1, -3, -1, -3},
		{-1, -1, 7, 2, -2,  0,  0,  0,  1, -3, -4, 0, -2, -4, -2,  1,  0, -4, -2, -3},
        {-2, -2, 2, 8, -4,  0,  2, -1, -1, -4, -4, -1, -4, -5, -1,  0, -1, -5, -3, -4},
        {-1, -4, -2, -4, 13, -3, -3, -3, -3, -2, -2, -3, -2, -2, -4, -1, -1, -5, -3, -1},
        {-1, 1, 0, 0, -3, 7, 2, -2,  1, -3, -2,  2, 0, -4, -1,  0, -1, -1, -1, -3 },
        {-1, 0, 0, 2, -3, 2, 6, -3,  0, -4, -3,  1, -2, -3, -1, -1, -1, -3, -2, -3},
        {0, -3, 0, -1, -3, -2, -3, 8, -2, -4, -4, -2, -3, -4, -2,  0, -2, -3, -3, -4},
        {-2, 0, 1, -1, -3, 1, 0, -2, 10, -4, -3, 0, -1, -1, -2, -1, -2, -3,  2, -4},
        {-1, -4, -3, -4, -2, -3, -4, -4, -4, 5, 2, -3,  2, 0, -3, -3, -1, -3, -1,  4},
        {-2, -3, -4, -4, -2, -2, -3, -4, -3, 2, 5, -3,  3,  1, -4, -3, -1, -2, -1,  1},
        {-1, 3, 0, -1, -3, 2, 1, -2, 0, -3, -3, 6, -2, -4, -1,  0, -1, -3, -2, -3},
        {-1, -2, -2, -4, -2, 0, -2, -3, -1, 2, 3, -2, 7, 0, -3, -2, -1, -1,  0,  1},
        {-3, -3, -4, -5, -2, -4, -3, -4, -1, 0, 1, -4, 0, 8, -4, -3, -2,  1,  4, -1},
        {-1, -3, -2, -1, -4, -1, -1, -2, -2, -3, -4, -1, -3, -4, 10, -1, -1, -4, -3, -3},
        {1, -1, 1, 0, -1, 0, -1, 0, -1, -3, -3, 0, -2, -3, -1, 5, 2, -4, -2, -2},
        {0, -1, 0, -1, -1, -1, -1, -2, -2, -1, -1, -1, -1, -2, -1, 2, 5, -3, -2,  0},
        {-3, -3, -4, -5, -5, -1, -3, -3, -3, -3, -2, -3, -1, 1, -4, -4, -3, 15, 2, -3},
        {-2, -1, -2, -3, -3, -1, -2, -3, 2, -1, -1, -2, 0, 4, -3, -2, -2, 2, 8, -1},
        {0, -3, -3, -4, -1, -3, -3, -4, -4, 4, 1, -3, 1, -1, -3, -2, 0, -3, -1, 5}
	};


// glavni program *********************************************************

int main(void){

//ucitavanje pocetnih nizova iz datoteke "nizovi.txt" ***************************
//datoteka mora imati oblik "svaki niz u svom redu"  

   FILE* file_ptr;
   char str[MAXN];
   char *s1, *s2;
   file_ptr=fopen("nizovi.txt", "r");

   fgets(str, MAXN, file_ptr);
   s1=(char*)malloc(sizeof(str));
   strcpy(s1,str);

   fgets(str, MAXN, file_ptr);
   s2=(char*)malloc(sizeof(str));
   strcpy(s2,str);

   fclose(file_ptr);

  // *******************************************************************************

   int i,j,a,b,c; //indeksi i pomocne varijable


    
   int d=8;
   int n=strlen(s1), m=strlen(s2);  //duljine polaznih nizova 
   int **F, **P;  //Fmatrica za score, P za pointere
   F=imatrix(0,m,0,n);
   P=imatrix(0,m,0,n);

   //inicijalizacija matrica , pointeri: \ =1, <-=2, |=3 
   
   
   //
   //
   //TU IDE KOD!!!!
   //
   //


   char *s3, *s4;
   int l;
   s3=(char*)malloc(k*sizeof(char));
   s4=(char*)malloc(k*sizeof(char));

   //
   //JOS KODA !!
   //


   //oslobadjam memoriju koju zauzimaju matrice
   free_imatrix(F,0,m,0,n); 
   free_imatrix(P,0,m,0,n);

//ispisivanje u datoteku "poravnavanje.txt" ***************************

   file_ptr=fopen("poravnavanje.txt", "w");

   fputs(s3, file_ptr);
   fputs("\n", file_ptr);
   fputs(s4, file_ptr);
   fclose(file_ptr);

	return 1;
}