#rR gscope_clotools.tcl 

proc CreateCommandeSigmaFromIgbmc {{LesFichiersCommande {}} {GetWhat ""}} {
    if {$GetWhat==""} { set GetWhat "GetList" }
    if {$LesFichiersCommande=={}} {
	set LesFichiersCommande [MorceauxChoisis [lsort [glob -nocomplain "*_commande*.txt"]]]
    }
    
    set SigmaScaleMicroMol [Entre "Scale in Micro Mol to order at Sigma: 0.05"]
    regsub -all {[^0-9\.]} $SigmaScaleMicroMol "" SigmaScaleMicroMol
    set SigmaPurification [Entre "Purification for Sigma: RPI"]
    regsub {[^\:]*\:} $SigmaPurification "" SigmaPurification
    set SigmaPurification [string trim $SigmaPurification]
    set SigmaComment ""

    set ListeSigma {}
    foreach FichierCommande $LesFichiersCommande {
	set OnAttend 1
	foreach Ligne [LesLignesDuFichier $FichierCommande] {
	    if {[regexp "FIN DE COMMANDE" $Ligne]} { break }
	    if {$OnAttend} {
		if { [regexp -- {\-\-\-\-\-} $Ligne]} { set OnAttend 0 }
		continue
	    }  
	    if { [regexp -- {\-\-\-\-\-} $Ligne]} { continue }
	    if { [string trim $Ligne]==""} { continue }
	    if {[regexp { *[0-9]+ +P[0-9]+ *} $Ligne]} {
		scan $Ligne "%d %s %s" n P SS
		set Seq($P) ""
		set SigSuj($P) $SS
		lappend LesP $P
		continue
	    }
	    regsub {[53]'} $Ligne "" S
	    regsub -all " " $S "" S
	    append Seq($P) $S
	}
    }
    foreach P $LesP {
	lappend ListeSigma "$P $SigSuj($P)\t$Seq($P)\t$SigmaScaleMicroMol\t$SigmaPurification\t$SigmaComment"
    }
    if {$GetWhat=="GetList"} { return $ListeSigma }
    if {$GetWhat=="GetText"} { return [join $ListeSigma "\n"] }
    return [SauveLesLignes $ListeSigma dans $GetWhat]  
	
}

proc ChoisisWindowSizePourSlidingCodonRare {{WindowSize ""}} {
    while { ! [regexp {^\-?[0-9]+} $WindowSize]} {
	set WindowSize [ChoixParmi [list 1 10 20 30 40 50 "WholeSequence" "Other"]]
	if {$WindowSize=="Other"} { set WindowSize [Entre 12] }
	if {$WindowSize=="WholeSequence"} { set WindowSize -1 }
    }
    return $WindowSize
}

proc AfficheSlidingCodonRarePour {{Liste ""}} {
    if {$Liste==""} {
	set Liste [MorceauxChoisis [PresentationDesPABs]]
    }
    if {$Liste=={}} { return "" }

    set WindowSize [ChoisisWindowSizePourSlidingCodonRare]

    foreach Ligne $Liste {
	scan $Ligne "%s" Nom
	set FichierTFA "[RepertoireDuGenome]/nuctfa/$Nom"
	if { ! [file exists $FichierTFA]} { continue }
	set SCR [SlidingCodonRare $FichierTFA $WindowSize]
	lappend LesSCRs $Ligne
	lappend LesSCRs [join $SCR "\n"]
	lappend LesSCRs ""
    }
    
    return [AfficheVariable [join $LesSCRs "\n"] "AvecRienGrandeLargeur" "SlidingCodonRare"] 
}

proc AfficheSlidingCodonRare {Page {WindowSize ""}} {
    set SCR [SlidingCodonRare $Page]
    return [AfficheVariable [join $SCR "\n"] "AvecRienGrandeLargeur" "SlidingCodonRare"] 
}

proc SlidingCodonRare {FichierOuTexteTFAOuSeq {WindowSize ""}}  {


    set LesRares [CodonsRares "LaListeMerci"]

    if {[regexp "^>" $FichierOuTexteTFAOuSeq]} {
	set Seq [QueLaSequenceDuTexteTFA $FichierOuTexteTFAOuSeq]
    } else {
	if { ! [regexp {[^ATGCN \n\t]} $FichierOuTexteTFAOuSeq]} {
	    regsub -all {[^ATGCN]} $FichierOuTexteTFAOuSeq "" Seq
	} else {
	    if {[file exists $FichierOuTexteTFAOuSeq]} {
		set Seq [QueLaSequenceDuFichierTFA $FichierOuTexteTFAOuSeq]
	    } else {
		FaireLire "Following line(s) is not a filename, TFA text or a nucleic sequence\n\
			$FichierOuTexteTFAOuSeq"
		return ""
	    }
	}
    }

    set Seq [string toupper $Seq]

    set WindowSize [ChoisisWindowSizePourSlidingCodonRare $WindowSize]

    if {$WindowSize<0} { set WindowSize [expr [string length $Seq]/3] }

    set Decale [string range "[string repeat "NNN" $WindowSize]$Seq" 0 [string length $Seq]]     
    set LesBases [split $Seq ""]
    set LesDecales [split $Decale ""]
    set i 0
    foreach {A B C} $LesBases {D E F} $LesDecales {
	set Codon "$A$B$C"
	set Decal "$D$E$F"
	lappend LesCodons $Codon
	if { ! [info exists Pic($Codon)]}   { set Pic($Codon)   0 }
	if { ! [info exists Cumul($Codon)]} { set Cumul($Codon) 0 }
	if { ! [info exists Cumul($Decal)]} { set Cumul($Decal) 0 }
	incr Cumul($Codon)
	incr Cumul($Decal) -1
	if {[set Cumul($Codon)] == [set Pic($Codon)]} { lappend PosDuPic($Codon) [expr $i/3+1] }
	if {[set Cumul($Codon)]  > [set Pic($Codon)]} {
	    set Pic($Codon) [set Cumul($Codon)]
	    set SeqDuPic($Codon) [string range $Seq [expr $i+3-$WindowSize*3] [expr $i+2]]
	    set PosDuPic($Codon) [list [expr $i/3+1]]
	}
	incr i 3
    }
    set LesCodons [lsort -unique $LesCodons]
    set Sortie {}
    foreach Rare $LesRares {
	if { ! [info exists Pic($Rare)]} { continue }
	set SdP [set SeqDuPic($Rare)]
	set BelleSdP ""
	foreach {A B C} [split $SdP ""] {
	    set Codon "$A$B$C"
	    if {$Codon!=$Rare} { set Codon [string tolower $Codon] }
	    append BelleSdP "$Codon "
	}
	lappend Sortie "$Rare [set Pic($Rare)] $BelleSdP [join [set PosDuPic($Rare)] " "]"
    }
    Espionne $Sortie
    return $Sortie
}

proc BaClonExists args {
    global BaClon

    if {$args=={}} { return [info exists BaClon(EstCharge)]}

    set Quoi [join $args ","]
    return [info exists BaClon($Quoi)]
}

proc BaClonAppend args {
    global BaClon
    set Quoi [join [lrange $args 0 end-1] ","]
    set Valeur [lindex $args end]

    if {[info exists BaClon($Quoi)] && [lsearch -exact [set BaClon($Quoi)] $Valeur]>-1} {
	return [set BaClon($Quoi)]
    }

    return [lappend BaClon($Quoi) $Valeur]
}

proc BaClonSet args {
    global BaClon
    set Quoi [join [lrange $args 0 end-1] ","]
    set Valeur [lindex $args end]

    return [set BaClon($Quoi) $Valeur]
}

proc BaClonUnset args {
    global BaClon
    set Quoi [join $args ","]
    catch {unset BaClon($Quoi)}
}

proc BaClon args {
    global BaClon

    if {$args=={}} {
	return [list \
		"BaClon LesSujets PGS" \
		"BaClon LesOligos PGS" \
		"BaClon LesOligosDuCouple PGS Sujet" \
		"BaClon Trio PGS Sujet P"]
    }


    if {$args=="Save"} { 
	set FichierBaClon "[RepertoireDuGenome]/fiches/baclon"
	SauveLesLignes [array get BaClon] dans $FichierBaClon
	return $FichierBaClon
    }
    set Quoi [join $args ","]

    if {[info exists BaClon($Quoi)]} { return [set BaClon($Quoi)] }
    if {[info exists BaClon(EstCharge)]} { return "" }

    set FichierBaClon "[RepertoireDuGenome]/fiches/baclon"
    if {[file exists $FichierBaClon]} {
	array set BaClon [LesLignesDuFichier $FichierBaClon]
    }
    set BaClon(EstCharge) 1
    if {[info exists BaClon($Quoi)]} { return [set BaClon($Quoi)] }
    return ""
}

proc TMDeLaSequence {Seq} {
    regsub -all " " $Seq "" Seq
    set Seq [string toupper $Seq]
    set Texte [ContenuDuFichier "[LbgiUrl]/MeltingTemperatureBioPhp.php?primer=$Seq&NearestNeighbor=1&cp=500&cs=50&cmg=1"]
    set Temp [FloatApres "<tmvalue>" dans $Texte]
    if {$Temp>55} { Espionne "$Temp $Seq" } 
    return $Temp

#suite obsolete
    set nAT   [regexp -all -nocase {[AT]}   $Seq]
    set nGC   [regexp -all -nocase {[GC]}   $Seq]
    set nATGC [expr $nAT+$nGC]
    if {$nATGC < 14 } {
	set Temp [expr $nAT*2 + $nGC*4]
    } else {
	set Temp [expr 64.9 + 41*($nGC - 16.4)/$nATGC]
    }
    return $Temp
#suite obsolete
    if {0} {            
	set TM(A) 2
	set TM(T) 2
	set TM(G) 4
	set TM(C) 4
	
	set Seq [string toupper $Seq]
	
	set Cumul 0
	foreach Base [split $Seq ""] {
	    if {[info exists TM($Base)]} { incr Cumul [set TM($Base)] }
	}
	return $Cumul
    }
}

proc EntammePourMeltingTemp {Seq TmVoulu {TmSiFinGC ""}} {
    # TmVoulu peut contenir les deux
    if {[regexp {([0-9\.]+) +([0-9\.]+)} $TmVoulu Match TmATGC TmGC]} {
	set TmVoulu   $TmATGC
	set TmSiFinGC $TmGC
    }

    if {$TmSiFinGC==""} { set TmSiFinGC $TmVoulu }

    set Seq [string toupper $Seq]

    set Entamme ""
    foreach Base [split $Seq ""] {
	append Entamme $Base
	if { ! [regexp {[ATGC]} $Base]} { continue }
	set TM [TMDeLaSequence $Entamme]
	if {$TM >= $TmVoulu} { break }
	if {$TM >= $TmSiFinGC && ($Base=="G" || $Base=="C")} { break }
    }
    return $Entamme
}

proc CreeLesOligosManquants {} {
    FaireLire "ne pas relancer"; exit
    cd "[RepertoireDuGenome]/oligos"
    set iP 2798
    foreach P [list P2644.tfa P2645.tfa P2652.tfa P2654.tfa P2655.tfa P2657.tfa P2658.tfa P2660.tfa] {
	regsub ".tfa" $P "" BP
	set TFA [ContenuDuFichier $P]
	set Entete [EnteteDuTexteTFA $TFA]
	set Seq    [QueLaSequenceDuTexteTFA $TFA]
	set SB    [StringApres " signal "   dans $Entete]
	set ST    [StringApres " replaces " dans $Entete]
	set Sujet [StringApres " for "      dans $Entete]
	regsub "_$SB" $ST "" SA
Espionne "$ST $SA"
	set SSA [Signal $SA "SEQ"]
	set FullSeq "$SSA$Seq"

	set FullP "P$iP"
	incr iP

	regsub "AfterMeButItDoesNotExist" $Entete $FullP NewEntete
	set NewTFA [SequenceFormatTFA $Seq $NewEntete "nucbrut"]

	set FullE "$FullP 5' oligo with signal $ST for $Sujet RebuildedBrockenOli of $SA seeBrocken $BP"
	set FullTFA [SequenceFormatTFA $FullSeq $FullE "nucbrut"]
	Sauve $NewTFA dans $P
	Sauve $FullTFA dans "$FullP.tfa"
    }
}

proc OperonClonage {Nom {Qui ""} {Quoi ""}} {

    if { ! [EstUnPAB $Nom]} { set Nom [NomDuAlias $Nom] }
    if { ! [EstUnPAB $Nom]} { return "" }

    set Operon [ExtraitInfo $Nom "Operon:"]
    if {$Operon==""} { return ""} 

    if {$Qui ==""} { set Qui  "GetOperon" }
    if {$Quoi==""} { set Quoi "GetSequence" }
    if {$Qui =="GetOperon"} { return [split $Operon " "]}

    foreach {G D F} [split $Operon " "] {
	if {$Qui==$G} {
	    if {$Quoi=="GetStartEnd"} { return "$D $F" }
	    if {$Quoi=="GetStart"} { return $D }
	    if {$Quoi=="GetEnd"} { return $F }
	    if {$Quoi=="GetSequence"} {
		set Seq [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]]
		return [string range "n$Seq" $D $F]
	    }
	}
    }
    return ""
}

