c					GUY_CH.FOR (ULTIMA MODIFICA: 28/6/2005)
c	Questa e' una versione piu' articolata del rivoluzionario programma che
c	dovrebbe permettere di risolvere la congettura
c	per "Mousetrap", almeno fino a cio'
c	che mi interessa direttamente, cioe' le carte francesi.
c	Il programma si basa sulla ricostruzione a ritroso delle stringhe
c	che possono portare ai mazzi che diano il massimo punteggio.
c	E' la terza versione, in cui la costruzione a ritroso delle
c	stringhe viene affidata tutta al computer, anziche' 
c	fatta a mano.
c	In Mousetrap ho il vantaggio di sapere quanti mazzi vincenti
c	mi devo aspettare, in quanto lo calcolo con CAYLEY.FOR.
c	In MANMA la chance di avere il punteggio piu' alto e'
c	a volte talmente bassa che non ho idea di quale sia l'ordine
c	di grandezza dei mazzi vincenti.
c	Rispetto alla seconda versione, che e' nel file STRINGHE_MOUSETRAP,
c	questo programma mi serve per rispondere anche ai quesiti di Guy sulle
c	stringhe REFORMED, sia nel caso di Mousetrap classico, sia nel
c	caso di Mousetrap modulare, cioe' giocato "alla Carola", senza
c	bruciare alcuna carta, ma andando avanti ad libitum.
C	Rispetto alla vecchia versione, GUY, inseriamo l'importantissima
c	innovazione di memorizzare i vettori in forma di CARATTERE, in modo
c	da risparmiare, auspicabilmente, molto spazio memoria.
c

      integer*4 na, nq, nu, nsem, nr, nf
      integer*4 nsum(100), nn(400), nc(20,400), ne(2), nw(2), nf4(100), 
     #nl1(100), nn1(100), nn0(400), nn2(400), ngu(4), ns(0:4)
  	CHARACTER str0*17, nch*1
            
	write(*,*) 'RICORDATI DI DIMENSIONARE I CHARACTER!!!'
      write (*,*) ' Fino a quale valore di carta vuoi arrivare (max 100)
     #?'
	read (*,*) nq  
	write(*,*) 'Quanti semi (da 1 a 4)?'
	read (*,*) nsem
	write(*,*) 'si conta ex-novo?'
	read(*,*) mo
	write(*,*) 'cerchiamo UN mazzo (1) o TUTTI i mazzi (2)?'
	read(*,*) mi
	write(*,*) 'vuoi memorizzare TUTTI i mazzi vincenti?'
	read(*,*) nqq
	write(*,*) 'vuoi studiare anche i cicli di Guy?'
	read(*,*) ng
	write(*,*) 'vuoi memorizzare tutti i reformed e i cicli?'
	read(*,*) kre
	if(kre.eq.0)then
	write(*,*) 'quanti mazzi vuoi memorizzare?'
	read(*,*) krn
	end if

c     nz mi da' il numero di carte del mazzo
c     ny mi da' la somma dei valori delle carte.
c	In GU(1) inserisco gli eventuali cicli di mazzi reformed.
c	Da esso creo, automaticamente, i valori degli altri nomi
c	di file per la memorizzazione dei mazzi. In GU(k) vanno i mazzi
c	k-reformed. Poiché gli 1-reformed sono semplicemente i mazzi
c	vincenti, non li memorizzo, perché già lo ho fatto con 
c	STRINGHE_MOUSETRAP.
c	NS(0) memorizza il TOTALE di stringhe reformed. NS(j) memorizza
c	il numero di stringhe j-reformed.
c

      nz = nq*nsem
      ny = (nsem*nq*(nq+1))/2
	kc=0
	do 12 mm=0,4
12	ns(mm)=0

	if(ng.eq.1) then
	write(*,*) 'file su cui memorizzare i cicli?'
	read(*,*) ngu(1)
	WRITE(*,*) 'valore minimo di k per segnalare stringhe k-reformed'
	read(*,*) krec
	write(ngu(1),*) 'MOUSETRAP: CICLI E RIEPILOGO MAZZI REFORMED'
	write(ngu(1),*) nq, ' carte * ', nsem, ' semi'

	do 11 mm=2,3
	ngu(mm)=ngu(mm-1)+1
	open(ngu(mm), access='append', status='unknown')
	write(ngu(mm),*) 'MOUSETRAP: MAZZI ', mm, ' VOLTE REFORMED'
	write(ngu(mm),*) nq, ' carte * ', nsem, ' semi'
