VOID dobranch_Correlation(ADDRINT des, ADDRINT ins, BOOL judge) { 

        //Achar Indices
        int indice7  = TestarMask(Bits, 127);
        int indice8  = TestarMask(Bits, 255);
        int indice9  = TestarMask(Bits, 511);
        int indice10 = TestarMask(Bits, 1023);
        int indice11 = TestarMask(Bits, 2047);
        int indice12 = TestarMask(Bits, 4095);
        int indice13 = TestarMask(Bits, 8191);
        int indice14 = TestarMask(Bits, 16383);

        UINT64 i, tag;
        i = TestarMask(ins, 4095);
        tag = FindTag(ins, 12);


        //7 bits
        Analisar(des, ins, judge, i, tag, Acertos_correlation_7bits, Erros_correlation_7bits, correlation_btb_7bit, indice7, correlation_7bits);   
        //8 bits
        Analisar(des, ins, judge, i, tag, Acertos_correlation_8bits, Erros_correlation_8bits, correlation_btb_8bit, indice8, correlation_8bits);
        //9 bits
        Analisar(des, ins, judge, i, tag, Acertos_correlation_9bits, Erros_correlation_9bits, correlation_btb_9bit, indice9, correlation_9bits);
        //10 bits
        Analisar(des, ins, judge, i, tag, Acertos_correlation_10bits, Erros_correlation_10bits, correlation_btb_10bit, indice10, correlation_10bits);
        //11 bits
        Analisar(des, ins, judge, i, tag, Acertos_correlation_11bits, Erros_correlation_11bits, correlation_btb_11bit, indice11, correlation_11bits);
        //12 bits
        Analisar(des, ins, judge, i, tag, Acertos_correlation_12bits, Erros_correlation_12bits, correlation_btb_12bit, indice12, correlation_12bits);
        //13 bits
        Analisar(des, ins, judge, i, tag, Acertos_correlation_13bits, Erros_correlation_13bits, correlation_btb_13bit, indice13, correlation_13bits);
        //14 bits
        Analisar(des, ins, judge, i, tag, Acertos_correlation_14bits, Erros_correlation_14bits, correlation_btb_14bit, indice14, correlation_14bits);


        //Feito no final o deslocamento.
        Bits = MoveBit(Bits, judge);

        if(judge) takenBranch++;
        else nTakenBranch++;
}
int main(void)
{
    int CasosTeste, N, M, p1, p2, L, j, CentroVet;
    int **MatrizAdj=NULL, i, k, *VetorPessoasAnalisadas=NULL, *VetMax=NULL;

    //Ler o Número de casos de teste
    scanf("%d", &CasosTeste);

    //Loop que executa os casos testes
    for (k = 0; k < CasosTeste; ++k)
    {
        //fflush(stdin);
        //Ler o Número de Pessoas no Facebook e o número de relações existentes, respectivamente
        scanf("%d %d", &N, &M);

        //Criando Matriz de Adjacência
        MatrizAdj=(int**)calloc((N+1), sizeof(int*));
        for (i = 0; i < (N+1); ++i)
        {
            MatrizAdj[i]=(int*)calloc((N+1), sizeof(int));
        }

        //Inicializando a matriz com valor "infinito"
        for (i = 1; i < N+1; ++i)
        {
            for (j = 1; j < N+1; ++j)
            {
                if (i != j)
                {
                    MatrizAdj[i][j] = INF;
                }
            }
        }

        //Inserindo as Relações na Matriz de Adjacência
        for (i = 0; i < M; ++i)
        {
            scanf("%d %d", &p1, &p2);
            MatrizAdj[p1][p2] = 1;
            MatrizAdj[p2][p1] = 1;
        }

        //Ler número de Pessoas que Zequinha quer analisar
        scanf("%d", &L);

        //Alocar vetor para pessoas a serem analisadas
        VetorPessoasAnalisadas=(int*)calloc(L, sizeof(int));
        //Ler as Pessoas que Zequinha quer analisar
        for (i = 0; i < L; ++i)
        {
            scanf("%d", &VetorPessoasAnalisadas[i]);
        }
        
        //Algoritmo Floyd
        floyd(MatrizAdj, N);
        //Retorna um vetor com os valores máximos de cada coluna da Matriz de Adjacência após a execução do Algoritmo Floyd
        VetMax=MaxColuna(MatrizAdj, N);
        //Encontra o vértice Central
        CentroVet=VerticeCentral(VetMax, N);
        printf("%d", CentroVet);

        //Analisar os outros pontos em relação ao termo central
        Analisar(MatrizAdj, CentroVet, VetorPessoasAnalisadas, L);

        //Desalocar o Vetor de pessoas
        free(VetorPessoasAnalisadas);

        //Desalocando a matriz de Adjacencia
        for (j = 0; j < (N+1); j++)
        {
            free(MatrizAdj[j]);
        }

        free(MatrizAdj);

        free(VetMax);
    }

    return 0;
}