proc OperonNancyInforme {} {
    FaireLire "Ne plus relancer. Merci"; exit; 
    foreach Nom [ListeDesPABs] {
	set FicNucTfa [GscopeFile $Nom "nuctfa"]
	if {[FileAbsent $FicNucTfa]} { continue }
	set Entete [EnteteDuFichierTFA $FicNucTfa]
	if { ! [regexp "operon coding for" $Entete]} { continue }

	set SeqNucOp "n[QueLaSequenceDuFichierTFA $FicNucTfa]"
	set Reste [StringSuivant "operon coding for" dans $Entete]
	set LesGDF {}
	set LesSeqPro {}
	while {[regexp {operonprot ([^ ]+) +base +([0-9]+) +to +([0-9]+)} $Reste Match Gene Deb Fin]} {
	        regsub {operonprot ([^ ]+) +base +([0-9]+) +to +([0-9]+)} $Reste "" Reste
	    lappend LesGDF $Gene $Deb $Fin
	    set SeqNuc [string range $SeqNucOp $Deb $Fin]
	    set SeqDep [QueLaSequenceDuFichierTFA "[OperonNancy Directory]/$Gene.tfa"]
	    if { ! [string equal $SeqNuc $SeqDep]} {
		Espionne "$SeqNucOp\n$SeqNuc\n$SeqDep"
		FaireLire "$Nom $Gene something is wrong\
                          \n[string range $SeqNuc 0 44]\n[string range $SeqDep 0 44]"
	    }
	    set SeqPro [SeqNucToSeqPro $SeqNuc]
	    lappend LesSeqPro $SeqPro
	}
	set AllSeqPro [join $LesSeqPro "XXXXXXXXXX"]
	set AllTfaPro [SequenceFormatTFA $AllSeqPro $Entete "protbrut"]
	Espionne $AllTfaPro
	Sauve $AllTfaPro dans [GscopeFile $Nom "prottfa"]
	set Info "Operon: [join $LesGDF " "]"
	InformeSansDemander $Nom $Info
	Espionne $Info
    }
}

