SEG FAULT D:::

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


int l, c,luzfound = 0, score = 0, steps = 0, arrow = 1,sense = 0; // a luz nao foi encontrada ainda, vai ser mudado para 1 quando for.

typedef struct celula {
    int tipo;
    int cheiroFraco;
    int cheiroMedio;
    int cheiroForte;
    int brisaFraca;
    int brisaMedia;
    int brisaForte;
    int safe; //safe - exclusivo para a IA - 1 - Totalmente salvo; 0 - Não foi marcado
    int visited; //IA only (já foi visitado = 1)
    int monstro; //IA only - monstro (se >= 3 é monstro)
    int abismo; //IA only - abismo (se >= 3 é abismo)
} celula;


int walk(char dir, int i, int j){ //passa a direcao para andar (w,a,s,d) , a posicao i (linhas) e j (colunas) e o numero de passos.
    steps--;
    score--;

    if (dir == 'w'){
        i--;
    }
    if (dir == 's'){
        i++;
    }
    if (dir == 'a'){
        j--;
    }
    if (dir == 'd'){
        j++;
    }
    if(i < 0){
        printf("Movimento invalido!\n");
        i++;
    }
    if(j < 0){
        printf("Movimento invalido!\n");
        j++;
    }
    if(i > l-1){
        printf("Movimento invalido!\n");
        i--;
    }
    if(j > c-1){
        printf("Movimento invalido!\n");
        j--;
    }
    if(dir == 'w' || dir == 's') return i;
    if(dir == 'a' || dir == 'd') return j;
}


int sensations(int i, int j, celula ** M){ //sensações no local
    M[i][j].visited = 1;
    if (i == 0 && j == 0 && luzfound == 1){
        printf("Voce saiu do mundo de Wumpus a salvo!\n +1000 Pontos!!!\n");
        score += 1000;
        steps = 0;
        sense++;
        return 0;
    }
    if (M[i][j].tipo == 1){
        printf("Voce encontrou um abismo!\n");
        printf(" -1000 Pontos!\n");
        score -= 1000;
        steps = 0;
        i = j = 0; //volta para o inicio
        sense++;
        return 0;
    }
    if (M[i][j].tipo == 2){
        printf("Voce encontrou um monstro!\n -10000 Pontos!\n");
        score -=10000;
        steps = 0;
        i = j = 0; //volta para o inicio
        sense++;
        return 0;
    }
    if (M[i][j].tipo == 3){
        printf("Parabens, voce encontrou a luz\n +1000 Pontos!!!\n");
        score += 1000;
        luzfound = 1;
        M[i][j].tipo = 0;
        sense++;
        return 0;
    }
    //imprimindo as sensações
    int k;
    for(k = 0;k<M[i][j].cheiroFraco;k++){
        printf("Você sente um cheiro fraco\n");
        sense++;
    }
    for(k = 0;k<M[i][j].cheiroMedio;k++){
        printf("Você sente um cheiro médio\n");
        sense++;
    }
    for(k = 0;k<M[i][j].cheiroForte;k++){
        printf("Você sente um cheiro forte\n");
        sense++;
    }
    for(k = 0;k<M[i][j].brisaFraca;k++){
        printf("Você sente uma brisa fraca\n");
        sense++;
    }
    for(k = 0;k<M[i][j].brisaMedia;k++){
        printf("Você sente uma brisa média\n");
        sense++;
    }
    for(k = 0;k<M[i][j].brisaForte;k++){
        printf("Você sente uma brisa forte\n");
        sense++;
    }
    return 0;
}

int shoot(int i, int j, celula ** M, char side){ //retorna 0 se errar ou for inválido, 1 se acertar. - Função flecha
    if (arrow == 0){
        printf("Você já gastou a sua flecha!\n");
        return 0;
    }
    arrow--;
    if (side == 'w'){
        i--;
    }
    if (side == 's'){
        i++;
    }
    if (side == 'a'){
        j--;
    }
    if (side == 'd'){
        j++;
    }
    if (i < 0 || j < 0 || i > l-1 || j > c-1) return 0;
    if (M[i][j].tipo == 2){
        printf("Você matou Wumpus!\n +10000 Pontos !!!\n");
        M[i][j].tipo = 0;
        return 1;
    }else{
        printf("Errou!\n");
        return 0;
    }

}