11	continue
	ngu(4)=ngu(1)+3
	open(ngu(4), access='append', status='unknown')
	write(ngu(4),*) 'MOUSETRAP: MAZZI ALMENO 4 VOLTE REFORMED'
	write(ngu(4),*) nq, ' carte * ', nsem, ' semi'
	end if

c	kc indica il numero di cicli di stringhe reformed
c	ns(k) memorizza il numero di stringhe k-reformed

	if(mo.eq.0)then
	write(*,*) 'file da cui leggere i numeri di file'
	write(*,*) 'quanti file devo leggere?'
	write(*,*) 'lunghezza stringhe da leggere'
	write(*,*) 'ulteriore prefisso (minore di 21)?'
	read(*,*) nf5, ns2, nl, iu

c	NF5 e' la NF1 del precedente passo.
c	IU e' un prefisso che va messo davanti al numero di file, per
c	riconoscerlo dagli altri file di uguale lunghezza di stringhe

	else

c	qui si conta ex-novo

	iu=0

c	ns2 mi dice il numero di file di stringhe di una data lunghezza che devo leggere.
c	Se sto cominciando ex-novo, ho ovviamente un solo file da leggere.
c	nl mi dice la lunghezza delle stringhe che devo leggere. 
c	Se sto iniziando ex-novo, parto ovviamente da stringhe di lunghezza 1.

	ns2=1
	nl=1

	nfile = nq*10000+nsem*1000+10
	ihb=1

c	con Mousetrap devo ricostruire tutte le stringhe, non solo
c	quelle terminanti con il 2

c	mz e' un contatore del numero di file che sto creando per
c	memorizzare le stringhe.

	mz=1
	do 205 mm=1,nq
	if(mm.eq.1)nch='1'
	if(mm.eq.2)nch='2'
	if(mm.eq.3)nch='3'
	if(mm.eq.4)nch='4'
	if(mm.eq.5)nch='5'
	if(mm.eq.6)nch='6'
	if(mm.eq.7)nch='7'
	if(mm.eq.8)nch='8'
	if(mm.eq.9)nch='9'
	if(mm.eq.10)nch='A'
	if(mm.eq.11)nch='B'
	if(mm.eq.12)nch='C'
	if(mm.eq.13)nch='D'
	if(mm.eq.14)nch='E'
	if(mm.eq.15)nch='F'
	if(mm.eq.16)nch='G'
	if(mm.eq.17)nch='H'
	if(mm.eq.18)nch='I'
	if(mm.eq.19)nch='J'
	if(mm.eq.20)nch='K'
	str0(1:1)=nch
	write(NFILE,*) str0
205	continue
	ns(0)=nq
	close(nfile)
	end if

	write(*,*) 'file su cui memorizzare i dati sulle stringhe 
     #vincenti?'
	read(*,*) nf1
	write(*,*) 'su quale file il numero di stringhe vincenti?'
	read(*,*) nf2

	open(nf1)
	if(mo.eq.0) open(nf5)
	open(nf2, access='append', status='unknown')
	write(nf2,*) 'MOUSETRAP: MAZZI OTTENUTI CON GUY_CH'
	write(nf2, *) nq, ' carte * ', nsem, ' semi'

	do 200 nu=nl+1, nz
	nsumm=0
	mz=0
	do 601 ib=1, ns2
	if(mo.eq.0) read(nf5,*) ihb, nfile, ns(0)

c	ihb conta il numero di file memorizzato nel passo precedente.
c	NFILE e' il file da cui leggo le varie stringhe.
c	NF5 e' il file da cui leggo il numero di stringhe che dovro' leggere su
c	NFILE. A ogni passo del loop leggo una riga di NF5, che mi dice
c	qual e' il file NFILE da cui leggere le stringhe e il numero di stringhe.
c	ns(0) indica il numero di stringhe da leggere in nfile.
c	nu e' la lunghezza delle stringhe da costruire e verificare
c	il primo file su cui memorizzare e' dato da un numero
c	le cui cifre danno il numero di carte, il numero di semi
c	e il numero di elementi della stringa.

	nf= nq*10000+nsem*1000+nu*10+ib*1000000+iu*100000000
	nr=ns(0)
	ns(0)=0