proc OperonNancyCreateSequences {} {
    FaireLire "Ne plus relancer. Merci"; exit; 
    cd [OperonNancy "Directory"]
    foreach OS [OperonNancy ListOf OS] {
	set GE [OperonNancy $OS ge]
	set Nuc2 [OperonNancy $GE nuc]
	set FE "mhpFE$GE"
	set F    [OperonNancy $GE F]
	set E    [OperonNancy $GE E]
	set NucF [OperonNancy $F nuc]
	set NucE [OperonNancy $E nuc]
	set dF 1
	set fF [expr [string length $NucF]                          ]
	set dE [expr [string length $Nuc2]-[string length $NucE] + 1]
	set fE [expr [string length $Nuc2]                          ]
	set Entete2 "$FE $OS mhp operon coding for operonprot $F base $dF to $fF and operonprot $E base $dE to $fE"
	set EnteteF "$F $OS mhp protein F"
	set EnteteE "$E $OS mhp protein E"
	set Tfa2 [SequenceFormatTFA $Nuc2 $Entete2 "nucbrut"]
	set TfaF [SequenceFormatTFA $NucF $EnteteF "nucbrut"]
	set TfaE [SequenceFormatTFA $NucE $EnteteE "nucbrut"]
	lappend LesFichiers [Sauve $Tfa2 dans $FE.tfa]
	lappend LesFichiers [Sauve $TfaF dans $F.tfa]
	lappend LesFichiers [Sauve $TfaE dans $E.tfa]
    }
    return $LesFichiers
}

proc OperonNancy {{Qui ""} {Quoi ""}} {
    FaireLire "Ne plus relancer. Merci"; exit; 
    #rR OperonNancy lit le seqs.txt et fournit les mhpEF mhpF mhpE
    global OperonNancy
    if {$Qui==""} { set Qui "ListOf"; set Quoi "keys"; }
    if {[info exists OperonNancy($Qui,$Quoi)]}  { return $OperonNancy($Qui,$Quoi) }
    if {[info exists OperonNancy("EstCharge")]} { return "" }
    set  OperonNancy("EstCharge") 1

    set NancyDir "[RepertoireDuGenome]/atelier/OperonNancy"
    set FiSeqs "$NancyDir/seqs.txt"
    set OperonNancy(Directory,) $NancyDir
    foreach Ligne [LesLignesDuFichier $FiSeqs] {
	set Ligne [string trim $Ligne]
	if {$Ligne==""} { continue }
	if {[regexp {^ *mhp} $Ligne]} {
	    if {[regexp {([0-9]+) *AA} $Ligne Match na]} {
		incr na
		scan $Ligne "%s" P
		if { ! [regexp {mhp(F|E)([a-z]+)} $P Match FE GE]} { FaireLire "Gloups on \n$Ligne" ; exit }
		if {$ge!=$GE} { FaireLire "$ge $GE on \n$Ligne" ; exit }
		set $FE "mhp$FE$GE"
		set Long($FE) $na
 		if {$FE=="F"} {
		    set F [set $FE]
		    lappend OperonNancy(ListOf,F) $F
		    set OperonNancy($GE,F) $F
		    set nb $na*3
		    set db 0
		    set fb [expr $nb-1]
		    set OperonNancy($F,nuc) [string range $OperonNancy($GE,nuc) $db $fb]
		    set Courant $F
		}
 		if {$FE=="E"} {
		    set E [set $FE]
		    lappend OperonNancy(ListOf,E) $E
		    set OperonNancy($GE,E) $E
		    set nb $na*3
		    set db [expr $nb-1]
		    set OperonNancy($E,nuc) [string range $OperonNancy($GE,nuc) end-$db end]
		    set Courant $E
		}
		continue
	    }
	    if { ! [regexp {mhpFE ([a-zA-z0-9 ]+)} $Ligne Match OS]} { FarireLire "Oups \n$Ligne"; exit }
	    scan $OS "%s %s" g e
	    set ge "[string tolower [string index $g 0]][string tolower [string index $e 0]]"
	    if {[info exists DejaVu($ge) ]} {
		set ge "[string tolower [string index $g 0]][string tolower [string range $e 0 1]]"
	    }
	    set DejaVu($ge) $Ligne
	    lappend OperonNancy(ListOf,OS) $OS
	    lappend OperonNancy(ListOf,GE) $ge
	    set OperonNancy($OS,ge) $ge
	    set OperonNancy($ge,os) $OS

	    set Courant "TwoNuc"
	    continue
	}
	if {$Courant=="TwoNuc"} { regsub -all "X" $Ligne "N" SeqNuc ; set OperonNancy($ge,nuc) $SeqNuc; }
	if {$Courant!="TwoNuc"} {
	    set OperonNancy($Courant,pro) $Ligne
	    set ProFromNuc [SeqNucToSeqPro $OperonNancy($Courant,nuc)]
	    if { ! [string equal -nocase $OperonNancy($Courant,pro) $ProFromNuc]} {
		FaireLire "$OperonNancy($Courant,pro)\n$ProFromNuc"
	    }
	}

    }
    set OperonNancy(ListOf,keys) [lsort [array names OperonNancy]]
    lappend OperonNancy(ListOf,keys) "ListOf,keys"
    return [OperonNancy $Qui $Quoi]
}