int askwhat(int i, int j, celula ** M, char side){ //função de pergunta
    score--;
    if (side == 'w'){
        i--;
    }
    if (side == 's'){
        i++;
    }
    if (side == 'a'){
        j--;
    }
    if (side == 'd'){
        j++;
    }
    if (i < 0 || j < 0 || i > l-1 || j > c-1){
        printf("Você encontrou uma parede\n");
        return 0;
    }
    sensations(i, j, M);
}

// -------------------------Funções exclusivas para a IA----------------------------//

int upfirst(int i, int j, celula ** M){ //setando para cima do player
    if (i < 0 || j < 0 || i > l-1 || j > c-1) //se for inválido
        return 0;
    M[i][j].safe = 1; //uponly
    if (i >= 1 && j>= 0 && i <= l-1 && j <= c-1){
        M[i-1][j].safe = 1; //upup
        if (i >= 2 && j >= 0){
            M[i-2][j].safe = 1; //upupup
        }
        if (i >= 1 && j >= 1){
            M[i-1][j-1].safe = 1; //upupleft
        }
        if (i >= 1 && j <= c-2){
            M[i-1][j+1].safe = 1; //upupright
        }
    }
    if (i < 0 || j < 0 || i > l-1 || j > c-2){

    }else{
        M[i][j+1].safe = 1; //upright
        if(i >= 0 && j <= c-3){
            M[i][j+2].safe = 1; //uprightright
        }
    }
    if (i < 0 || j < 1 || i > l-1 || j > c-1){
    }else{
        M[i][j-1].safe = 1; //upleft
        if(i >= 0 && j >= 2){
            M[i][j-2].safe = 1; //upleftleft
        }
    }
    return 0;
}

int leftfirst(int i, int j, celula ** M){
    if (i < 0 || j < 0 || i > l-1 || j > c-1){
        return 0;
    }
    M[i][j].safe = 1;//left
    if (j-1 >= 0){
        M[i][j-1].safe = 1; //leftleft
        if(j-2 >= 0){
            M[i][j-2].safe = 1; //leftleftleft
        }
    }
}
int rightfirst(int i, int j, celula ** M){
    if (i < 0 || j < 0 || i > l-1 || j > c-1){
        return 0;
    }
    M[i][j].safe = 1;//right
    if (j+1 <= c-1){
        M[i][j+1].safe = 1; //rightright
        if(j+2 <= c-1){
            M[i][j+2].safe = 1; //rightrightright
        }
    }
    return 0;
}
int downfirst(int i, int j, celula ** M){
    if (i < 0 || j < 0 || i > l-1 || j > c-1)
        return 0;
    M[i][j].safe = 1; //downonly
    if (i+1 <= l-1 && j <= c-1){
        M[i+1][j].safe = 1; //downdown
        if (i+2 <= l-1){
            M[i+2][j].safe = 1; //downdowndown
        }
        if (i+1 <= l-1 && j >= 1){
            M[i+1][j-1].safe = 1; //downdownleft
        }
        if (i >= 1 && j <= c-2){
            M[i-1][j+1].safe = 1; //downdownright
        }
    }
    if(j+1 <= c-1){
        M[i][j+1].safe = 1; //downright
        if(j+2 <= c){
            M[i][j+2].safe = 1; //downrightright
        }
    }
    if(j-1 >= 0){
        M[i][j-1].safe = 1; //downleft
        if(j-2 >= 0){
            M[i][j-2].safe = 1; //downleftleft
        }
    }
    return 0;

}


int upsecond(int i, int j, celula ** M){ //setando para cima do player
    if (i < 0 || j < 0 || i > l-1 || j > c-1)
        return 0;
    M[i][j].safe = 1; //uponly
    if (i >= 1 && j>= 0 && i <= l-1 && j <= c-1){
        M[i-1][j].safe = 1; //upup
    }
    if (i < 0 || j < 0 || i > l-1 || j > c-2){
    }else{
        M[i][j+1].safe = 1; //upright
    }
    if (i < 0 || j < 1 || i > l-1 || j > c-1){
    }else{
        M[i][j-1].safe = 1; //upleft
    }
    return 0;
}