c	su FOR.NF memorizzo le stringhe da leggere al passo successivo.
c	Una volta riazzerato,
c	ns mi dira' il numero di stringhe nuove che ho memorizzato 
c	nel file for.nf.

	open(nfile)
	write(*,*) 'sto leggendo il file n. ', ihb, ' : ' , nfile

c	leggo, una per volta, le NR stringhe immagazzinate

	do 70 i=1,nr

c	il programma legge i numeri sulla stringa posta nella 
c	i-esima posizione del file for.nfile, chiamandola
c	nn.

	read (nfile,*) str0

	do 260 ii=1,nu-1
	nch=str0(ii:ii)
	if(nch.eq.'1')nn(ii+1)=1
	if(nch.eq.'2')nn(ii+1)=2
	if(nch.eq.'3')nn(ii+1)=3
	if(nch.eq.'4')nn(ii+1)=4
	if(nch.eq.'5')nn(ii+1)=5
	if(nch.eq.'6')nn(ii+1)=6
	if(nch.eq.'7')nn(ii+1)=7
	if(nch.eq.'8')nn(ii+1)=8
	if(nch.eq.'9')nn(ii+1)=9
	if(nch.eq.'A')nn(ii+1)=10
	if(nch.eq.'B')nn(ii+1)=11
	if(nch.eq.'C')nn(ii+1)=12
	if(nch.eq.'D')nn(ii+1)=13
	if(nch.eq.'E')nn(ii+1)=14
	if(nch.eq.'F')nn(ii+1)=15
	if(nch.eq.'G')nn(ii+1)=16
	if(nch.eq.'H')nn(ii+1)=17
	if(nch.eq.'I')nn(ii+1)=18
	if(nch.eq.'J')nn(ii+1)=19
	if(nch.eq.'K')nn(ii+1)=20
260	continue

c	write(*,*) (nn(ii), ii=2,nu)

c	una volta letta la stringa nn, aggiungo l'nu-esimo
c	numero. nsum mi segnala se le carte di valore j sono
c	gia' state messe tutte, nel qual caso incremento j
c	e metto una carta di valore piu' alto. Per sistemare
c	il mazzo, creo una stringa di nu valori e inserisco
c	le carte nell'ordine dato dalla stringa lunga nu-1.
c	Quando arrivo a nu, riazzero il conteggio. Quando
c	trovo una casella occupata, mi sposto di uno a destra.

	do 10 js=1,nq
10	nsum(js)=0

c	il prossimo loop verifica quante volte e' ripetuta una
c	carta nella stringa che sto leggendo

	do 20 js=2, nu
	na=nn(js)
20	nsum(na) = nsum(na) + 1

c	costruisco la stringa di un elemento piu' lunga, rispetto a quella
c	 che ho letto, provando, a uno a uno, gli NQ valori ammissibili

	do 30 j=1, nq

	do 50 js=1, nu
50	nc(1,js)=0

	if(nsum(j).eq.nsem) goto 30

	nn(1)=j

c	nn(1) e' l'elemento nuovo da inserire nella precedente stringa

	k=0
	ns1=0

c	ns4 e' il contatore per far spostare la carta al posto giusto
c	NS1 e' la somma dei valori delle carte della stringa in esame.

	ns4=0

	do 40 l=1, nu
	nh=nn(l)
	if(ns4.gt.0)then
	k=k+1
		if(k.gt.nu)k=k-nu
146		if(nc(1,K).gt.0)then
		k=k+1
		if(k.gt.nu)k=k-nu
		goto 146
		end if
	else
		do 155 i0=1,nh
		k=k+1
		if(k.gt.nu)k=k-nu
145		if(nc(1,k).gt.0)then
		k=k+1
		if(k.gt.nu)k=k-nu
		goto 145
		end if
155		end do
	end if
	nc(1,k)=nn(l)
	ns1=ns1+nc(1,k)
40	continue

	do 240 mh=1,nu
240	nn0(mh)=nc(1,mh)