proc MiseAJourOligosExisting {} {
    foreach Fichier [glob "[RepertoireDuGenome]/atelier/*/*existing*.list"] {
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    scan $Ligne "%s %s %s %s" ASA please use P
	    lassign [DecomposeLaLigne $ASA] LesSujets
	    set FicOli "[RepertoireDuGenome]/oligos/$P.tfa"
	    if {[FileAbsent $FicOli]} { continue }
	    set Tfa [ContenuDuFichier $FicOli]
	    set Description [PremiereLigneDuFichier $FicOli]
	    if {$Description==""} { continue }
	    if {[regexp "oligoignore" $Description]} { continue }
	    set NewTfa $Tfa
	    set YaFull [regexp {seeFull (P[0-9]+)} $Description Match F]
	    while {$YaFull} {
		set FicOliF "[RepertoireDuGenome]/oligos/$F.tfa"
		if {[FileAbsent $FicOliF]} { set YaFull 0 ; break }
		set TfaF [ContenuDuFichier $FicOliF]
		set DesF [PremiereLigneDuFichier $FicOli]
		if {[regexp "oligoignore" $DesF]} { set YaFull ; break }
		set NewTfaF $TfaF
		break
	    }
	    foreach Sujet $LesSujets {
		if {[string first " $Sujet " "$Description "]>0} { continue }
		Espionne
		Espionne $Ligne
		regsub "for " $NewTfa "for $Sujet " NewTfa
		Espionne "$Tfa\n$NewTfa"
		if {$YaFull && [string first " $Sujet " "$DesF "]<0} {
		    regsub "for " $NewTfaF "for $Sujet " NewTfaF
		    Espionne "$TfaF\n$NewTfaF"
		}
	    }
#	    if {           $Tfa !=$NewTfa } {Sauve $NewTfa  dans $FicOli}
#	    if {$YaFull && $TfaF!=$NewTfaF} {Sauve $NewTfaF dans $FicOliF}
	}
    }
}

proc RepareLesRebuilded {} {
    foreach FP [glob "[RepertoireDuGenome]/oligos20081202/P*.tfa"] { 
	set TFA [ContenuDuFichier $FP]
	if { ! [regexp -nocase "Rebuilded" $TFA]} { continue }
	if { [regexp -nocase "without signal" $TFA]} { continue }
	Espionne $TFA
	scan $TFA "%s %s %s %s %s %s %s %s %s" P O w s f B r o S
	regsub ">" $P "" P
	set LesSubjects [Oli $B "Subjects"]
	set Subjects [join $LesSubjects " "]
	set Signals     [Oli $B "Signals"]
	set SignalsFull [Oli $B "SignalsFull"]
	set Sens        [Oli $B "Sens"]
	Espionne "$P $B $S $Subjects $Signals $SignalsFull" 

	regsub "oligo without signal for $B" $TFA "$Sens oligo with signal $SignalsFull for $Subjects" NewTFA

	regsub "oligos20081202" $FP "oligos" NewFP
#	Sauve $NewTFA dans $NewFP
    }
}

proc VerifieLesMutantsPourClonage {} {
    set LesMalPlaces {}
    foreach Ligne [LesLignesDuFichier [Fiches "bornesdespabs"]] {
	Espionne $Ligne
	scan $Ligne "%s %s %s" Nom D F
	if {[info exists DejaVu($D,$F)]} {
	    set GrandFrere [GrandFrereDuMutant $Nom]
	    while {[EstUnPABMute $GrandFrere]} { set GrandFrere [GrandFrereDuMutant $GrandFrere] }
	    if {$DejaVu($D,$F)==$GrandFrere} { continue }
#	    FaireLire "$Nom $D $F $DejaVu($D,$F)"
	    lappend LesMalPlaces "$Nom $D $F $DejaVu($D,$F)"
	}
	set DejaVu($D,$F) $Nom
    }
    AfficheListe $LesMalPlaces
}

proc SignalReverse Signal {
    return [NucToReverseAndComplementNuc [Signal $Signal]]
}

proc ShowCloning Nom {
    foreach Ligne [LesLignesDuFichier [GscopeFile $Nom "notes"]] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} {
	    lappend LaPage $Ligne
	    continue
	}
	set Ref ""
	scan $Ligne "%s" Cible
	if {0} {
	} elseif {[regexp {^P[0-9]{4,}$} $Cible]} {
	    set Ref "[WscopeScience]\\&ShowOli\\&$Cible"
	} elseif {[regexp {^N[0-9]{4,}$} $Cible]} {
	    set Ref "[WscopeScience]\\&ShowVirtualPPCR\\&$Cible"
	} elseif {[regexp {^N[0-9]{4,}_[0-9a-zA-Z]+$} $Cible]} {
	    set Ref "[WscopeScience]\\&FileMoi\\&rec1\\&$Cible"
	} elseif {[regexp {^N[0-9]{4,}_[0-9a-zA-Z]+_[0-9a-zA-Z]+$} $Cible]} {
	    set Ref "[WscopeScience]\\&FileMoi\\&rec2\\&$Cible"
	}
	if {$Ref==""} {
	    lappend LaPage $Ligne
	    continue
	}
	regsub $Cible $Ligne "<a href='$Ref' target='_blank'>$Cible</a>" Ligne
	lappend LaPage $Ligne
    }
    Html_ZeroToBody
    Html_BackTo
    Html_Append "<pre>[join $LaPage \n]</pre>"
    return [Html_Get]
}