int leftsecond(int i, int j, celula ** M){
    if (i < 0 || j < 0 || i > l-1 || j > c-1){
        return 0;
    }
    M[i][j].safe = 1;//left
    if (j-1 >= 0){
        M[i][j-1].safe = 1; //leftleft
    }
}
int rightsecond(int i, int j, celula ** M){
    if (i < 0 || j < 0 || i > l-1 || j > c-1){
        return 0;
    }
    M[i][j].safe = 1;//right
    if (j+1 <= c-1){
        M[i][j+1].safe = 1; //rightright
    }
    return 0;
}
int downsecond(int i, int j, celula ** M){
    if (i < 0 || j < 0 || i > l-1 || j > c-1)
        return 0;
    M[i][j].safe = 1; //downonly
    if (i+1 <= l-1 && j <= c-1){
        M[i+1][j].safe = 1; //downdown
    }
    if(j+1 <= c-1){
        M[i][j+1].safe = 1; //downright
    }
    if(j-1 >= 0){
        M[i][j-1].safe = 1; //downleft
    }
    return 0;

}

void marksafe1(int i, int j, celula ** M){ //caso não tenha nenhuma sensação
    M[i][j].safe = 1;
    upfirst(i-1, j ,M);
    downfirst(i+1, j ,M);
    leftfirst(i, j-1, M);
    rightfirst(i, j+1, M);
}

void marksafe2(int i, int j, celula ** M){ //somente sensações fracas
    M[i][j].safe = 1;
    downsecond(i+1, j ,M);
    rightsecond(i, j+1, M);
    leftsecond(i, j-1, M);
    upsecond(i-1, j ,M);
}

void marksafe3(int i, int j, celula ** M){ //somente sensações médias - talvez desnecessário
    if(i>0)
        M[i-1][j].safe = 1;
    if(i<l-1)
        M[i+1][j].safe = 1;
    if(j>0)
        M[i][j-1].safe = 1;
    if(j<c-1)
        M[i][j+1].safe = 1;
}

int monstroperto(int i, int j, celula ** M){

    M[i][j].visited = 1;
    if(i>0){
        M[i-1][j].monstro++;
        M[i-1][j].safe = 2;
    }
    if(j>0){
        M[i][j-1].monstro++;
        M[i][j-1].safe = 2;
    }
    if(i<l-1){
        M[i+1][j].monstro++;
        M[i+1][j].safe = 2;
    }
    if(l<c-1){
        M[i][j+1].monstro++;
        M[i][j+1].safe = 2;
    }
    return 0;
}

int abismoperto(int i, int j, celula ** M){
    if(M[i][j].visited = 1){
        return 0;
    }
    M[i][j].visited = 1;
    if(i>0){
        M[i-1][j].abismo++;
        M[i-1][j].safe = 2;
    }
    if(j>0){
        M[i][j-1].abismo++;
        M[i][j-1].safe = 2;
    }
    if(i<l-1){
        M[i+1][j].abismo++;
        M[i+1][j].safe = 2;
    }
    if(l<c-1){
        M[i][j+1].abismo++;
        M[i][j+1].safe = 2;
    }
    return 0;
}

void killmonstro(int i, int j, celula ** M){
    char side;
    int go = 0;
    if(i>0){
        if(M[i-1][j].monstro >= 3){
            side = 'w';
            go++;
        }
    }
    if(j>0){
        if(M[i][j-1].monstro >= 3){
            side = 'a';
            go++;
        }
    }
    if(i<l-1){
        if(M[i+1][j].monstro >= 3){
            side = 's';
            go++;
        }
    }
    if(l<c-1){
        if(M[i][j+1].monstro >= 3){
            side = 'd';
            go++;
        }
    }
    if(go != 0){
        shoot(i,j,M,side);
    }

}

int safemarking(int i, int j, celula ** M){
    if(M[i][j].visited == 1){
        return 0;
    }
    printf("-----------------marcação sendo feita aqui coordenada {%d, %d}-------------\n", i, j);
/*    if(sense == 0){
        marksafe1(i,j,M);
    }
    if(sense != 0 && M[i][j].brisaMedia == 0 && M[i][j].brisaForte == 0 && M[i][j].cheiroMedio == 0 && M[i][j].cheiroForte == 0){
        marksafe2(i,j,M);
    }
    if(sense != 0 && M[i][j].brisaFraca == 0 && M[i][j].brisaForte == 0 && M[i][j].cheiroFraco == 0 && M[i][j].cheiroForte == 0){
        marksafe3(i,j,M);
    }*/
    if(M[i][j].cheiroForte == 1){
        monstroperto(i,j,M); //monstro perto
        killmonstro(i,j,M);
    }
    if(M[i][j].brisaForte >= 1){
        abismoperto(i,j,M); //vai falar que tem chance de abismo perto
    }
    return 0;
}