c	write(*,*) 'somma dei punti= ', ns1
c	write(*,*)(nn(hi), hi=1, nu)
c	write(*,*)(nc(1,hi), hi=1, nu)
c	write(4,*)(nn(hi), hi=1, nu)
c	write(4,*)(nc(1,hi), hi=1, nu)
c	write(4,*) ' '

c	una volta ricostruito il mazzo, faccio partire il giuoco. 
c	QUESTO E', PER IL MOMENTO, MOUSETRAP NON MODULARE (CIOE' NON
C	"ALLA CAROLA")
c	Per adeguare il programma a Mousetrap, ho rispolverato il metodo
c	meno efficiente.
c     Il vettore nc memorizza il mazzo iniziale. Costruisco 
c     anche il mazzo nn0, che sara' quello manipolabile durante
c     il gioco. Ho bisogno di tenere in memoria nc, perche' alla
c     fine, se ho fatto record, devo stampare anche il mazzo con
c     cui ho fatto record.

	nt = nu

c     nt e' il numero di carte che non ho ancora ne' bruciato 
c     ne' accantonato; n1 e' la somma dei punti delle carte
c     accantonate; n2 e' il numero di carte che accantono 
c     (e' importante al fine di individuare, a parita' di 
c     punteggio finale, con quante carte si sia ottenuto quel 
c     punteggio); k e'il contatore.
c     Il programma, infatti, anziche' girare le carte, muove un
c     cursore su un vettore a nt componenti.
c     Il risultato, ai fini del gioco, e' lo stesso. Potrebbe
c     accadere che il numero di carte sia minore di NQ.
c     NT rende conto proprio di questo fatto. Puo' anche accadere
c     che, contando con k, si raggiunga l'ultima componente
c     di nn0. In tal caso, il gioco prevede che il cursore 
c     riparta dalla prima carta, con un meccanismo circolare,
c     a mo' di classi modulo nt.

      n1 = 0
      n2 = 0
      k = 0

60        do 140 ja = 1, nq
          k = k + 1
              if (k.gt.nt) k = k - nt

c     qui metto in conto il fatto che il valore della carta 
c     coincida con il valore da me "pronunciato".

				if(ja.eq.nn0(k))then
                  n2 = n2 + 1 
				nn2(n2)=ja

c	l'istruzione sotto e' di controllo: e' legata al fatto che
c	il mazzo ricostruito a partire da una stringa non e' detto
c	che ridia quella stringa. Ad esempio, la stringa 1221 fornisce
c	il mazzo 1221, il quale, pero', a sua volta, fornisce la stringa
c	1212, differente da quella di partenza. L'istruzione butta via quei
c	mazzi che non forniscano coincidenze fra le componenti della stringa
c	di partenza e quella di arrivo.
c	In GUY.FOR serve solo per il primo giro, perche' poi, nel cercare
c	mazzi REFORMED, gioco ancora con la stringa generata, che diventa
c	automaticamente mazzo per il gioco del passo successivo.

				if(nn2(n2).ne.nn(n2))goto 30
                  n1 = n1 + ja

c     adesso, avendo accantonato la carta buona, riscalo le 
c     carte superstiti.   

                  nt = nt - 1
                      if(nt.eq.0) goto 170
                          do 130 id = k, nt
130                        nn0(id) = nn0(id+1)
                      k = k - 1
                      goto 60
			     end if                                                       
140         end do  
                            
c     se esco dal loop, vuol dire che, per NQ carte, 
c     non c'e' stata corrispondenza con i valori da me
c     "pronunciati". Quindi devo terminare il giuoco,
c	abbandonando il mazzo, perché il mazzo non mi darà il
c	massimo risultato.
c	write(*,*) 'mazzo non buono'

      goto 30
      
c     al passo 170 si arriva se sono state accantonate TUTTE le carte (nt=0).

c     terza fase: eventuale memorizzazione del risultato 
c	(se il punteggio ha raggiunto la somma dei valori delle carte
c	nella stringa in esame, memorizzo) e, nel caso in cui NU=NZ, prosieguo
c	del gioco secondo le regole del mazzo REFORMED. Prendo la stringa NN2,
c	costruita dal mazzo vincente NC e la utilizzo come nuovo mazzo,
c	verificando se esso, a sua volta, vince, generando una nuova stringa.
c	E cosi' via.