proc TestHdac {} {
    set LesEnzymes [list BamHI BglII EcoRI NcoI NdeI NruI]
    foreach Fichier [lsort -dictionary [glob "[RepertoireDuGenome]/atelier/hdac/hdac*.tfa"]] {
	set ProtTfa [NucToProtTFA [ContenuDuFichier $Fichier]]
	set L  [string length [QueLaSequenceDuTexteTFA $ProtTfa]]
	regsub ".tfa$" $Fichier .prottfa FichierProt
	Sauve $ProtTfa dans $FichierProt
	set Hits [CheckRestrictionEnzymes $Fichier $LesEnzymes "" "GetHits"]
	lappend LaSortie $Hits
	lappend LaSortie "[expr 3*$L] bases  $L AA"
	lappend LaSortie " "
    }
    set Sortie [join $LaSortie "\n"]
    return [AfficheVariable $Sortie]
}

proc IUPAC B {

    if {[string length $B] > 1} {
	set Tout ""
	foreach C [split $B ""] {
	    append Tout [IUPAC $C]
	}
	return $Tout
    }

    set B [string toupper $B]
    if {$B=="A"} { return "A" }
    if {$B=="G"} { return "G" }
    if {$B=="C"} { return "C" }
    if {$B=="T"} { return "T" }
    if {$B=="U"} { return "T" }
    if {$B=="M"} { return "\[AC\]" }
    if {$B=="R"} { return "\[AG\]" }
    if {$B=="W"} { return "\[AT\]" }
    if {$B=="S"} { return "\[CG\]" }
    if {$B=="Y"} { return "\[CT\]" }
    if {$B=="K"} { return "\[GT\]" }
    if {$B=="V"} { return "\[ACG\]" }
    if {$B=="H"} { return "\[ACT\]" }
    if {$B=="D"} { return "\[AGT\]" }
    if {$B=="B"} { return "\[CGT\]" }
    if {$B=="N"} { return "\[ACGT\]" }	
    return $B
}

proc RestrictionEnzymesStatistics {{Quoi ""}} {
    set FichierStat "[Fiches]/EnzymesStatistics.txt"
    set FichierHits "[Fiches]/EnzymesHits.txt"

    if {$Quoi==""} { set Quoi "ShowHits" }

    if {$Quoi=="Update"} {
	file delete -force $FichierStat
	file delete -force $FichierHits
	regsub "Update" $Quoi "" Quoi
    }

    if {[FileExists $FichierStat] || [FileExists $FichierHits]} {
	if {[regexp "Statistics" $Quoi]} { set Texte [ContenuDuFichier $FichierStat] }
	if {[regexp "Hits"       $Quoi]} { set Texte [ContenuDuFichier $FichierHits] }
	if {[regexp "Show"       $Quoi]} { return [AfficheVariable $Texte "" "RestrictionEnzymesStatistics"] }
	return $Texte
    }

    foreach E [RestrictionEnzyme ListOf Enzymes] {
	set SE [string toupper [RestrictionEnzyme $E "Sequence"]]
	set SEX [IUPAC $SE]
	set LesHits {}
	set NbHits 0
	foreach Nom [ListeDesPABs] {
	    if {[EstUnPABMute $Nom]} { continue }
	    set FichierTFA [GscopeFile $Nom "nuctfa"]
	    if {[FileAbsent $FichierTFA]} { continue }
	    set Seq [string toupper [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]]]
	    if { ! [set N [regexp -all $SEX $Seq]]} { continue }
	    lappend LesHits [Alias $Nom]
	    incr NbHits $N
	}
	set EnzHitsCount "[format "%-8s %-20s %3d %4d" $E $SE [llength $LesHits] $NbHits]"
	Espionne                       "$EnzHitsCount"                                        
	AppendAuFichier "$FichierStat" "$EnzHitsCount"
	AppendAuFichier "$FichierHits" "$EnzHitsCount $LesHits" 
    }
    return [RestrictionEnzymesStatistics $Quoi]
}

proc CheckRestrictionEnzymes {NomOuAlias {ListOfEnzymes ""} {Texte ""} {Quoi ""}} {

    if {[regexp "^Get" $Texte]} { set Quoi $Texte ; set Texte "" } 

    regsub "^for_" $NomOuAlias "" NomOuAlias

    if {$ListOfEnzymes=="" || $ListOfEnzymes=="All"} { set ListOfEnzymes [RestrictionEnzyme ListOf Enzymes] }
    if {$ListOfEnzymes=="Signals"} {
	set ListOfEnzymes {}
	foreach Signal [Signal ListOf Signals] {
	    set EstUnSignal($Signal) 1 
	}
	foreach E [RestrictionEnzyme ListOf Enzymes] {
	    if {[info exists EstUnSignal($E)]} { lappend ListOfEnzymes $E }
	}
    }

    set Nom ""
    set Alias ""
    set DE ""
    while {$Nom==""} {
	if {$NomOuAlias=="FromFile"}      { set Nom "FromFile"  ; set NomOuAlias $Texte }
	if {[regexp "/" $NomOuAlias]}     { set Nom "FromFile"  ; break }
	if {$NomOuAlias=="FromSequence"}  { set Nom $NomOuAlias ; break }
	if {[EstUnPAB $NomOuAlias]}       { set Nom $NomOuAlias ; break }
	if {[NomDuAlias $NomOuAlias]!=""} { set Nom $NomOuAlias ; break }
	if {$Texte==""} { set Texte $NomOuAlias }
	set NomOuAlias "FromSequence"
    }
    if {[EstUnPAB $Nom]} {
	set Alias [Alias $Nom]
	set DE [DefinitionRapide $Nom]
	set Seq [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]]
    }
    if {$Nom=="FromSequence"} {
	if {[regexp ">" $Texte]} {
	    set Seq [QueLaSequenceDuTexteTFA $Texte]
	} else {
	    set Seq $Texte
	}
    }
    if {$Nom=="FromFile"} {
	set Seq [QueLaSequenceDuFichierTFA $NomOuAlias]
	set Nom $NomOuAlias
    }

    set Seq [string toupper $Seq]
    set LesHits [list "CheckRestrictionEnzymes for $Nom $Alias $DE"]
    foreach E $ListOfEnzymes {
	set SE [string toupper [RestrictionEnzyme $E "Sequence"]]
	set SEX [IUPAC $SE]

	set LesDFs [regexp -all -indices -inline $SEX $Seq]
	if {$LesDFs=={}} {
	    lappend LesHits "[format %-8s $E] [format %-20s $SE]         NotFound"
	} else {
	    set LesIs {}
	    foreach DF $LesDFs {
		scan $DF "%d" I
		lappend LesIs "[expr $I+1] [expr ($I+3)/3]"
	    }
	    lappend LesHits "[format %-8s $E] [format %-20s $SE] [join $LesIs " / "]"
	}
    }
    set Hits [join $LesHits "\n"]
    if {$Quoi=="GetHtml"} { return [Html_DuTexteTelQuel $Hits] }
    if {$Quoi=="GetHits"} { return $Hits } 
    return [AfficheVariable $Hits "" "Restriction Enzymes Hits for $Nom"]
}