// ----------------------------Fim funções IA---------------------------------//


int main() {
    int i, j, k = 0;
    int begin, end;
    char side, dir;

 //-----Função de leitura--------//
    FILE* fp;
    char* mat_content; //vetor que tem a leitura

    celula **M;

    fp = fopen("matriz.txt", "r");

    if (fp==NULL)
        return -1;

    //----Fim leitura arquivo----//
    //Próximas 2 linhas scanf do arquivo
    fscanf(fp, "%d", &l);
    fscanf(fp, "%d", &c);
    steps = l*c;

    //-------Declaração da matriz ------//
    M = (celula **)calloc((l), sizeof(celula*)); //declara setando como 0

    for(i=0; i<l; i++)
       M[i] = (celula *)calloc(c, sizeof(celula)); //declara setando como 0

    begin = ftell(fp); //começo após os números (é um \n)

    fseek(fp, 0, SEEK_END); //vai até o fim

    end = ftell(fp); //conta a posição do fim

    fseek(fp, begin+1, SEEK_SET); //começa a setar à partir do begin

    mat_content = (char*)malloc((end-begin)*sizeof(char)); //alocação

    fread(mat_content,sizeof(char), (end-begin), fp); //read

    //-------Fim Declaração da Matriz -------//
    //------Atribuição de cada tipo à struct-------//

    for(i=0; i<l; i++){
        for(j=0; j<c; j++){
            while(k < (end - begin) && mat_content[k] != '\n'){
                if (mat_content[k] == 'A')
                    M[i][j].tipo = 1; // Abismo é tipo 1
                if (mat_content[k] == 'M')
                    M[i][j].tipo = 2; // Monstro é tipo 2
                if (mat_content[k] == 'L')
                    M[i][j].tipo = 3; // Luz é tipo 3
                if (mat_content[k] == 'B')
                    M[i][j].brisaForte++; //é B
                if (mat_content[k] == 'C')
                    M[i][j].cheiroForte++; //é C
                if (mat_content[k] == 'b'){
                        if(mat_content[k+1] == 'B'){
                            M[i][j].brisaMedia++; //é bB
                            k++;
                        }else{
                            M[i][j].brisaFraca++; //é b
                        }
                }
                if (mat_content[k] == 'c'){
                        if(mat_content[k+1] == 'C'){
                            M[i][j].cheiroMedio++; //é cC
                            k++;
                        }else{
                            M[i][j].cheiroFraco++; //é c
                        }
                }
                k++;
            }//Duas linhas  abaixo testando o scan
            k++;
            //printf("\ni = %d, j = %d k = %d - [%d %d %d %d %d %d %d]", i, j, k, M[i][j].tipo, M[i][j].brisaFraca, M[i][j].brisaMedia, M[i][j].brisaForte, M[i][j].cheiroFraco, M[i][j].cheiroMedio, M[i][j].cheiroForte);
        }
    }
    //--------Fim da Atribuição-----------//


    i = 0;
    j = 0;
    system("clear");
    // -------------------------------Switch Type of Player-------------------------------//
    printf("Digite 1 caso queira jogar, digite 0 caso queira ver a IA jogando.\n");
    int playermode = 1;
    scanf("%d%*c", &playermode);

    //--------------------------------------Player Mode -------------------------------------------//
    printf("\nVocê se encontra no mundo de wumpus, o labirinto do terrível monstro!\n\n");
    printf("O labirinto consiste de abismos, a luz e o monstro.\n\n\tO seu objetivo é desviar dos abismos");
    printf(", matar o monstro, pegar a luz e voltar para a coordenada {0, 0} para sair à salvo, tudo isso enquanto toma cuidado para não se cansar!\n");
    printf("\n\nControles:\n");
    printf("w - Andar para cima\n");
    printf("s - Andar para baixo\n");
    printf("d - Andar para a direita\n");
    printf("a - Andar para a esquerda\n");
    printf("e - Atirar flecha\n");
    printf("q - Perguntar\n");
    printf("c - Acessar o menu de controles\n\n");
    printf("Você está na coordenada {0, 0} e o tamanho do mapa é %d linhas x %d colunas\n", l, c);
    printf("Ajuste o tamanho do terminal até que as linhas abaixo fiquem continuas\n");
    if(playermode == 1){
        while (steps > 0){
            sense = 0;
            printf("--------------------------------------------------------------------------------");
            printf("Para que lado quer andar? \n");
            scanf("%c%*c",&dir);
            system("clear");
            if(dir == 'c'){
                printf("\n\nControles:\n");
                printf("w - Andar para cima\n");
                printf("s - Andar para baixo\n");
                printf("d - Andar para a direita\n");
                printf("a - Andar para a esquerda\n");
                printf("e - Atirar flecha\n");
                printf("q - Perguntar\n");
                printf("c - Acessa o menu de controles\n");
            }
            if(dir == 'q'){
                printf("Para que lado você quer perguntar?\n");
                scanf("%c%*c", &side);
                printf("No quadrado perguntado ");
                askwhat(i, j, M, side);
            }
            if(dir == 'e'){ //q é o modo shoot
                printf("Digite o lado para qual quer atirar\n");
                scanf("%c%*c", &side);
                if(shoot(i, j, M, side) == 1){
                    score += 10000;
                }
                printf("\nPara que lado quer andar? \n");
                scanf("%c%*c", &dir);
                system("clear");
            }
            if(dir == 'w' || dir == 's'){
                i = walk(dir, i, j);
            }
            if(dir == 'a' || dir == 'd'){
                j = walk(dir, i, j);
            }
            printf("\nSua coordenada atual é {%d, %d}\n", i, j);
            printf("Você tem %d passos restantes\n", steps);
            printf("Sua pontuação atual é %d\n\n\n", score);
            sensations(i, j, M);
            if(sense == 0){
                printf("Você experimenta um vazio de sensações...\n");
            }
            printf("--------------------------------------------------------------------------------");
        }
        printf("Você chegou ao fim do jogo, a sua pontuação é: %d\n\n\n", score);
    }
    //----------------------------- Automatic Mode -------------------------------------//

    if(playermode == 0){ //
        int direction = 0;
        while(steps > 0){
            printf("--------------------------------------------------------------------------------");
            printf("\nA coordenada atual é {%d, %d}\n", i, j);
            printf("A IA tem %d passos restantes\n", steps);
            printf("A pontuação atual é %d\n", score);
            printf("--------------------------------------------------------------------------------");

            sense = 0;
            printf("coordenada {%d;%d}", i, j);
            sensations(i,j, M); //pega as sensações para a IA
            safemarking(i,j,M); //marca safe, deve ser colocado após cada passo juntamente com um sense = 0 e sensations
            if(i == 0){ //walk down
                if(M[i+1][j].safe != 0){
                    dir = 's'; //para baixo
                    i = walk(dir, i, j); //isso é uma jogada, pro caso de i ser 0, é desvantajoso
                    sensations(i, j, M);
                    safemarking(i,j,M);
                }
            }
            if(i == l-1){ //walk up
                if(M[i-1][j].safe != 0){
                    dir = 'w';
                    i = walk(dir, i, j); //isso é uma jogada, pro caso de i ser l-1, é desvantajoso
                    sensations(i, j, M);
                    safemarking(i,j,M);
                }
            }
            if(M[i-1][j].safe != 0 && M[i-1][j].visited != 1){ //perguntar para cima
                    side = 'w';
                    sense = 0;
                    askwhat(i,j, M, side);
                    safemarking(i,j,M);
            }
            printf("\n\n DEBUG 2.0\n\n");
            if(M[i+1][j].safe != 0){ //perguntar para baixo
                side = 's';
                if (i<l-1){
                    if (M[i+1][j].visited != 1){
                        sense = 0;
                        askwhat(i,j, M, side);
                        safemarking(i,j,M);
                    }
                }
            }
            if(j == c-1 && i != l-1){ //virando o lado, andando 2 pra baixo (caso chegue no ponto max à direita)
                direction = 1;
                dir = 's';
                if (M[i+1][j].safe != 0){ //anda pra baixo
                    i = walk(dir, i, j);
                    sense = 0;
                    sensations(i,j,M);
                    safemarking(i,j,M);
                }
                if(i<l-1){
                    if (M[i+1][j].safe != 0){
                        i = walk(dir, i, j);
                        sense = 0;
                        sensations(i,j,M);
                        safemarking(i,j,M);
                }
                }else{ //dê uma voltinha pela esquerda caso n seja safe e pergunte à direita
                    if(M[i][j-1].safe != 0){
                        dir = 'a';
                        j = walk(dir, i, j);
                        sense = 0;
                        sensations(i,j,M);
                        safemarking(i,j,M);
                        if (M[i+1][j].safe != 0){
                            dir = 's';
                            i = walk(dir, i, j);
                            sense = 0;
                            sensations(i,j,M);
                            safemarking(i,j,M);
                        }
                        if (M[i+1][j].safe != 0){
                            dir = 's';
                            i = walk(dir, i, j);
                            sense = 0;
                            sensations(i,j,M);
                            safemarking(i,j,M);
                        }
                        if(M[i][j+1].safe != 0){
                            sense = 0;
                            side = 'd';
                            askwhat(i,j, M, side);
                        }
                    }
                }
            }
            if(direction == 0){
                if(j<c-1){
                    dir = 'd';
                    if (M[i][j+1].safe != 0){ //------------------------------falta fazer voltinha(else)
                        j = walk(dir, i, j);
                        sense = 0;
                        sensations(i,j,M);
                        safemarking(i,j,M);
                    }else{ //voltinha
                        if(M[i+1][j].safe != 0){ //up voltinha
                            dir = 'w';
                            i = walk(dir, i, j);
                            sense = 0;
                            sensations(i,j,M);
                            safemarking(i,j,M);
                            if(j<c-1){
                                if (M[i][j+1].safe != 0){ //double left voltinha
                                    dir = 'd';
                                    j = walk(dir, i, j);
                                    sense = 0;
                                    sensations(i,j,M);
                                    safemarking(i,j,M);
                                }
                            }
                            if(j<c-1){
                                if (M[i][j+1].safe != 0){
                                    dir = 'd';
                                    j = walk(dir, i, j);
                                    sense = 0;
                                    sensations(i,j,M);
                                    safemarking(i,j,M);
                                }                       // ----- Fim double left -----//
                            }
                            if(M[i-1][j].safe != 0){
                                dir = 's';
                                i = walk(dir, i, j);
                                sense = 0;
                                sensations(i,j,M);
                                safemarking(i,j,M);
                            }
                        }
                    }
                }
            }
            if(direction == 1){ //andar para a esquerda
                if(j>0){
                    dir = 'a';
                    if (M[i][j-1].safe != 0){ //------------------------------falta fazer voltinha(else)
                        j = walk(dir, i, j);
                        sense = 0;
                        sensations(i,j,M);
                        safemarking(i,j,M);
                    }else{ //voltinha
                        if(M[i+1][j].safe != 0){ //up voltinha
                            dir = 'w';
                            i = walk(dir, i, j);
                            sense = 0;
                            sensations(i,j,M);
                            safemarking(i,j,M);
                            if(j<c-1){
                                if (M[i][j-1].safe != 0){ //double right voltinha
                                    dir = 'a';
                                    j = walk(dir, i, j);
                                    sense = 0;
                                    sensations(i,j,M);
                                    safemarking(i,j,M);
                                }
                            }
                            if(j<c-1){
                                if (M[i][j-1].safe != 0){
                                    dir = 'a';
                                    j = walk(dir, i, j);
                                    sense = 0;
                                    sensations(i,j,M);
                                    safemarking(i,j,M);
                                }                       // ----- Fim double left -----//
                            }
                            if(M[i-1][j].safe != 0){
                                dir = 's';
                                i = walk(dir, i, j);
                                sense = 0;
                                sensations(i,j,M);
                                safemarking(i,j,M);
                            }
                        }
                    }
                }
            }
        }
    }



    // --------------------------- Fim automatic mode ------------------------//


    //--------- Dando free no programa--------/

    fclose(fp);

    for(i=0; i<l; i++)
        free(M[i]);

    free(M);

    free(mat_content);

    //--------- Fim do free ----------//

    return 0;
}