170	if(n1.eq.ns1)then
	ns(0)=ns(0)+1

	do 270 ii=1,nu
	if(nn(ii).eq.1)nch='1'
	if(nn(ii).eq.2)nch='2'
	if(nn(ii).eq.3)nch='3'
	if(nn(ii).eq.4)nch='4'
	if(nn(ii).eq.5)nch='5'
	if(nn(ii).eq.6)nch='6'
	if(nn(ii).eq.7)nch='7'
	if(nn(ii).eq.8)nch='8'
	if(nn(ii).eq.9)nch='9'
	if(nn(ii).eq.10)nch='A'
	if(nn(ii).eq.11)nch='B'
	if(nn(ii).eq.12)nch='C'
	if(nn(ii).eq.13)nch='D'
	if(nn(ii).eq.14)nch='E'
	if(nn(ii).eq.15)nch='F'
	if(nn(ii).eq.16)nch='G'
	if(nn(ii).eq.17)nch='H'
	if(nn(ii).eq.18)nch='I'
	if(nn(ii).eq.19)nch='J'
	if(nn(ii).eq.20)nch='K'
	str0(ii:ii)=nch
270	continue
c	write(*,*) 'stringa da memorizzare = ', str0
	write(NF,*) str0

C		write(*,*) (nn(ii), ii=1,nu)
C		write(*,*) (nc(1,ii), ii=1,nu)
C		write(*,*) (nn2(ii), ii=1,nu)

		if(ns1.eq.ny)then
		if(nqq.eq.1)then
c		write(*,*) ' somma dei punti = ' , ny
		write (nf2,*) (nc(1,ii), ii = 1, nu)
		write (nf2,*) 'punteggio =', n1
		write (nf2,*) 'ottenuto con  ', n2, '   carte'
c		write (nf1,*) (nc(1,ii), ii = 1, nu)
c		write (nf1,*) 'punteggio =', n1
c		write (nf1,*) 'ottenuto con  ', n2, '   carte'
		else
			if(ns(0).eq.1)then

c	memorizzo un solo mazzo per file, giusto come controllo.
c	potrei memorizzarne quanti ne voglio, tramite l'istruzione
c	if(ns(0).ge.1.and.ns(0).le.XXX)then...

			write(*,*) ' somma dei punti = ' , ny
			write (nf2,*) (nc(1,ii), ii = 1, nu)
			write (nf2,*) 'punteggio =', n1
			write (nf2,*) 'ottenuto con  ', n2, '   carte'
c			write (nf1,*) (nc(1,ii), ii = 1, nu)
c			write (nf1,*) 'punteggio =', n1
c			write (nf1,*) 'ottenuto con  ', n2, '   carte'
			end if
		end if

c	Il primo IF rimane aperto, perché, se NS1 è uguale a NY,
c	voglio continuare a giocare.	
c	qui inserisco la ricerca delle permutazioni REFORMED.
c	Prendo la stringa NN2, costruita con il mazzo NC e ci rigioco.

	if(ng.eq.1)then
	kj=1
341	do 340 mh=1,nz
	NC(KJ+1, MH)=NN2(MH)
340	nn0(mh)=nn2(mh)
	
c	RICOMINCIO IL GIUOCO.
C	Nel primo passo, sto trattando una stringa ottenuta per la prima
c	volta, cioè la stringa ottenuta dal primo mazzo, a sua volta
c	ottenuta dalla stringa da me costruita.
c	Quindi la prima stringa coincide con la stringa da me costruita.
c	Al primo passo, dunque, siamo ancora in una 1-reformed stringa.

500		nt = nu

c     nt e' il numero di carte che non ho ancora ne' bruciato 
c     ne' accantonato; n1 e' la somma dei punti delle carte
c     accantonate; n2 e' il numero di carte che accantono 
c     (e' importante al fine di individuare, a parita' di 
c     punteggio finale, con quante carte si sia ottenuto quel 
c     punteggio); k e'il contatore.
c     Il programma, infatti, anziche' girare le carte, muove un
c     cursore su un vettore a nt componenti.
c     Il risultato, ai fini del gioco, e' lo stesso. Potrebbe
c     accadere che il numero di carte sia minore di NQ.
c     NT rende conto proprio di questo fatto. Puo' anche accadere
c     che, contando con k, si raggiunga l'ultima componente
c     di nn0. In tal caso, il gioco prevede che il cursore 
c     riparta dalla prima carta, con un meccanismo circolare,
c     a mo' di classi modulo nt.

      n1 = 0
      n2 = 0
      k = 0

