#!/usr/bin/perl -w

use strict;


open (FITXERMEU,"<$ARGV[0]");


my %motiu = ("A" => [0,0,0,0,0,0,0,0,0],
	     "C" => [0,0,0,0,0,0,0,0,0],
	     "G" => [0,0,0,0,0,0,0,0,0],
	     "T" => [0,0,0,0,0,0,0,0,0]);
my $nom;

my $posicio = 0;

my $compta = 0;

my $i;




while (<FITXERMEU>){

    if ($_ =~ m/FA\s+(.+)\s+.\w./){

	$nom = $1;

	print "\n$nom\n";

    }

    if ($_=~ m/\d+\t(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/){
 
	$motiu{"A"}[$posicio]= $1;

	$motiu{"C"}[$posicio]= $2;

	$motiu{"G"}[$posicio]= $3;

	$motiu{"T"}[$posicio]= $4;

	$posicio = $posicio +1;

	$compta = $compta +1;
    }


    
 
    if (($_ =~ m/(\/\/)\Z/) && ($compta > 1)) { 

#així ens determinarà que ha acabat de llegir el hash.

   
	open(SEQUENCIA, "<$ARGV[1]");

	my $dna = " ";
	my @seq;
	my $longitud = 0;

	while (<SEQUENCIA>){
	    chomp ($_);
	    if ($_ =~ m/>/){
	    }
	    else {
		$dna = $dna.$_;
	    }
	}

	close (SEQUENCIA); #les dades de la seq ja es troben en la variable.



	@seq = split(//,$dna);

	$longitud = scalar(@seq);






	my $pos = 0;

	my $A = 0;

	my $C = 0;

	my $G = 0;

	my $T = 0;


	while ($pos < $longitud) {

	    if ($seq[$pos] eq 'A' || $seq[$pos] eq 'a' ) {

		$A = $A + 1;

	    }

	    if ($seq[$pos] eq 'C' || $seq[$pos] eq 'c') {

		$C = $C + 1;

	    }

	    if ($seq[$pos] eq 'G' || $seq[$pos] eq 'g') {

		$G = $G + 1;

	    }

	    if ($seq[$pos] eq 'T' || $seq[$pos] eq 't') {

		$T = $T + 1;

	    }

	    $pos = $pos + 1;

	}


	my $probA;

	my $probC;

	my $probG;

	my $probT;


	if ($A == 0) {

	    $probA = -999;

	}

	else { $probA = log($A / $longitud) / log(10);

	   }

	if ($C == 0) {

	    $probC = -999;

	}

	else { $probC = log($C / $longitud) / log(10);

	   }

	if ($G == 0) {

	    $probG = -999;

	}

	else { $probG = log($G / $longitud) / log(10);

	   }

	if ($T == 0) {

	    $probT = -999;

	}

	else { $probT = log($T / $longitud) / log(10);

	   }

	

# Fem una nova matriu on ens incorpori els logaritmes de probabilitat en cada posició. A més hi restarem els logaritmes de la seqüència promotora.

	my %logaritme = ("A" => [0,0,0,0,0,0,0,0,0],
			 "C" => [0,0,0,0,0,0,0,0,0],
			 "G" => [0,0,0,0,0,0,0,0,0],
			 "T" => [0,0,0,0,0,0,0,0,0]);

	$posicio = 0;
#!/usr/bin/perl -w

use strict;

open (FITXERMEU,"<$ARGV[0]");


my %motiu = ("A" => [0,0,0,0,0,0,0,0,0],
	     "C" => [0,0,0,0,0,0,0,0,0],
	     "G" => [0,0,0,0,0,0,0,0,0],
	     "T" => [0,0,0,0,0,0,0,0,0]);
my $nom;

my $posicio = 0;
 
my $compta = 0;

my $i;





while (<FITXERMEU>){

    if ($_ =~ m/FA\s+(.+)\s+.\w./){

	$nom = $1;

	print "\n$nom\n";
#!/usr/bin/perl -w

use strict;

open (FITXERMEU,"<$ARGV[0]");


my %motiu = ("A" => [0,0,0,0,0,0,0,0,0],
	     "C" => [0,0,0,0,0,0,0,0,0],
	     "G" => [0,0,0,0,0,0,0,0,0],
	     "T" => [0,0,0,0,0,0,0,0,0]);
my $nom;

my $posicio = 0;
 
my $compta = 0;

my $i;


#!/usr/bin/perl -w

use strict;

open (FITXERMEU,"<$ARGV[0]");


my %motiu = ("A" => [0,0,0,0,0,0,0,0,0],
	     "C" => [0,0,0,0,0,0,0,0,0],
	     "G" => [0,0,0,0,0,0,0,0,0],
	     "T" => [0,0,0,0,0,0,0,0,0]);
my $nom;

my $posicio = 0;
 
my $compta = 0;

my $i;


#!/usr/bin/perl -w

use strict;

open (FITXERMEU,"<$ARGV[0]");


my %motiu = ("A" => [0,0,0,0,0,0,0,0,0],
	     "C" => [0,0,0,0,0,0,0,0,0],
	     "G" => [0,0,0,0,0,0,0,0,0],
	     "T" => [0,0,0,0,0,0,0,0,0]);
my $nom;

my $posicio = 0;
 
my $compta = 0;

my $i;



#!/usr/bin/perl -w

use strict;

open (FITXERMEU,"<$ARGV[0]");


my %motiu = ("A" => [0,0,0,0,0,0,0,0,0],
	     "C" => [0,0,0,0,0,0,0,0,0],
	     "G" => [0,0,0,0,0,0,0,0,0],
	     "T" => [0,0,0,0,0,0,0,0,0]);
my $nom;

my $posicio = 0;
 
my $compta = 0;

my $i;





while (<FITXERMEU>){

    if ($_ =~ m/FA\s+(.+)\s+.\w./){

	$nom = $1;

	print "\n$nom\n";

    }

    if ($_=~ m/\d+\t(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/){
 
	$motiu{"A"}[$posicio]= $1;

	$motiu{"C"}[$posicio]= $2;

	$motiu{"G"}[$posicio]= $3;

	$motiu{"T"}[$posicio]= $4;

	$posicio = $posicio +1;

	$compta = $compta +1;
    }


    
 
    if (($_ =~ m/(\/\/)\Z/) && ($compta > 1)) { 

#així ens determinarà que ha acabat de llegir el hash.

   
	open(SEQUENCIA, "<$ARGV[1]");

	my $dna = " ";
	my @seq;
	my $longitud = 0;

	while (<SEQUENCIA>){
	    chomp ($_);
	    if ($_ =~ m/>/){
	    }
	    else {
		$dna = $dna.$_;
	    }
	}

	close (SEQUENCIA); #les dades de la seq ja es troben en la variable.



	@seq = split(//,$dna);

	$longitud = scalar(@seq);






	my $pos = 0;

	my $A = 0;

	my $C = 0;

	my $G = 0;

	my $T = 0;


	while ($pos < $longitud) {

	    if ($seq[$pos] eq 'A' || $seq[$pos] eq 'a' ) {

		$A = $A + 1;

	    }

	    if ($seq[$pos] eq 'C' || $seq[$pos] eq 'c') {

		$C = $C + 1;

	    }

	    if ($seq[$pos] eq 'G' || $seq[$pos] eq 'g') {

		$G = $G + 1;

	    }

	    if ($seq[$pos] eq 'T' || $seq[$pos] eq 't') {

		$T = $T + 1;

	    }

	    $pos = $pos + 1;

	}


	my $probA;

	my $probC;

	my $probG;

	my $probT;


	if ($A == 0) {

	    $probA = -999;

	}

	else { $probA = log($A / $longitud) / log(10);

	   }

	if ($C == 0) {

	    $probC = -999;

	}

	else { $probC = log($C / $longitud) / log(10);

	   }

	if ($G == 0) {

	    $probG = -999;

	}

	else { $probG = log($G / $longitud) / log(10);

	   }

	if ($T == 0) {

	    $probT = -999;

	}

	else { $probT = log($T / $longitud) / log(10);

	   }

	

# Fem una nova matriu on ens incorpori els logaritmes de probabilitat en cada posició. A més hi restarem els logaritmes de la seqüència promotora.

	my %logaritme = ("A" => [0,0,0,0,0,0,0,0,0],
			 "C" => [0,0,0,0,0,0,0,0,0],
			 "G" => [0,0,0,0,0,0,0,0,0],
			 "T" => [0,0,0,0,0,0,0,0,0]);

	$posicio = 0;

	while ($posicio < $compta) { 

	    if ($motiu{"A"}[$posicio] == 0) {

		$logaritme{"A"}[$posicio] = -999;

	    }
	    
	    else {

		$logaritme{"A"}[$posicio] = (log(($motiu{"A"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probA;

	    }

	    if ($motiu{"C"}[$posicio] == 0) {

		$logaritme{"C"}[$posicio] = -999;

	    }

	    else {

		$logaritme{"C"}[$posicio] = (log(($motiu{"C"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probC;

	    }

	    if ($motiu{"G"}[$posicio] == 0) {

		$logaritme{"G"}[$posicio] = -999;

	    }
	    
	    else {

		$logaritme{"G"}[$posicio] = (log(($motiu{"G"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probG;

	    }

	    if ($motiu{"T"}[$posicio] == 0) {

		$logaritme{"T"}[$posicio] = -999;

	    }

	    else {

		$logaritme{"T"}[$posicio] = (log(($motiu{"T"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probT;

	    }

	    $posicio = $posicio + 1;

	}


#
#
#


    

	my $diposit = 0; # Guarda l'score dels motiu
	
	my $millor = -9999999999999 ; # Guarda la millor puntuació
	
	my $motiu = $posicio; # És la llargada de cada matriu de pesos (hash)
			
	my $millorposicio = 0; # Guarda la millor posició 
	
	my $stopft; # Simplement servirà per saber fins a on s'uneix el FT
		
	my $p = 0; # Compta la posició de la seqüència únicament dins del motiu

	my $l = 0; # Per a comptar posició dins del motiu

	my $r; # Recorre les posicions de la seqüència
	
	$r = 0;

	while ($r < $longitud-($motiu)+1) {
	    
	 $l = 0;
	 $diposit = 0;
	 $p=$r;

	    while ($l < $motiu) { 
		
		if ($seq[$p] eq 'G' || $seq[$p] eq 'g' ){
		    $diposit = $logaritme{"G"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'A' || $seq[$p] eq 'a' ){
		    $diposit = $logaritme{"A"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'C' || $seq[$p] eq 'c' ){
		    $diposit = $logaritme{"C"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'T' || $seq[$p] eq 't' ){
		    $diposit = $logaritme{"T"}[$l] + $diposit;
		}
		$p = $p + 1;
		$l = $l + 1; 
			
	    }	
	    if ($diposit > $millor) {
		$millor = $diposit;
		$millorposicio = $r;
	
		$stopft=$millorposicio+$motiu-1;
	    }

	    $r = $r +1;
	      
	}

	

	print "Quan aquest FT s'uneix a la seqüència promotora en els nucleòtids $millorposicio - $stopft té la millor puntuació, que és $millor\n";
	

#
#
#


	my $voltes = 0; # Per a comptar les 100 vegades
	
	my $c = 0; # Vegades que el millorrandom és igual o superior a $millor

	my $pvalue;
	


	while ($voltes < 100 ){
   
	    my $i = $longitud - 1;
	    
	    while ($i >= 0) {
		
		my $j = int(rand($i+1));
		
		if ($i != $j) {
		    
		    my $tmp = $seq[$i];
		    
		    $seq[$i] = $seq[$j];
		    $seq[$j] = $tmp;
		}
		$i = $i - 1;
	    }
	    
	   
	my $millorrandom = -999999; # Guardarem la millor puntuació del factor de transcripció en la seqüència random

	$r = 0;


	while ($r < $longitud-($motiu)+1) {
	    
	 $l = 0;
	 $diposit = 0;
	 $p=$r;

	    while ($l < $motiu) { 
		
		if ($seq[$p] eq 'G' || $seq[$p] eq 'g' ){
		    $diposit = $logaritme{"G"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'A' || $seq[$p] eq 'a' ){
		    $diposit = $logaritme{"A"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'C' || $seq[$p] eq 'c' ){
		    $diposit = $logaritme{"C"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'T' || $seq[$p] eq 't' ){
		    $diposit = $logaritme{"T"}[$l] + $diposit;
		}
		$p = $p + 1;
		$l = $l + 1; 
			
	    }	
	    if ($diposit > $millorrandom) {
		$millorrandom = $diposit;
	
	    }
	    
	    $r = $r +1;
	      
     }
  
	
	    
	    if ($millorrandom >= $millor){
		
		$c = $c + 1;
		
	    }
	    
	    $voltes = $voltes + 1;
	}
	
	
	    
	$pvalue = $c/100;
	    
	print "El p-value de $nom és igual o mes petit que $pvalue \n";
	print "\n";





	%motiu = ("A" => [0,0,0,0,0,0,0,0,0],
	  	  "C" => [0,0,0,0,0,0,0,0,0],
	    	  "G" => [0,0,0,0,0,0,0,0,0],
	     	  "T" => [0,0,0,0,0,0,0,0,0]);

	$compta = 0;

	$posicio = 0;
	
    } # Final del tercer "if". Canvi de matriu!


}

close (FITXERMEU);


while (<FITXERMEU>){

    if ($_ =~ m/FA\s+(.+)\s+.\w./){

	$nom = $1;

	print "\n$nom\n";

    }

    if ($_=~ m/\d+\t(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/){
 
	$motiu{"A"}[$posicio]= $1;

	$motiu{"C"}[$posicio]= $2;

	$motiu{"G"}[$posicio]= $3;

	$motiu{"T"}[$posicio]= $4;

	$posicio = $posicio +1;

	$compta = $compta +1;
    }


    
 
    if (($_ =~ m/(\/\/)\Z/) && ($compta > 1)) { 

#així ens determinarà que ha acabat de llegir el hash.

   
	open(SEQUENCIA, "<$ARGV[1]");

	my $dna = " ";
	my @seq;
	my $longitud = 0;

	while (<SEQUENCIA>){
	    chomp ($_);
	    if ($_ =~ m/>/){
	    }
	    else {
		$dna = $dna.$_;
	    }
	}

	close (SEQUENCIA); #les dades de la seq ja es troben en la variable.



	@seq = split(//,$dna);

	$longitud = scalar(@seq);






	my $pos = 0;

	my $A = 0;

	my $C = 0;

	my $G = 0;

	my $T = 0;


	while ($pos < $longitud) {

	    if ($seq[$pos] eq 'A' || $seq[$pos] eq 'a' ) {

		$A = $A + 1;

	    }

	    if ($seq[$pos] eq 'C' || $seq[$pos] eq 'c') {

		$C = $C + 1;

	    }

	    if ($seq[$pos] eq 'G' || $seq[$pos] eq 'g') {

		$G = $G + 1;

	    }

	    if ($seq[$pos] eq 'T' || $seq[$pos] eq 't') {

		$T = $T + 1;

	    }

	    $pos = $pos + 1;

	}


	my $probA;

	my $probC;

	my $probG;

	my $probT;


	if ($A == 0) {

	    $probA = -999;

	}

	else { $probA = log($A / $longitud) / log(10);

	   }

	if ($C == 0) {

	    $probC = -999;

	}

	else { $probC = log($C / $longitud) / log(10);

	   }

	if ($G == 0) {

	    $probG = -999;

	}

	else { $probG = log($G / $longitud) / log(10);

	   }

	if ($T == 0) {

	    $probT = -999;

	}

	else { $probT = log($T / $longitud) / log(10);

	   }

	

# Fem una nova matriu on ens incorpori els logaritmes de probabilitat en cada posició. A més hi restarem els logaritmes de la seqüència promotora.

	my %logaritme = ("A" => [0,0,0,0,0,0,0,0,0],
			 "C" => [0,0,0,0,0,0,0,0,0],
			 "G" => [0,0,0,0,0,0,0,0,0],
			 "T" => [0,0,0,0,0,0,0,0,0]);

	$posicio = 0;

	while ($posicio < $compta) { 

	    if ($motiu{"A"}[$posicio] == 0) {

		$logaritme{"A"}[$posicio] = -999;

	    }
	    
	    else {

		$logaritme{"A"}[$posicio] = (log(($motiu{"A"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probA;

	    }

	    if ($motiu{"C"}[$posicio] == 0) {

		$logaritme{"C"}[$posicio] = -999;

	    }

	    else {

		$logaritme{"C"}[$posicio] = (log(($motiu{"C"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probC;

	    }

	    if ($motiu{"G"}[$posicio] == 0) {

		$logaritme{"G"}[$posicio] = -999;

	    }
	    
	    else {

		$logaritme{"G"}[$posicio] = (log(($motiu{"G"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probG;

	    }

	    if ($motiu{"T"}[$posicio] == 0) {

		$logaritme{"T"}[$posicio] = -999;

	    }

	    else {

		$logaritme{"T"}[$posicio] = (log(($motiu{"T"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probT;

	    }

	    $posicio = $posicio + 1;

	}


#
#
#


    

	my $diposit = 0; # Guarda l'score dels motiu
	
	my $millor = -9999999999999 ; # Guarda la millor puntuació
	
	my $motiu = $posicio; # És la llargada de cada matriu de pesos (hash)
			
	my $millorposicio = 0; # Guarda la millor posició 
	
	my $stopft; # Simplement servirà per saber fins a on s'uneix el FT
		
	my $p = 0; # Compta la posició de la seqüència únicament dins del motiu

	my $l = 0; # Per a comptar posició dins del motiu

	my $r; # Recorre les posicions de la seqüència
	
	$r = 0;

	while ($r < $longitud-($motiu)+1) {
	    
	 $l = 0;
	 $diposit = 0;
	 $p=$r;

	    while ($l < $motiu) { 
		
		if ($seq[$p] eq 'G' || $seq[$p] eq 'g' ){
		    $diposit = $logaritme{"G"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'A' || $seq[$p] eq 'a' ){
		    $diposit = $logaritme{"A"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'C' || $seq[$p] eq 'c' ){
		    $diposit = $logaritme{"C"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'T' || $seq[$p] eq 't' ){
		    $diposit = $logaritme{"T"}[$l] + $diposit;
		}
		$p = $p + 1;
		$l = $l + 1; 
			
	    }	
	    if ($diposit > $millor) {
		$millor = $diposit;
		$millorposicio = $r;
	
		$stopft=$millorposicio+$motiu-1;
	    }

	    $r = $r +1;
	      
	}

	

	print "Quan aquest FT s'uneix a la seqüència promotora en els nucleòtids $millorposicio - $stopft té la millor puntuació, que és $millor\n";
	

#
#
#


	my $voltes = 0; # Per a comptar les 100 vegades
	
	my $c = 0; # Vegades que el millorrandom és igual o superior a $millor

	my $pvalue;
	


	while ($voltes < 100 ){
   
	    my $i = $longitud - 1;
	    
	    while ($i >= 0) {
		
		my $j = int(rand($i+1));
		
		if ($i != $j) {
		    
		    my $tmp = $seq[$i];
		    
		    $seq[$i] = $seq[$j];
		    $seq[$j] = $tmp;
		}
		$i = $i - 1;
	    }
	    
	   
	my $millorrandom = -999999; # Guardarem la millor puntuació del factor de transcripció en la seqüència random

	$r = 0;


	while ($r < $longitud-($motiu)+1) {
	    
	 $l = 0;
	 $diposit = 0;
	 $p=$r;

	    while ($l < $motiu) { 
		
		if ($seq[$p] eq 'G' || $seq[$p] eq 'g' ){
		    $diposit = $logaritme{"G"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'A' || $seq[$p] eq 'a' ){
		    $diposit = $logaritme{"A"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'C' || $seq[$p] eq 'c' ){
		    $diposit = $logaritme{"C"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'T' || $seq[$p] eq 't' ){
		    $diposit = $logaritme{"T"}[$l] + $diposit;
		}
		$p = $p + 1;
		$l = $l + 1; 
			
	    }	
	    if ($diposit > $millorrandom) {
		$millorrandom = $diposit;
	
	    }
	    
	    $r = $r +1;
	      
     }
  
	
	    
	    if ($millorrandom >= $millor){
		
		$c = $c + 1;
		
	    }
	    
	    $voltes = $voltes + 1;
	}
	
	
	    
	$pvalue = $c/100;
	    
	print "El p-value de $nom és igual o mes petit que $pvalue \n";
	print "\n";





	%motiu = ("A" => [0,0,0,0,0,0,0,0,0],
	  	  "C" => [0,0,0,0,0,0,0,0,0],
	    	  "G" => [0,0,0,0,0,0,0,0,0],
	     	  "T" => [0,0,0,0,0,0,0,0,0]);

	$compta = 0;

	$posicio = 0;
	
    } # Final del tercer "if". Canvi de matriu!


}

close (FITXERMEU);



while (<FITXERMEU>){

    if ($_ =~ m/FA\s+(.+)\s+.\w./){

	$nom = $1;

	print "\n$nom\n";

    }

    if ($_=~ m/\d+\t(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/){
 
	$motiu{"A"}[$posicio]= $1;

	$motiu{"C"}[$posicio]= $2;

	$motiu{"G"}[$posicio]= $3;

	$motiu{"T"}[$posicio]= $4;

	$posicio = $posicio +1;

	$compta = $compta +1;
    }


    
 
    if (($_ =~ m/(\/\/)\Z/) && ($compta > 1)) { 

#així ens determinarà que ha acabat de llegir el hash.

   
	open(SEQUENCIA, "<$ARGV[1]");

	my $dna = " ";
	my @seq;
	my $longitud = 0;

	while (<SEQUENCIA>){
	    chomp ($_);
	    if ($_ =~ m/>/){
	    }
	    else {
		$dna = $dna.$_;
	    }
	}

	close (SEQUENCIA); #les dades de la seq ja es troben en la variable.



	@seq = split(//,$dna);

	$longitud = scalar(@seq);






	my $pos = 0;

	my $A = 0;

	my $C = 0;

	my $G = 0;

	my $T = 0;


	while ($pos < $longitud) {

	    if ($seq[$pos] eq 'A' || $seq[$pos] eq 'a' ) {

		$A = $A + 1;

	    }

	    if ($seq[$pos] eq 'C' || $seq[$pos] eq 'c') {

		$C = $C + 1;

	    }

	    if ($seq[$pos] eq 'G' || $seq[$pos] eq 'g') {

		$G = $G + 1;

	    }

	    if ($seq[$pos] eq 'T' || $seq[$pos] eq 't') {

		$T = $T + 1;

	    }

	    $pos = $pos + 1;

	}


	my $probA;

	my $probC;

	my $probG;

	my $probT;


	if ($A == 0) {

	    $probA = -999;

	}

	else { $probA = log($A / $longitud) / log(10);

	   }

	if ($C == 0) {

	    $probC = -999;

	}

	else { $probC = log($C / $longitud) / log(10);

	   }

	if ($G == 0) {

	    $probG = -999;

	}

	else { $probG = log($G / $longitud) / log(10);

	   }

	if ($T == 0) {

	    $probT = -999;

	}

	else { $probT = log($T / $longitud) / log(10);

	   }

	

# Fem una nova matriu on ens incorpori els logaritmes de probabilitat en cada posició. A més hi restarem els logaritmes de la seqüència promotora.

	my %logaritme = ("A" => [0,0,0,0,0,0,0,0,0],
			 "C" => [0,0,0,0,0,0,0,0,0],
			 "G" => [0,0,0,0,0,0,0,0,0],
			 "T" => [0,0,0,0,0,0,0,0,0]);

	$posicio = 0;

	while ($posicio < $compta) { 

	    if ($motiu{"A"}[$posicio] == 0) {

		$logaritme{"A"}[$posicio] = -999;

	    }
	    
	    else {

		$logaritme{"A"}[$posicio] = (log(($motiu{"A"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probA;

	    }

	    if ($motiu{"C"}[$posicio] == 0) {

		$logaritme{"C"}[$posicio] = -999;

	    }

	    else {

		$logaritme{"C"}[$posicio] = (log(($motiu{"C"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probC;

	    }

	    if ($motiu{"G"}[$posicio] == 0) {

		$logaritme{"G"}[$posicio] = -999;

	    }
	    
	    else {

		$logaritme{"G"}[$posicio] = (log(($motiu{"G"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probG;

	    }

	    if ($motiu{"T"}[$posicio] == 0) {

		$logaritme{"T"}[$posicio] = -999;

	    }

	    else {

		$logaritme{"T"}[$posicio] = (log(($motiu{"T"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probT;

	    }

	    $posicio = $posicio + 1;

	}


#
#
#


    

	my $diposit = 0; # Guarda l'score dels motiu
	
	my $millor = -9999999999999 ; # Guarda la millor puntuació
	
	my $motiu = $posicio; # És la llargada de cada matriu de pesos (hash)
			
	my $millorposicio = 0; # Guarda la millor posició 
	
	my $stopft; # Simplement servirà per saber fins a on s'uneix el FT
		
	my $p = 0; # Compta la posició de la seqüència únicament dins del motiu

	my $l = 0; # Per a comptar posició dins del motiu

	my $r; # Recorre les posicions de la seqüència
	
	$r = 0;

	while ($r < $longitud-($motiu)+1) {
	    
	 $l = 0;
	 $diposit = 0;
	 $p=$r;

	    while ($l < $motiu) { 
		
		if ($seq[$p] eq 'G' || $seq[$p] eq 'g' ){
		    $diposit = $logaritme{"G"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'A' || $seq[$p] eq 'a' ){
		    $diposit = $logaritme{"A"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'C' || $seq[$p] eq 'c' ){
		    $diposit = $logaritme{"C"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'T' || $seq[$p] eq 't' ){
		    $diposit = $logaritme{"T"}[$l] + $diposit;
		}
		$p = $p + 1;
		$l = $l + 1; 
			
	    }	
	    if ($diposit > $millor) {
		$millor = $diposit;
		$millorposicio = $r;
	
		$stopft=$millorposicio+$motiu-1;
	    }

	    $r = $r +1;
	      
	}

	

	print "Quan aquest FT s'uneix a la seqüència promotora en els nucleòtids $millorposicio - $stopft té la millor puntuació, que és $millor\n";
	

#
#
#


	my $voltes = 0; # Per a comptar les 100 vegades
	
	my $c = 0; # Vegades que el millorrandom és igual o superior a $millor

	my $pvalue;
	


	while ($voltes < 100 ){
   
	    my $i = $longitud - 1;
	    
	    while ($i >= 0) {
		
		my $j = int(rand($i+1));
		
		if ($i != $j) {
		    
		    my $tmp = $seq[$i];
		    
		    $seq[$i] = $seq[$j];
		    $seq[$j] = $tmp;
		}
		$i = $i - 1;
	    }
	    
	   
	my $millorrandom = -999999; # Guardarem la millor puntuació del factor de transcripció en la seqüència random

	$r = 0;


	while ($r < $longitud-($motiu)+1) {
	    
	 $l = 0;
	 $diposit = 0;
	 $p=$r;

	    while ($l < $motiu) { 
		
		if ($seq[$p] eq 'G' || $seq[$p] eq 'g' ){
		    $diposit = $logaritme{"G"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'A' || $seq[$p] eq 'a' ){
		    $diposit = $logaritme{"A"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'C' || $seq[$p] eq 'c' ){
		    $diposit = $logaritme{"C"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'T' || $seq[$p] eq 't' ){
		    $diposit = $logaritme{"T"}[$l] + $diposit;
		}
		$p = $p + 1;
		$l = $l + 1; 
			
	    }	
	    if ($diposit > $millorrandom) {
		$millorrandom = $diposit;
	
	    }
	    
	    $r = $r +1;
	      
     }
  
	
	    
	    if ($millorrandom >= $millor){
		
		$c = $c + 1;
		
	    }
	    
	    $voltes = $voltes + 1;
	}
	
	
	    
	$pvalue = $c/100;
	    
	print "El p-value de $nom és igual o mes petit que $pvalue \n";
	print "\n";





	%motiu = ("A" => [0,0,0,0,0,0,0,0,0],
	  	  "C" => [0,0,0,0,0,0,0,0,0],
	    	  "G" => [0,0,0,0,0,0,0,0,0],
	     	  "T" => [0,0,0,0,0,0,0,0,0]);

	$compta = 0;

	$posicio = 0;
	
    } # Final del tercer "if". Canvi de matriu!


}

close (FITXERMEU);



while (<FITXERMEU>){

    if ($_ =~ m/FA\s+(.+)\s+.\w./){

	$nom = $1;

	print "\n$nom\n";

    }

    if ($_=~ m/\d+\t(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/){
 
	$motiu{"A"}[$posicio]= $1;

	$motiu{"C"}[$posicio]= $2;

	$motiu{"G"}[$posicio]= $3;

	$motiu{"T"}[$posicio]= $4;

	$posicio = $posicio +1;

	$compta = $compta +1;
    }


    
 
    if (($_ =~ m/(\/\/)\Z/) && ($compta > 1)) { 

#així ens determinarà que ha acabat de llegir el hash.

   
	open(SEQUENCIA, "<$ARGV[1]");

	my $dna = " ";
	my @seq;
	my $longitud = 0;

	while (<SEQUENCIA>){
	    chomp ($_);
	    if ($_ =~ m/>/){
	    }
	    else {
		$dna = $dna.$_;
	    }
	}

	close (SEQUENCIA); #les dades de la seq ja es troben en la variable.



	@seq = split(//,$dna);

	$longitud = scalar(@seq);






	my $pos = 0;

	my $A = 0;

	my $C = 0;

	my $G = 0;

	my $T = 0;


	while ($pos < $longitud) {

	    if ($seq[$pos] eq 'A' || $seq[$pos] eq 'a' ) {

		$A = $A + 1;

	    }

	    if ($seq[$pos] eq 'C' || $seq[$pos] eq 'c') {

		$C = $C + 1;

	    }

	    if ($seq[$pos] eq 'G' || $seq[$pos] eq 'g') {

		$G = $G + 1;

	    }

	    if ($seq[$pos] eq 'T' || $seq[$pos] eq 't') {

		$T = $T + 1;

	    }

	    $pos = $pos + 1;

	}


	my $probA;

	my $probC;

	my $probG;

	my $probT;


	if ($A == 0) {

	    $probA = -999;

	}

	else { $probA = log($A / $longitud) / log(10);

	   }

	if ($C == 0) {

	    $probC = -999;

	}

	else { $probC = log($C / $longitud) / log(10);

	   }

	if ($G == 0) {

	    $probG = -999;

	}

	else { $probG = log($G / $longitud) / log(10);

	   }

	if ($T == 0) {

	    $probT = -999;

	}

	else { $probT = log($T / $longitud) / log(10);

	   }

	

# Fem una nova matriu on ens incorpori els logaritmes de probabilitat en cada posició. A més hi restarem els logaritmes de la seqüència promotora.

	my %logaritme = ("A" => [0,0,0,0,0,0,0,0,0],
			 "C" => [0,0,0,0,0,0,0,0,0],
			 "G" => [0,0,0,0,0,0,0,0,0],
			 "T" => [0,0,0,0,0,0,0,0,0]);

	$posicio = 0;

	while ($posicio < $compta) { 

	    if ($motiu{"A"}[$posicio] == 0) {

		$logaritme{"A"}[$posicio] = -999;

	    }
	    
	    else {

		$logaritme{"A"}[$posicio] = (log(($motiu{"A"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probA;

	    }

	    if ($motiu{"C"}[$posicio] == 0) {

		$logaritme{"C"}[$posicio] = -999;

	    }

	    else {

		$logaritme{"C"}[$posicio] = (log(($motiu{"C"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probC;

	    }

	    if ($motiu{"G"}[$posicio] == 0) {

		$logaritme{"G"}[$posicio] = -999;

	    }
	    
	    else {

		$logaritme{"G"}[$posicio] = (log(($motiu{"G"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probG;

	    }

	    if ($motiu{"T"}[$posicio] == 0) {

		$logaritme{"T"}[$posicio] = -999;

	    }

	    else {

		$logaritme{"T"}[$posicio] = (log(($motiu{"T"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probT;

	    }

	    $posicio = $posicio + 1;

	}


#
#
#


    

	my $diposit = 0; # Guarda l'score dels motiu
	
	my $millor = -9999999999999 ; # Guarda la millor puntuació
	
	my $motiu = $posicio; # És la llargada de cada matriu de pesos (hash)
			
	my $millorposicio = 0; # Guarda la millor posició 
	
	my $stopft; # Simplement servirà per saber fins a on s'uneix el FT
		
	my $p = 0; # Compta la posició de la seqüència únicament dins del motiu

	my $l = 0; # Per a comptar posició dins del motiu

	my $r; # Recorre les posicions de la seqüència
	
	$r = 0;

	while ($r < $longitud-($motiu)+1) {
	    
	 $l = 0;
	 $diposit = 0;
	 $p=$r;

	    while ($l < $motiu) { 
		
		if ($seq[$p] eq 'G' || $seq[$p] eq 'g' ){
		    $diposit = $logaritme{"G"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'A' || $seq[$p] eq 'a' ){
		    $diposit = $logaritme{"A"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'C' || $seq[$p] eq 'c' ){
		    $diposit = $logaritme{"C"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'T' || $seq[$p] eq 't' ){
		    $diposit = $logaritme{"T"}[$l] + $diposit;
		}
		$p = $p + 1;
		$l = $l + 1; 
			
	    }	
	    if ($diposit > $millor) {
		$millor = $diposit;
		$millorposicio = $r;
	
		$stopft=$millorposicio+$motiu-1;
	    }

	    $r = $r +1;
	      
	}

	

	print "Quan aquest FT s'uneix a la seqüència promotora en els nucleòtids $millorposicio - $stopft té la millor puntuació, que és $millor\n";
	

#
#
#


	my $voltes = 0; # Per a comptar les 100 vegades
	
	my $c = 0; # Vegades que el millorrandom és igual o superior a $millor

	my $pvalue;
	


	while ($voltes < 100 ){
   
	    my $i = $longitud - 1;
	    
	    while ($i >= 0) {
		
		my $j = int(rand($i+1));
		
		if ($i != $j) {
		    
		    my $tmp = $seq[$i];
		    
		    $seq[$i] = $seq[$j];
		    $seq[$j] = $tmp;
		}
		$i = $i - 1;
	    }
	    
	   
	my $millorrandom = -999999; # Guardarem la millor puntuació del factor de transcripció en la seqüència random

	$r = 0;


	while ($r < $longitud-($motiu)+1) {
	    
	 $l = 0;
	 $diposit = 0;
	 $p=$r;

	    while ($l < $motiu) { 
		
		if ($seq[$p] eq 'G' || $seq[$p] eq 'g' ){
		    $diposit = $logaritme{"G"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'A' || $seq[$p] eq 'a' ){
		    $diposit = $logaritme{"A"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'C' || $seq[$p] eq 'c' ){
		    $diposit = $logaritme{"C"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'T' || $seq[$p] eq 't' ){
		    $diposit = $logaritme{"T"}[$l] + $diposit;
		}
		$p = $p + 1;
		$l = $l + 1; 
			
	    }	
	    if ($diposit > $millorrandom) {
		$millorrandom = $diposit;
	
	    }
	    
	    $r = $r +1;
	      
     }
  
	
	    
	    if ($millorrandom >= $millor){
		
		$c = $c + 1;
		
	    }
	    
	    $voltes = $voltes + 1;
	}
	
	
	    
	$pvalue = $c/100;
	    
	print "El p-value de $nom és igual o mes petit que $pvalue \n";
	print "\n";





	%motiu = ("A" => [0,0,0,0,0,0,0,0,0],
	  	  "C" => [0,0,0,0,0,0,0,0,0],
	    	  "G" => [0,0,0,0,0,0,0,0,0],
	     	  "T" => [0,0,0,0,0,0,0,0,0]);

	$compta = 0;

	$posicio = 0;
	
    } # Final del tercer "if". Canvi de matriu!


}

close (FITXERMEU);

    }

    if ($_=~ m/\d+\t(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/){
 
	$motiu{"A"}[$posicio]= $1;

	$motiu{"C"}[$posicio]= $2;

	$motiu{"G"}[$posicio]= $3;

	$motiu{"T"}[$posicio]= $4;

	$posicio = $posicio +1;

	$compta = $compta +1;
    }


    
 
    if (($_ =~ m/(\/\/)\Z/) && ($compta > 1)) { 

#així ens determinarà que ha acabat de llegir el hash.

   
	open(SEQUENCIA, "<$ARGV[1]");

	my $dna = " ";
	my @seq;
	my $longitud = 0;

	while (<SEQUENCIA>){
	    chomp ($_);
	    if ($_ =~ m/>/){
	    }
	    else {
		$dna = $dna.$_;
	    }
	}

	close (SEQUENCIA); #les dades de la seq ja es troben en la variable.



	@seq = split(//,$dna);

	$longitud = scalar(@seq);






	my $pos = 0;

	my $A = 0;

	my $C = 0;

	my $G = 0;

	my $T = 0;


	while ($pos < $longitud) {

	    if ($seq[$pos] eq 'A' || $seq[$pos] eq 'a' ) {

		$A = $A + 1;

	    }

	    if ($seq[$pos] eq 'C' || $seq[$pos] eq 'c') {

		$C = $C + 1;

	    }

	    if ($seq[$pos] eq 'G' || $seq[$pos] eq 'g') {

		$G = $G + 1;

	    }

	    if ($seq[$pos] eq 'T' || $seq[$pos] eq 't') {

		$T = $T + 1;

	    }

	    $pos = $pos + 1;

	}


	my $probA;

	my $probC;

	my $probG;

	my $probT;


	if ($A == 0) {

	    $probA = -999;

	}

	else { $probA = log($A / $longitud) / log(10);

	   }

	if ($C == 0) {

	    $probC = -999;

	}

	else { $probC = log($C / $longitud) / log(10);

	   }

	if ($G == 0) {

	    $probG = -999;

	}

	else { $probG = log($G / $longitud) / log(10);

	   }

	if ($T == 0) {

	    $probT = -999;

	}

	else { $probT = log($T / $longitud) / log(10);

	   }

	

# Fem una nova matriu on ens incorpori els logaritmes de probabilitat en cada posició. A més hi restarem els logaritmes de la seqüència promotora.

	my %logaritme = ("A" => [0,0,0,0,0,0,0,0,0],
			 "C" => [0,0,0,0,0,0,0,0,0],
			 "G" => [0,0,0,0,0,0,0,0,0],
			 "T" => [0,0,0,0,0,0,0,0,0]);

	$posicio = 0;

	while ($posicio < $compta) { 

	    if ($motiu{"A"}[$posicio] == 0) {

		$logaritme{"A"}[$posicio] = -999;

	    }
	    
	    else {

		$logaritme{"A"}[$posicio] = (log(($motiu{"A"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probA;

	    }

	    if ($motiu{"C"}[$posicio] == 0) {

		$logaritme{"C"}[$posicio] = -999;

	    }

	    else {

		$logaritme{"C"}[$posicio] = (log(($motiu{"C"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probC;

	    }

	    if ($motiu{"G"}[$posicio] == 0) {

		$logaritme{"G"}[$posicio] = -999;

	    }
	    
	    else {

		$logaritme{"G"}[$posicio] = (log(($motiu{"G"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probG;

	    }

	    if ($motiu{"T"}[$posicio] == 0) {

		$logaritme{"T"}[$posicio] = -999;

	    }

	    else {

		$logaritme{"T"}[$posicio] = (log(($motiu{"T"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probT;

	    }

	    $posicio = $posicio + 1;

	}


#
#
#


    

	my $diposit = 0; # Guarda l'score dels motiu
	
	my $millor = -9999999999999 ; # Guarda la millor puntuació
	
	my $motiu = $posicio; # És la llargada de cada matriu de pesos (hash)
			
	my $millorposicio = 0; # Guarda la millor posició 
	
	my $stopft; # Simplement servirà per saber fins a on s'uneix el FT
		
	my $p = 0; # Compta la posició de la seqüència únicament dins del motiu

	my $l = 0; # Per a comptar posició dins del motiu

	my $r; # Recorre les posicions de la seqüència
	
	$r = 0;

	while ($r < $longitud-($motiu)+1) {
	    
	 $l = 0;
	 $diposit = 0;
	 $p=$r;

	    while ($l < $motiu) { 
		
		if ($seq[$p] eq 'G' || $seq[$p] eq 'g' ){
		    $diposit = $logaritme{"G"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'A' || $seq[$p] eq 'a' ){
		    $diposit = $logaritme{"A"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'C' || $seq[$p] eq 'c' ){
		    $diposit = $logaritme{"C"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'T' || $seq[$p] eq 't' ){
		    $diposit = $logaritme{"T"}[$l] + $diposit;
		}
		$p = $p + 1;
		$l = $l + 1; 
			
	    }	
	    if ($diposit > $millor) {
		$millor = $diposit;
		$millorposicio = $r;
	
		$stopft=$millorposicio+$motiu-1;
	    }

	    $r = $r +1;
	      
	}

	

	print "Quan aquest FT s'uneix a la seqüència promotora en els nucleòtids $millorposicio - $stopft té la millor puntuació, que és $millor\n";
	

#
#
#


	my $voltes = 0; # Per a comptar les 100 vegades
	
	my $c = 0; # Vegades que el millorrandom és igual o superior a $millor

	my $pvalue;
	


	while ($voltes < 100 ){
   
	    my $i = $longitud - 1;
	    
	    while ($i >= 0) {
		
		my $j = int(rand($i+1));
		
		if ($i != $j) {
		    
		    my $tmp = $seq[$i];
		    
		    $seq[$i] = $seq[$j];
		    $seq[$j] = $tmp;
		}
		$i = $i - 1;
	    }
	    
	   
	my $millorrandom = -999999; # Guardarem la millor puntuació del factor de transcripció en la seqüència random

	$r = 0;


	while ($r < $longitud-($motiu)+1) {
	    
	 $l = 0;
	 $diposit = 0;
	 $p=$r;

	    while ($l < $motiu) { 
		
		if ($seq[$p] eq 'G' || $seq[$p] eq 'g' ){
		    $diposit = $logaritme{"G"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'A' || $seq[$p] eq 'a' ){
		    $diposit = $logaritme{"A"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'C' || $seq[$p] eq 'c' ){
		    $diposit = $logaritme{"C"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'T' || $seq[$p] eq 't' ){
		    $diposit = $logaritme{"T"}[$l] + $diposit;
		}
		$p = $p + 1;
		$l = $l + 1; 
			
	    }	
	    if ($diposit > $millorrandom) {
		$millorrandom = $diposit;
	
	    }
	    
	    $r = $r +1;
	      
     }
  
	
	    
	    if ($millorrandom >= $millor){
		
		$c = $c + 1;
		
	    }
	    
	    $voltes = $voltes + 1;
	}
	
	
	    
	$pvalue = $c/100;
	    
	print "El p-value de $nom és igual o mes petit que $pvalue \n";
	print "\n";





	%motiu = ("A" => [0,0,0,0,0,0,0,0,0],
	  	  "C" => [0,0,0,0,0,0,0,0,0],
	    	  "G" => [0,0,0,0,0,0,0,0,0],
	     	  "T" => [0,0,0,0,0,0,0,0,0]);

	$compta = 0;

	$posicio = 0;
	
    } # Final del tercer "if". Canvi de matriu!


}

close (FITXERMEU);

	while ($posicio < $compta) { 

	    if ($motiu{"A"}[$posicio] == 0) {

		$logaritme{"A"}[$posicio] = -999;

	    }
	    
	    else {

		$logaritme{"A"}[$posicio] = (log(($motiu{"A"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probA;

	    }

	    if ($motiu{"C"}[$posicio] == 0) {

		$logaritme{"C"}[$posicio] = -999;

	    }

	    else {

		$logaritme{"C"}[$posicio] = (log(($motiu{"C"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probC;

	    }

	    if ($motiu{"G"}[$posicio] == 0) {

		$logaritme{"G"}[$posicio] = -999;

	    }
	    
	    else {

		$logaritme{"G"}[$posicio] = (log(($motiu{"G"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probG;

	    }

	    if ($motiu{"T"}[$posicio] == 0) {

		$logaritme{"T"}[$posicio] = -999;

	    }

	    else {

		$logaritme{"T"}[$posicio] = (log(($motiu{"T"}[$posicio]) / ($motiu{"A"}[$posicio] + $motiu{"C"}[$posicio] +  $motiu{"G"}[$posicio] + $motiu{"T"}[$posicio])) / log(10)) - $probT;

	    }

	    $posicio = $posicio + 1;

	}


#
#
#


    

	my $diposit = 0; # Guarda l'score dels motiu
	
	my $millor = -9999999999999 ; # Guarda la millor puntuació
	
	my $motiu = $posicio; # És la llargada de cada matriu de pesos (hash)
			
	my $millorposicio = 0; # Guarda la millor posició 
	
	my $stopft; # Simplement servirà per saber fins a on s'uneix el FT
		
	my $p = 0; # Compta la posició de la seqüència únicament dins del motiu

	my $l = 0; # Per a comptar posició dins del motiu

	my $r; # Recorre les posicions de la seqüència
	
	$r = 0;

	while ($r < $longitud-($motiu)+1) {
	    
	 $l = 0;
	 $diposit = 0;
	 $p=$r;

	    while ($l < $motiu) { 
		
		if ($seq[$p] eq 'G' || $seq[$p] eq 'g' ){
		    $diposit = $logaritme{"G"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'A' || $seq[$p] eq 'a' ){
		    $diposit = $logaritme{"A"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'C' || $seq[$p] eq 'c' ){
		    $diposit = $logaritme{"C"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'T' || $seq[$p] eq 't' ){
		    $diposit = $logaritme{"T"}[$l] + $diposit;
		}
		$p = $p + 1;
		$l = $l + 1; 
			
	    }	
	    if ($diposit > $millor) {
		$millor = $diposit;
		$millorposicio = $r;
	
		$stopft=$millorposicio+$motiu-1;
	    }

	    $r = $r +1;
	      
	}

	

	print "Quan aquest FT s'uneix a la seqüència promotora en els nucleòtids $millorposicio - $stopft té la millor puntuació, que és $millor\n";
	

#
#
#


	my $voltes = 0; # Per a comptar les 100 vegades
	
	my $c = 0; # Vegades que el millorrandom és igual o superior a $millor

	my $pvalue;
	


	while ($voltes < 100 ){
   
	    my $i = $longitud - 1;
	    
	    while ($i >= 0) {
		
		my $j = int(rand($i+1));
		
		if ($i != $j) {
		    
		    my $tmp = $seq[$i];
		    
		    $seq[$i] = $seq[$j];
		    $seq[$j] = $tmp;
		}
		$i = $i - 1;
	    }
	    
	   
	my $millorrandom = -999999; # Guardarem la millor puntuació del factor de transcripció en la seqüència random

	$r = 0;


	while ($r < $longitud-($motiu)+1) {
	    
	 $l = 0;
	 $diposit = 0;
	 $p=$r;

	    while ($l < $motiu) { 
		
		if ($seq[$p] eq 'G' || $seq[$p] eq 'g' ){
		    $diposit = $logaritme{"G"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'A' || $seq[$p] eq 'a' ){
		    $diposit = $logaritme{"A"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'C' || $seq[$p] eq 'c' ){
		    $diposit = $logaritme{"C"}[$l] + $diposit;
		}

		if ($seq[$p] eq 'T' || $seq[$p] eq 't' ){
		    $diposit = $logaritme{"T"}[$l] + $diposit;
		}
		$p = $p + 1;
		$l = $l + 1; 
			
	    }	
	    if ($diposit > $millorrandom) {
		$millorrandom = $diposit;
	
	    }
	    
	    $r = $r +1;
	      
     }
  
	
	    
	    if ($millorrandom >= $millor){
		
		$c = $c + 1;
		
	    }
	    
	    $voltes = $voltes + 1;
	}
	
	
	    
	$pvalue = $c/100;
	    
	print "El p-value de $nom és igual o mes petit que $pvalue \n";
	print "\n";





	%motiu = ("A" => [0,0,0,0,0,0,0,0,0],
	  	  "C" => [0,0,0,0,0,0,0,0,0],
	    	  "G" => [0,0,0,0,0,0,0,0,0],
	     	  "T" => [0,0,0,0,0,0,0,0,0]);

	$compta = 0;

	$posicio = 0;
	
    } # Final del tercer "if". Canvi de matriu!


}

close (FITXERMEU);