proc ShowRestrictionEnzyme {} {
    foreach E [RestrictionEnzyme ListOf Enzymes] {
	set Ligne [format "%-8s %-20s %s" $E [RestrictionEnzyme $E "Sequence"] [RestrictionEnzyme $E "SequenceCut"]]
	lappend LesLignes $Ligne
   }
   set Texte [join $LesLignes "\n"]
   return [AfficheVariable $Texte "AvecEnzyme" "RestrictionEnzymes"]
}

proc RestrictionEnzyme {{Qui ""} {Quoi ""}} {
    global RestrictionEnzyme

    if {$Qui==""}  { set Qui  "ListOf"  }
    if {$Quoi==""} {
	set Quoi "Sequence"
	if {$Qui=="ListOf"} { set Quoi "Enzymes" }
    }

    if {[info exists RestrictionEnzyme($Qui,$Quoi)]} { return $RestrictionEnzyme($Qui,$Quoi) }
    if {[info exists RestrictionEnzyme("EstCharge")]} { return "" }
    set RestrictionEnzyme("EstCharge") 1

    set FichierEnzyme "[GscopeEtc]/enzyme.dat"
    set RestrictionEnzyme(File,Name) $FichierEnzyme
    set RestrictionEnzyme(File,Content) [ContenuDuFichier $FichierEnzyme]

    set OnAttendPointPoint 1
    foreach Ligne [LesLignesDuFichier $FichierEnzyme] {
	if {$OnAttendPointPoint} {
	    if {[regexp {\.\.\s*$} $Ligne]} { set OnAttendPointPoint 0 }
	    continue
	}
	if {[regexp {^\;} $Ligne]} { continue }
	regsub {>.*} $Ligne "" Ligne
	set Ligne [string trim $Ligne]
	set Enz ""
	set SeqCut ""
	set Autres "" 
	scan $Ligne "%s %d %s %d %s %s" Enz P SeqCut M Exclam Autres
	if {$Enz=="" || $SeqCut==""} { continue }
	set LesEnzymesCourants [split $Autres ","]
	lappend LesEnzymesCourants $Enz
	regsub -all {['_]} $SeqCut "" Seq
	foreach Enzyme $LesEnzymesCourants {
	    set  RestrictionEnzyme($Enzyme,SequenceCut) $SeqCut
	    set  RestrictionEnzyme($Enzyme,Sequence) $Seq
	    lappend RestrictionEnzyme(ListOf,Enzymes) $Enz
	    lappend RestrictionEnzyme(ListOf,Sequence) $Seq
	    lappend RestrictionEnzyme(ListOf,SequenceCut) $SeqCut
	}
	set RestrictionEnzyme(ListOf,Sequence)    [lsort -unique -dictionary $RestrictionEnzyme(ListOf,Sequence)]
	set RestrictionEnzyme(ListOf,SequenceCut) [lsort -unique -dictionary $RestrictionEnzyme(ListOf,SequenceCut)]
	set RestrictionEnzyme(ListOf,Enzymes)     [lsort -unique -dictionary $RestrictionEnzyme(ListOf,Enzymes)]
    }
    return [RestrictionEnzyme $Qui $Quoi]
}

proc CompositionDesSequences {{Rep ""} {Action ""} {Ordre ""} {Sens ""}}  {
    if {$Rep==""} { set Rep [ChoixDuRepertoire [RepertoireDuGenome]] }
    if {$Sens==""}  { set Sens "increasing" }
    if {$Ordre==""} { set Ordre 0 }
    if {$Action==""} { set Action "Show" }
    if { ! [regexp "/" $Rep]} { set Rep "[RepertoireDuGenome]/$Rep" }
    foreach Fichier [lsort [glob -nocomplain $Rep/*]] {
	set Nom [file tail $Fichier]
	set Seq [QueLaSequenceDuFichierTFA $Fichier]
	set Seq [string toupper $Seq]
	set Entete [EnteteDuFichierTFA $Fichier]
	set L [regexp -all "." $Seq]
	set Ligne "$Nom length [format "%4d" $L] :" 
	foreach C [lsort -unique [split $Seq ""]] {
	    set N [regexp -all -nocase -- "$C" $Seq]
	    append Ligne " [format "%4d" $N] $C"
	}
	append Ligne " $Entete" 
	lappend LeTexte $Ligne
	set ListeDesMots [LesMotsDeLaLigne $Ligne]
	lappend LesListesDesMots $ListeDesMots
	set TexteDesMots([join $ListeDesMots "_"]) $Ligne
    }
    set LeBonTexte {}
    foreach LdM [lsort -$Sens -index $Ordre $LesListesDesMots] {
	lappend LeBonTexte $TexteDesMots([join $LdM "_"])
    }
    if {$Action=="GetList"} { return $LeBonTexte }
    if {$Action=="GetText"} { return [join $LeBonTexte "\n"]}
    set F [AfficheVariable [join $LeBonTexte "\n"] "" "CompositionDesSequences_$Rep"]
    set B [BoutonneLaFenetre $F "Composition" ""]
    $B configure -text "Composition ReOrder lines/ New" -background "cyan"
    bind $B <1> "CompositionDesSequences $Rep Show \[Entre $Ordre\] \[ChoixParmi {increasing decreasing}\]"
    bind $B <2> "CompositionDesSequences"
    return $F
}

proc MatOl {{Qui ""} {Quoi ""}} {
    global MatOl 

    if {$Qui==""} {
	return [list \
		"MatOl P Matrice" \
		"MatOl P AA" \
		"MatOl P NA" \
		"MatOl P Orient" \
		"MatOl P Subjects" \
		"MatOl LaListeDes Oligos" \
		"MatOl LaListeDes Matrices" \
		"MatOl LaListeDes Fichiers"]
    }

    if {$Quoi==""} { set Quoi "Matrice" }

    if {[info exists MatOl($Qui,$Quoi)] } { return [set MatOl($Qui,$Quoi)] }
    if {[info exists MatOl("EstCharge")]} { return "" }

    set  MatOl("EstCharge") 1

    set FiMatOfOl "[RepertoireDuGenome]/fiches/matrices_of_oligos"
    if { ! [file exists $FiMatOfOl]} {
	if { ! [OuiOuNon "$FiMatOfOl\n does not exist. Do I create it ?" 0]} { return "" }
	PositionSurMatricesPourTous
    }
    set LeVieux [LesLignesDuFichier $FiMatOfOl]
    set LeNouveau {}
    foreach Ligne $LeVieux {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { lappend LeNouveau $Ligne ;continue }
	set BonneLigne $Ligne
	set Mat ""
	scan $Ligne "%s %d %d %s %s" P NA AA Orient Mat
	if {[regexp {=|~$} $Mat]} { set Mat "" }
	if {[regexp {=|~$} $Mat]} { set Mat "" }
	lappend MatOl(LaListeDes,Oligos) $P
	set Subjects [Oli $P "Subjects"]
	set Subjects [join [lsort -unique [split $Subjects " "]] " "] 
	set MatSubjects [string trim [StringSuivant "=> " dans $Ligne]]
	if {$MatSubjects!=$Subjects} {
	    if {$Subjects!="" && [OuiOuNon "for $P\nMat gives $MatSubjects\nOli gives $Subjects\nDo you choose Oli ?"]} {
		set MatSubjects $Subjects
		regsub {=> .*} $Ligne "=> $Subjects" BonneLigne
	    }
	}
	lappend MatOl($P,Subjects) $MatSubjects
	lappend MatOl($P,NA) $NA
	lappend MatOl($P,AA) $AA
	lappend MatOl($P,Orient) $Orient
	lappend LeNouveau $BonneLigne
	if {$NA<=0} { continue }
	if {[regexp "/" $Mat]} {
	    set FiMat $Mat
	} else {
	    set FiMat "[RepertoireDuGenome]/nuctfa/$Mat"
	}
	lappend MatOl(LaListeDes,Matrices) $Mat
	lappend MatOl(LaListeDes,Fichiers) $FiMat
	if {[file exists $FiMat]} {
	    lappend MatOl($P,Matrice) $FiMat
	    if {$Orient=="F"} {
		lappend MatOl($P,Sequence) [ZoneADNDuFichierTFA $NA end $FiMat]
	    } else {
		lappend MatOl($P,Sequence) [ZoneADNDuFichierTFA   1 $NA $FiMat]
	    }
	} else {
	    lappend MatOl($P,Matrice)  "FileLoosed"
	    lappend MatOl($P,Sequence) "FileLoosed"
	}
    }
    if {$LeNouveau!=$LeVieux && [OuiOuNon "I made some corrections in\n$FiMatOfOl\nDo I save them ?"]} {
	SauveLesLignes $LeNouveau dans $FiMatOfOl
    }
    set MatOl(LaListeDes,Matrices) [lsort -unique [set MatOl(LaListeDes,Matrices)]]
    set MatOl(LaListeDes,Fichiers) [lsort -unique [set MatOl(LaListeDes,Fichiers)]]
    return [MatOl $Qui $Quoi]
    
}

proc SupprimeDoublonsDansMatricesOfOligos {} {
    set  FiMatDefaut "[RepertoireDuGenome]/fiches/matrices_of_oligos"
    Garde $FiMatDefaut
    set LesBons {}
    foreach Ligne [LesLignesDuFichier $FiMatDefaut] {
	set Sujets [StringSuivant "=> " dans $Ligne]
	set Sujets [join [lsort -unique [split $Sujets " "]] " "] 
	regsub {=> .*} $Ligne "" Debut
	lappend LesBons "$Debut => $Sujets"
    }
    SauveLesLignes $LesBons dans $FiMatDefaut
    return $FiMatDefaut
}

proc PositionSurMatricesPourTous {{AppendOrShow ""} {FiMat ""}} {

    if {$AppendOrShow==""} { set AppendOrShow "Append" }
    set Append [regexp "Append" $AppendOrShow]
    set Show   [regexp "Show"   $AppendOrShow]

    set  FiMatDefaut "[RepertoireDuGenome]/fiches/matrices_of_oligos"
    if {$FiMat==""} { set FiMat $FiMatDefaut }

    if {$FiMat=="ShowOnly"} { set Show 1 }

    set ToutesLesPositions {}

    if {[FileExists $FiMat]} {
	foreach Ligne [LesLignesDuFichier $FiMat] {
	    scan $Ligne "%s %d" P AA
	    if {$AA<0} { continue } 
	    set DejaVu($P) 1
	    lappend ToutesLesPositions $Ligne
	}
    }

    if {1 || [OuiOuNon "Do I use Oli to list existing oligos (instead of CloDo) ?"]} {
	set LesPs [Oli "LaListeMerci"]
    } else {
	set LesPs [CloDo "ListAllPlease" oligos]
    }
    if {$Append} {
	foreach P $LesPs {
	    Espionne "PositionSurMatrice pour $P"
	    if { ! [regexp {^P[0-9]+$} $P]} { continue }
	    if {[info exists DejaVu($P)]} { continue }
	    set LesPositions [PositionSurMatrices $P]
	    foreach Pos $LesPositions  {
		lappend ToutesLesPositions $Pos
		AppendAuFichier $FiMat $Pos
	    }
	}
    }
    set ToutesLesPositions [lsort -unique $ToutesLesPositions]
    if {$Append} { SauveLesLignes $ToutesLesPositions dans $FiMat }

    if {$Show} {
	set Fen [AfficheVariable [join $ToutesLesPositions "\n"] "AvecOli" Matrices]
	return $Fen
    }
    return $FiMat
}

proc PositionSurMatrices {P {Ou ""}} {

    if {$Ou==""} { set Ou "nuctfa" }

    if {[regexp "/" $Ou]} {
	set LesMatrices [glob -nocomplain "$Ou/*"]
    } else {
	set LesMatrices [glob -nocomplain "[RepertoireDuGenome]/$Ou/*"]
    }

    if {[Oli $P TFA]==""} {
	Espionne "$P merde"
	set Orient "!"
	set Posi [format "%4d %4d" -2 -2]
#	set Sign [CloDo signal $P]
	set Sign ""
	if {$Sign==""} { set Sign "no signal available" }
	set Resume "$Posi $Orient [format "%-15s" "      "] => $Sign"
	return [list "$P $Resume"]
    }

    set SeqD [Oli $P "SeqSubject"]
    set Sens [Oli $P "Sens"]
    set Orient "?"
    if {$Sens=="5'"} { set Orient "F" }
    if {$Sens=="3'"} { set Orient "R" }
    set LesPositions {}
    set Posi [format "%4d %4d" -1 -1]
    foreach Fichier $LesMatrices {
	set Queue [file tail $Fichier]
	if {[regexp {~$|\.20[0-9]{4,}$} $Queue]} { continue }
	if {[string length $SeqD] < 10} { break }
	if { ! [EstUnFichierTFA $Fichier]} { continue }

	if {[regexp -- "\-mRNA" $Fichier]} { continue }
	regsub "matrices_a_tester/" $Fichier "matrices" FichierOK
	if {$Fichier!=$FichierOK && [file exists $FichierOK]}  { continue }

	if {$Sens=="5'"} { set FoR "F" } else { set FoR "RaC" }
	set NAetAA [PositionDuPatternDansFichierTFA $SeqD $Fichier $FoR]
	scan $NAetAA "%d %d" NA AA
	if {$NA<=0} { continue }
	set Posi [format "%4d %4d" $NA $AA]
	set Sujets [Oli $P "Subjects"]
	set Matrice [file tail $Fichier]
	regsub ".tfa$" $Matrice "" Matrice

	set PGS [file tail $Matrice]
	set Alias [Alias $PGS]

	while 1 {
Espionne "$Alias $PGS $Sujets"
	    if { $Alias!="" && ! [regexp "^$Alias" $Sujets] } { break }
	    if { ! [EstUnPABMute $PGS]} { break }
	    Espionne "Oli $P $Sujets \n Y a t il un grand frere pour $Alias"
	    set GrandFrere [GrandFrereDuMutant $PGS]
	    if {$GrandFrere==""} { break }
	    set AliasGrandFrere [Alias $GrandFrere]
	    if {$AliasGrandFrere==""} { break }
	    Espionne "Oui $GrandFrere"
	    set LesNouveauxSujets {}
	    foreach Sujet [split $Sujets " "] {
		if { ! [regexp -indices {\-[0-9]+\-[0-9]+$} $Sujet Indices]} { continue }
		scan $Indices "%d" D
		set Bornes       [string range $Sujet $D end]
		set CorpsDuSujet [string range $Sujet 0 [incr D -1]]
		if { ! [string equal $AliasGrandFrere $CorpsDuSujet]} { continue }
		set NouveauSujet "$Alias$Bornes"
		lappend LesNouveauxSujets $NouveauSujet
		Espionne "NouveauSujet $NouveauSujet"
	    }
	    if {$LesNouveauxSujets!=""} {
		set Sujets "[join $LesNouveauxSujets " "] $Sujets"
	    }
	    break
	}

	set Sujets [join [lsort -unique [split $Sujets " "]] " "] 

	set Resume "$Posi $Orient [format "%-15s" $Matrice] => $Sujets"
	lappend LesPositions "$P $Resume"
    }
    if {$LesPositions=={}} {
	set Resume "$Posi $Orient [format "%-15s" "      "] => [Oli $P Subjects]"
	set LesPositions [list "$P $Resume"]
    }
    return $LesPositions
}

proc PositionDuPatternDansFichierTFA {Pattern Fichier {RaC ""} {NAouAA ""} {Circulaire ""} {GetAll ""}} {

    set LastAlso [regexp -nocase "LastAlso" $Circulaire]
    set Circulaire [regexp -nocase "Circ" $Circulaire]

    if {[regexp -nocase "GetAll" $RaC]} {
	set GetAll $RaC
	set Rac "" 
    }

    if {$RaC=="RaC"} { set RaC 1 } else { set RaC 0 } 

    if {$NAouAA==""} { set NAouAA "NA_AA" }

    set Seq [string toupper [QueLaSequenceDuFichierTFA $Fichier]]
    set lSeq [string length $Seq]

    set OnTesteUneProteine [regexp {[^ATGCN\-\. ]} $Seq]

    if {$Circulaire} { set Seq "$Seq$Seq" }
    regsub -all -nocase {[^A-Z]} $Pattern "" Pattern

    if {$RaC} { set Pattern [NucToReverseAndComplementNuc $Pattern] }

    set PATTERN [string toupper $Pattern]
    set lPat [string length $PATTERN]

    if {[regexp -nocase "GetAll" $GetAll]} {
	set LesPositions {}
	set i 0
	while { [set NA [string first $PATTERN "x$Seq" $i]]>=0 } {
	    lappend LesPositions $NA
	    set i $NA
	    incr i
	}
	return $LesPositions
    }

    set lastNA [string last $PATTERN "x$Seq"]
    set NA [string first $PATTERN "x$Seq"]
    if {$RaC && $NA>0} { incr NA [expr $lPat-1] } 

    if {$OnTesteUneProteine && $NA>0} {
	set NA [expr ($NA-1)*3 + 1]
	set lastNA [expr ($lastNA-1)*3 + 1]
    }

    if {$NAouAA == "NA"} {
	return $NA
    }
    if {$NA>0} {
	set AA [expr ($NA-1)/3+1]
    } else {
	set AA -1
    }
    if {$NAouAA == "AA"} { return $AA }
    if {$LastAlso} { return "$NA $AA $lastNA" }
    return "$NA $AA"
}