560        do 540 ja = 1, nq
          k = k + 1
              if (k.gt.nt) k = k - nt

c     qui metto in conto il fatto che il valore della carta 
c     coincida con il valore da me "pronunciato".

				if(ja.eq.nn0(k))then
                  n2 = n2 + 1 
               n1 = n1 + ja
				nn2(n2)=ja

c     adesso, avendo accantonato la carta buona, riscalo le 
c     carte superstiti.   

                  nt = nt - 1
                      if(nt.eq.0) goto 570
                          do 530 id = k, nt
530                        nn0(id) = nn0(id+1)
                      k = k - 1
                      goto 560
			     end if                                                       
540         end do  
                            
c     se esco dal loop, vuol dire che, per NQ carte, 
c     non c'e' stata corrispondenza con i valori da me
c     "pronunciati". Quindi devo terminare il giuoco,
c	abbandonando il mazzo, perché il mazzo non mi darà il
c	massimo risultato.
c	SE SONO USCITO IN CORRISPONDENZA DI kj=1, NON DEVO MEMORIZZARE
C	ALCUNCHÉ, avendolo già fatto poco prima. In tal caso, salto
c	direttamente alla fine del loop, pronto a considerare la stringa
c	successiva.
c	Per valori successivi di kj, aggiorno il numero di kj-reformed
c	stringhe e memorizzo nel file corrispettivo tutta la sequenza
c	di mazzi riformati fino al kj-esimo.

	ns(kj)=ns(kj)+1
	if(kj.le.1)goto 30
	if(kre.eq.0)then
		if(ns(kj).le.krn)then
			if(kj.le.3)then
				write(ngu(kj),*) ns(kj)
				do 542 mh=1,kj
				write(ngu(kj),*) (nc(mh, ii), ii=1, nz)
542				write(ngu(kj),*) ' '
				write(ngu(kj),*) (nc(kj+1, ii), ii=1, nz)
				write(ngu(kj),*) ' '
			else
				write(ngu(4),*) 'STRINGA ', kj, ' -REFORMED N. ', ns(kj)
				do 552 mh=1,kj
				write(ngu(4),*) (nc(mh, ii), ii=1, nz)
552				write(ngu(4),*) ' '
				write(ngu(4),*) (nc(kj+1, ii), ii=1, nz)
				write(ngu(4),*) ' '
			endif
		endif
	else
		if(kj.le.3)then
			write(ngu(kj),*) ns(kj)
			do 1542 mh=1,kj
			write(ngu(kj),*) (nc(mh, ii), ii=1, nz)
1542		write(ngu(kj),*) ' '
			write(ngu(kj),*) (nc(kj+1, ii), ii=1, nz)
			write(ngu(kj),*) ' '
		else
			write(ngu(4),*) 'STRINGA ', kj, ' -REFORMED N. ', ns(kj)
			do 1552 mh=1,kj
			write(ngu(4),*) (nc(mh, ii), ii=1, nz)
1552		write(ngu(4),*) ' '
			write(ngu(4),*) (nc(kj+1, ii), ii=1, nz)
			write(ngu(4),*) ' '
		endif
	end if
			if(kj.ge.krec)then
			write(*,*)'HO UNA STRINGA ', kj,' -REFORMED' 
			krec=kj
			end if
	goto 30

c     al passo 570 si arriva se sono state accantonate TUTTE le carte (nt=0).
c	Innanzitutto, controllo se la stringa appena ottenuta mi ha creato
c	un loop, anche nel caso kj=1. Se non ho a che fare con un ciclo,
c	allora posso ricominciare il gioco. Aumento kj.

570	do 343 iii=1,kj+1
		do 342 ii=1,nz
342		if(nc(iii,ii).ne.nn2(ii))goto 343
	goto 344
343	continue

c	se esco, vuol dire che NON HO il ciclo chiuso e quindi proseguo
c	il giuoco. Prendo la stringa NN2,
c	costruita dal mazzo vincente NC e la utilizzo come nuovo mazzo,
c	verificando se esso, a sua volta, vince, generando una nuova stringa.
c	E cosi' via.

	KJ=KJ+1
541	do 550 mh=1,nz
	nc(kj+1,mh)=nn2(mh)
550	nn0(mh)=nn2(mh)
	goto 500

c	se arrivo qui, vuol dire che HO il ciclo chiuso e quindi fermo
c	il giuoco. Memorizzo tutto il ciclo in NGU(1)

344	kc=kc+1
	if(kre.eq.0)then
		if(kc.le.krn)then
			write(*,*) 'HO UN ', kj-iii+2, ' CICLO CHIUSO!!!'
			if((kj-iii+1).eq.1)write(*,*) 'VALE A DIRE UNA IDENTITA!!!' 
			write(ngu(1),*)kc
			write(ngu(1),*) 'HO UN ', kj-iii+2, ' CICLO CHIUSO!!!'
			do 345 ii=1,kj+1
			write(ngu(1),*) (nc(ii,mh), mh=1,nz)
			write(ngu(1),*) ' '
345			continue
		endif
	else
		write(*,*) 'HO UN ', kj-iii+2, ' CICLO CHIUSO!!!'
		if((kj-iii+1).eq.1)write(*,*) 'VALE A DIRE UNA IDENTITA!!!' 
		write(ngu(1),*)kc
		write(ngu(1),*) 'HO UN ', kj-iii+2, ' CICLO CHIUSO!!!'
		do 1345 ii=1,kj+1
		write(ngu(1),*) (nc(ii,mh), mh=1,nz)
		write(ngu(1),*) ' '
1345	continue
	endif
	goto 30

c	chiudo l'IF che chiede se continuare il giuoco alla GUY

	end if

c	chiudo l'IF che si apre se sono arrivato a NZ

c		else
c		write(*,*) (nn0(ii), ii=1,nu)
c		write(*,*) (nc(1,ii), ii=1,nu)
c		write(*,*) (nn2(ii), ii=1,nu)

	end if
	
c	chiudo l'IF che si apre se ho messo da parte tutte le carte

	end if

	if(mi.eq.1.and.ns(0).eq.10000)goto 300
	if(ns(0).eq.10000000)then
	ns2=ns2+1
	mz=mz+1
	nsumm=nsumm+ns(0)
	write(*,310) mz, nf, ns(0), nu
	write(nf2,310) mz, nf, ns(0), nu
310	format('file n. ', i4, ' : ' , i10, ' : memorizzate ', i10, 
     #' stringhe di ', i4, ' elementi')
	write(nf1,*) mz, nf, ns(0)
	close(nf)
	nf=nf+1
	write(*,*) 'numero di file = ' , nf
	ns(0)=ns(0)-10000000
	end if

C	CHIUDO IL DO LOOP SULLA STRINGA COSTRUITA DALLA STRINGA LETTA

30	continue

C	CHIUDO IL DO LOOP SULLA STRINGA LETTA

70	continue
	mz=mz+1
300	write(*,210) mz, nf, ns(0), nu
	write(nf2,210) mz, nf, ns(0), nu
210	format('file n. ', i4, ' : ' , i10, ' : memorizzate ', i10, 
     #' stringhe di ', i4, ' elementi')
	nsumm=nsumm+ns(0)
	close(nf)
	write(nf1,*) mz, nf, ns(0)
601	continue
	write(nf1,*) 'totale stringhe di ', nu, ' elementi = ' , nsumm
	close(nf1)
	write(*,*) 'totale stringhe di ', nu, ' elementi = ' , nsumm
	
c	questa istruzione e' messa come controllo, per evitare che i file
c	in cui immagazzinare i dati esplodano

	nuu=nu
	if(ns2.gt.1)goto 220
	nf5=nf1
	nfile=nf
200	continue
220	if(ns2.gt.1) write(nf2,*) 'totale stringhe di ', nu, ' elementi 
     #= ' , nsumm
	if(nuu.eq.nz)then
	write(ngu(1),*) ' HO ', kc, ' CICLI CHIUSI' 
	do 355 ii=1,krec
355	write(ngu(1),*)'HO ', ns(ii), ' STRINGHE ', ii, ' -REFORMED' 
	write(ngu(1),*) ' '
	write(ngu(1),*)'HO UN TOTALE DI ', nsumm, ' STRINGHE REFORMED' 
	endif
	stop
      end                      