#rR gscope_clonage.tcl

proc CorrigeCmyc {} {
    FaireLire "Cette procedure ne devrait plus etre necessaire. C'etait pour corriger les cMyc"
    foreach FO [lsort [glob "[RepertoireDuGenome]/oligos/P*.tfa"]] {
	set P [file tail $FO]
	regsub ".tfa" $P "" P
	set TFA [ContenuDuFichier $FO]
	if { ! [regexp "cMyc" $TFA]} { continue }
	if { ! [regexp "seeFull" $TFA]} { continue }
	set Entete [EnteteDuTexteTFA $TFA]
	Espionne
	Espionne "**************************************************************************************************"
	Espionne
	Espionne $Entete
	set Fulls [StringApres "seeFull " dans $Entete]
	set LesFull [split $Fulls "+"]
	foreach F $LesFull {
	    regsub $P $FO $F FF
	    set TFAF [ContenuDuFichier $FF]
	    set EF [EnteteDuTexteTFA $TFAF]
	    set SF [StringApres "signal " dans $EF]
	    set SB [StringApres "RebuildedBrockenOli of " dans $EF]
	    set Bon "BamHI_$SB"
	    regsub $SF $EF $Bon BonEF
	    Espionne "$EF"
	    Espionne "$BonEF"
	    regsub $EF $TFAF $BonEF NewTFAF
	    Espionne "$TFAF\n$NewTFAF"
#	    Sauve $NewTFAF dans $FF
	}
    }
}

proc CorrigeRebuilded {} {
    FaireLire "Cette procedure ne devrait plus etre necessaire. C'etait pour corriger les without signal du STREP"
    foreach FO [lsort [glob "[RepertoireDuGenome]/oligos/P*.tfa"]] {
	set P [file tail $FO]
	regsub ".tfa" $P "" P
	set TFA [ContenuDuFichier $FO]
	if { ! [regexp "RebuildedBrockenOli" $TFA]} { continue }
	if { ! [regexp "without signal"      $TFA]} { continue }
	set Entete [EnteteDuTexteTFA $TFA]
	set B [StringApres "seeBrocken " dans $Entete]
	regsub $P $FO $B FB
	set EB [EnteteDuFichierTFA $FB]
	set NewEntete ">[FormatageEntete $EB "PourOligoNonBrocOli" $P] seeBrocken $B"
	Espionne 
	Espionne "$Entete"
	Espionne "$NewEntete"
	regsub $Entete $TFA $NewEntete NewTFA
	Espionne "$TFA\n$NewTFA"
#	Sauve $NewTFA dans $FO
    }
}

proc CorrigeAfterMe {} {
    FaireLire "Cette procedure ne devrait plus etre necessaire. C'etait au temps ou il y avait AfterMe dans les BrocOli"
    foreach FO [lsort -decreasing [glob "[RepertoireDuGenome]/oligos/P*.tfa"]] {
	set P [file tail $FO]
	regsub ".tfa" $P "" P
	set TFA [ContenuDuFichier $FO]
	if { ! [regexp "AfterMe" $TFA]} { set PreviousTFA $TFA ; set PreviousP $P ; continue }
	if { ! [regexp $P $PreviousTFA]} { FaireLire $P }
	Espionne "$P $PreviousP"
	Espionne $TFA
	regsub "AfterMe" $TFA $PreviousP NewTFA
	Espionne $NewTFA
	Sauve $NewTFA dans $FO
    }
}

proc OliVsPofOl {} {
    foreach P [PofOl LaListeDesPs] {
	lappend LaSortie "$P"
    }
}

proc StartOfOligos {} {
    foreach P [Oli "LaListeMerci"] {
	if {[Oli $P Sens]=="3'"} { continue }
	set Seq [string toupper [Oli $P SeqSubject]]
	set Codon [string range $Seq 0 2]
	if {$Codon==""} { continue }
	if { ! [info exists Cumul($Codon)]} { set Cumul($Codon) 0 }
	incr Cumul($Codon)
	lappend LesCodons $Codon
    }
    foreach Codon [lsort -unique $LesCodons] {
	lappend LaSortie "$Codon $Cumul($Codon)"
    }
    return $LaSortie
}

proc InformeSeqCheck {Selection Page} {

    Wup "First we take from Selectio then from Page" 

    set Tout "$Selection\n$Page"

    set PGS ""
    set FichierBlast "BlastfileNotFound"
    set CodeSeqFile "CodeSequenceFileNotFound"
    set P "NoOligoFound"
    foreach Ligne [split $Tout "\n"] {
	if {$FichierBlast=="BlastfileNotFound" && [regexp ".blast$" $Ligne]} {
	    set FichierBlast $Ligne
	    set CodeSeqFile [file tail $FichierBlast]
	    regsub {\.blast$} $CodeSeqFile "" CodeSeqFile
	}
	if {[regexp "^ PGS " $Ligne] && $PGS==""} {
	    scan $Ligne "%s %s" Bidon PGS
	}
	if {[regexp "^ Oli " $Ligne] && $P=="NoOligoFound"} {
	    scan $Ligne "%s %s" Bidon P
	}
	if {$FichierBlast!="BlastfileNotFound" \
		&& $CodeSeqFile!="CodeSequenceFileNotFound" \
		&& $P!="NoOligoFound"} {
	    break
	}
    }
    global TextePourInformeVerificationSequencage
    if {[info exists TextePourInformeVerificationSequencage]} {
	set Bornes $TextePourInformeVerificationSequencage
    } else {
	set Bornes ""
    }
    set SeqCheck "SeqCheck: $CodeSeqFile $P $Bornes"
    if {$PGS==""} { return "" }

    if { ! [OuiOuNon "Ok to inform '$PGS' with \n$SeqCheck"]} { return "" }
    return [Informe $PGS $SeqCheck]
}

proc NatureDeLaSequenceAuVuDu Titre {

    if {[EstUnPAB $Titre]} { return "PGS" }

    if {[regexp {^P[0-9]+$} $Titre]} { return "Oli" } 

    if {[regexp {^Rec1_} $Titre]} { return "Rec1" } 

    if {[regexp {^Rec2_} $Titre]} { return "Rec2" } 
    if {[regexp {^N[0-9]+_[^_]+_p} $Titre]} { return "Rec2" } 

    if {[regexp {^N[0-9]+_pDONR} $Titre]} { return "Rec1" } 
    if {[regexp {^N[0-9]+_p}     $Titre]} { return "Rec1" } 

    if {[regexp {^pDONR} $Titre]} { return "pDONR" } 
    if {[regexp {^pDEST} $Titre]} { return "pDEST" } 

    if {[regexp {^ProduitPCR} $Titre]} { return "PPCR" } 
    if {[regexp {^PPCR}       $Titre]} { return "PPCR" } 
    if {[regexp {^N[0-9]+$}   $Titre]} { return "VPPCR" } 

    if {[NomDuAlias $Titre]!=""} { return "Alias" }
    return ""
}

proc VerificationSequencageApprofondiePourTous {} {
    foreach FichierBlast [glob "[RepertoireDuGenome]/retoursequencage/blast/*.blast"] {
	Espionne $FichierBlast
	if {[regexp "FASTA" [ContenuDuFichier $FichierBlast]]} { continue }
	set Retour [VerificationSequencageApprofondie "" $FichierBlast "Show" "AvecRetour"]
	if {$Retour==""} { continue }
	foreach Ligne [split $Retour "\n"] {
	    if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	    Espionne $Ligne
	}
    }
}

proc VerificationSequencageApprofondie {FichierSequence FichierBlast {Action ""} {Maniere ""}} {

    if {$Action==""} { set Action "Show" }

    global ScoreDansProfil
    set ScoreDansProfilMemo 0
    if {[info exists ScoreDansProfil]} { set ScoreDansProfilMemo $ScoreDansProfil }
    set ScoreDansProfil 1
    set lPartieSegAli {}
    set n [DecortiqueBlast $FichierBlast "SansSeuilExpect" "SansLimiteDeNombreDuTout" Query \
	    lBanqueId lAccess lDE lScore lPN lPartieSegAli]
    set ScoreDansProfil $ScoreDansProfilMemo

    set Compte 0
    set NFoisQuoiMax 10
    foreach BanqueId $lBanqueId ScoreLu $lScore PN $lPN {
	set Quoi [NatureDeLaSequenceAuVuDu $BanqueId]
	if { ! [info exists NFois($Quoi)]} { set NFois($Quoi) 0 }
	if {[incr NFois($Quoi)] > $NFoisQuoiMax} { continue }
	if {$Quoi==""} {
	    lappend LesHits(Autres) $BanqueId
	    lappend Expect(Autres)  $PN
	    lappend Score(Autres)   $ScoreLu
	    continue
	}

	if { ! [info exists Expect($Quoi)]} { set Expect($Quoi) $PN }
#rR	if { $PN > [set Expect($Quoi)] } { continue }
	if { ! [info exists Score($Quoi)]} { set Score($Quoi) $ScoreLu }
	if { $ScoreLu < [set Score($Quoi)] } { continue }
	if {$Quoi=="Alias"} {
	    set PGS [NomDuAlias $BanqueId]
	    foreach PG [split $PGS " "] {
		if {[EstUnPAB $PG]} { lappend LesHits(PGS) $PG}
	    }
	}
	lappend LesHits($Quoi) $BanqueId
    }
    set LaPage {}
    lappend LaPage $FichierSequence
    lappend LaPage $FichierBlast
    set LesIllumines {}
    foreach Quoi [list "PGS" "Alias" "Oli" "VPPCR" "PPCR" "Rec1" "pDONR" "pDEST" "Autres"] {
	if { ! [info exists LesHits($Quoi)] } { continue }
	lappend LaPage "\n"
	if {[info exists Score($Quoi)] && [info exists Expect($Quoi)]} {
	    lappend LaPage "$Quoi [set Score($Quoi)] [set Expect($Quoi)]"
	}
	set Prems 1
	foreach Hi [set LesHits($Quoi)] {
	    set Ligne " $Quoi $Hi"  
	    if {$Prems && ($Quoi=="PGS" || $Quoi=="Oli" || $Quoi=="VPPCR")} { lappend LesIllumines $Ligne }
	    if {$Quoi=="Oli"} { append Ligne " [Oli $Hi Description]" }
	    if {$Quoi=="VPPCR"} { append Ligne " [VirtualPPCREnStock $Hi Resume]" }
	    set Prems 0
	    lappend LaPage $Ligne   
	}
    }
    set Page [join $LaPage "\n"]
    if {$Action=="RetourneTexte"} { return $Page }
    set MaManiere $Maniere
    if {[regexp "AvecRetour" $Maniere]} { append MaManiere "AvecRetourMaisSansWait" }
    set w [AfficheVariable $Page "AvecOli$MaManiere" "Hits_of_$FichierBlast"]
    if { ! [regexp "AvecRetour" $Maniere]} { return $w }
    if {$LesIllumines!={}} {
	foreach Illu $LesIllumines {
	    Illumine $Illu $w
	}
	Illumine [lindex $LesIllumines 0] $w
    }
    set Clavier "$w.buttons"
    TouchePour $Clavier "See the Blast" "AfficheUneSortieBlast $FichierBlast" "" "lightblue"
    TouchePour $Clavier "Disp SegAli"   "AfficheZoneContigue $FichierBlast \[selection get\]" "" "lightblue"
    TouchePour $Clavier "InformSeqCheck" "InformeSeqCheck \[selection get\] \[set PagePropre($w)\]" "" "lightblue"
    global VariableDeRetour
    tkwait variable VariableDeRetour($w)
    set v $VariableDeRetour($w)
    unset  VariableDeRetour($w)
    catch {destroy $w}
    return $v
}

proc GrandFrereDuMutant Nom {
    return [LesMutantsDe $Nom "SonGrandFrere"]
}

proc LesMutantsDe {PGS {Quoi ""}} {
    global LesMutantsDe
    
    Wup "Quoi can be Sites or Names"

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

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

    set LesGrandsFreres {}
    foreach Nom [ListeDesPABs] {
	set Texte [ExtraitInfo $Nom "Muted"]
	if {$Texte==""} { continue }
	if { ! [regexp "mutation of" $Texte]} { continue }
	set GrandFrere [StringApres "mutation of" dans $Texte]
	lappend LesMutantsDe($GrandFrere,Names) $Nom

	set LesMutantsDe($Nom,SonGrandFrere) $GrandFrere

	regsub { *mutation +of +[^ ]+ +[^ ]+ } $Texte "" TexteCodes
	set LesCodes [split $TexteCodes]
	set LesCoOrdonnes {}
	foreach Code $LesCodes {
	    if { ! [regexp -nocase {[a-z]} $Code]} { continue }
	    regsub {[0-9]+} [string toupper $Code] " & " Coco
	    scan $Coco "%s %d %s" AncienP PosAncienP NouveauP
	    set LongAncienP [string length $AncienP]
	    lappend LesCoOrdonnes "$AncienP $PosAncienP $NouveauP"
	    lappend LesMutantsDe($GrandFrere,Sites) $PosAncienP
	    lappend LesGrandsFreres $GrandFrere
	}
    }
    set LesGrandsFreres [lsort -u $LesGrandsFreres]
    set LesMutantsDe(LaListeDes,GrandsFreres) $LesGrandsFreres
    foreach GrandFrere $LesGrandsFreres {
	set LesMutantsDe($GrandFrere,Sites) [lsort -integer -unique [set LesMutantsDe($GrandFrere,Sites)]]
    }
    return [LesMutantsDe $PGS $Quoi]
}

proc LesBornesParSeqCheck PGS {
    set LesSeqCheck [split [ExtraitInfo $PGS "SeqCheck"] "/"]
    set LesPossibles {}
    set LesIllumines {}
    foreach Ligne $LesSeqCheck {
	set Ligne [string trim $Ligne]
	if { ! [regexp { *(P[0-9]+) } $Ligne Match Oli]} {
	    lappend LesPossibles $Ligne
	    continue
	}
	set Sens [Oli $Oli "Sens"]
	if {$Sens=="3'"} {
	    regsub "$Oli " $Ligne "$Oli            " Ligne
	}
	lappend LesPossibles $Ligne
	lappend LesIllumines $Ligne
    }
    set LesBons [MorceauxChoisis $LesPossibles $LesIllumines \
		"Please select lines in the left window and press '--->'\n\
		Reorder with 'Up' and 'Down' if necessary."]
    set MinD  9999
    set MaxF -9999
    foreach Ligne $LesBons {
	set D ""
	set F ""
	while {1} {
	    scan $Ligne "%s %s %s" NomSequenceur Oli Bornes
	    set Sens [Oli $Oli "Sens"]
	    if { ! [regexp {[0-9]+\-[0-9]+} $Bornes]} {
		if {[OuiOuNon "$Ligne\is not as SeqName Pxxxx 123-987\n Do I skipp ?"]} { set D "Skip" ; break }
		if {[OuiOuNon "Do You want to correct it ?"]} {
		    set Ligne [Entre $Ligne]
		    continue
		}
		if {[OuiOuNon "Do I cancel ?"]} { return "" }
		continue
	    }
	    regsub {\-} $Bornes " " Bornes
	    scan $Bornes "%d %d" D F
	    break
	}
	if {$D=="Skip"} { continue }
	if {$Sens=="5'"} {
	    set MinD [Mini $F $MinD]
	}
	if {$Sens=="3'"} {
	    set MaxF [Maxi $D $MaxF]
	}
    }
    set Propose "$PGS $MinD $MaxF"
    while 1 {
	if {[OuiOuNon "Do I create sequencing oligos for\n$Propose ?\n\n(I'll extend it on each side)"]} {
	    return $Propose
	}
	if {[OuiOuNon "Do You want to correct it ?"]} {
	    set Propose [Entre $Propose]
	    continue
	}
	if {[OuiOuNon "Do I cancel ?"]} { return "" }
    }
}

proc NomDuFichierDesOligosPourSequencage FicOli {
    set FicOliOriginal $FicOli
    set Prem 1
    while {$Prem || $FicOli==""} {
	set Prem 0
	FaireLire "Please choose a file to store the oligos I'll create."
	set Rep [file dirname $FicOli]
	set Queue [file tail $FicOli]
	if { ! [regexp ".tfa$" $Queue]} {
	    regsub {\.[^.]+$} $Queue "" Queue
	    append Queue ".tfa"
	}
	set FicOli "$Rep/oliseq_$Queue"
	set FicOli [FichierPourSaveAs $FicOli]
	if {$FicOli==""} {
	    if {[OuiOuNon "Do I skip creation of oligos ?"]} {return ""}
	    set FicOli $FicOliOriginal
	    set Prem 1
	}
    }
    while {[file exists $FicOli]} {
	if {[OuiOuNon "$FicOli\nalready exists. Do I append to it ?"]} { return $FicOli }
	if {[OuiOuNon "$FicOli\nalready exists. Do I replace it ?"]} {
	    file delete -force $FicOli
	    return $FicOli
	}
	if {[OuiOuNon "$FicOli\nalready exists.	Do I skip creation of oligos ?"]} {
	    return ""
	}
	if {[OuiOuNon "$FicOli\nalready exist. Do You want to change it ?"]} {
	    return [NomDuFichierDesOligosPourSequencing $FicOli]
	}
    }
    return $FicOli
}

proc CreateSeqOli {Nom Debut Fin {Sens ""} {FicOli ""}} {
    if {$Sens==""} { set Sens "FR" }

    set LesTFAs {}

    set Alias [Alias $Nom]
    set Seq [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]]
    set SeqOliF [string range "n$Seq" $Debut $Fin]
    set SeqOliR [NucToReverseAndComplementNuc $SeqOliF]
    set NomDeLOligo "$Alias-${Debut}to${Fin}"
    if {[regexp -nocase "F" $Sens]} {
	set EnteteOliSeq "SeqOli_$NomDeLOligo sequencing oligo for $Nom $Alias $Debut to $Fin"
	set TFA [SequenceFormatTFA $SeqOliF $EnteteOliSeq "brut"]
	lappend LesTFAs $TFA
    }
    if {[regexp -nocase "R" $Sens]} {
	set EnteteOliSeqRac "SeqOliRaC_$NomDeLOligo reverse sequencing oligo for $Nom $Alias $Debut to $Fin"
	set TFA [SequenceFormatTFA $SeqOliR $EnteteOliSeqRac "brut"]
	lappend LesTFAs $TFA
    }
    return [join $LesTFAs "\n"]
}

proc CreateOligosForSequencing {FichierOuTexteOliSeq {FicOli ""} {ReverseAussi ""} {SansPremier ""} } {

    set LongueurOliSeq 21
    set LongOptimale  800
    set EcartAutorise  50

    while {! [OuiOuNon "Are following parameters ok ?\
	    \n OligoLength $LongueurOliSeq\
	    \n Offset between oligos $LongOptimale\
	    \n Tolerance $EcartAutorise"]} {
	set LongueurOliSeq [Entre 21]
	set LongOptimale   [Entre 800]
	set EcartAutorise  [Entre 50]
    }

    if {$ReverseAussi==""} {
	set ReverseAussi [Entre "SansReverse"]
    }
    if {$ReverseAussi=="SansReverse" || $ReverseAussi==0 } { set ReverseAussi 0 } else { set ReverseAussi 1 }
    if {$SansPremier==""} {
	if {[OuiOuNon "Do you want that I REMOVE the Nter and Cter oligos ?"]} {
	    set SansPremier "SansPremier"
	} else {
	    set SansPremier "AvecPremier"
	}
    }
    if {$SansPremier=="SansPremier" || $SansPremier==1 } { set SansPremier 1 } else { set SansPremier 0 }
 
    if {$FichierOuTexteOliSeq==""} { return "" }
    if {[regexp "\n" $FichierOuTexteOliSeq]} {
	if {$FicOli==""} {
	    set FicOli [NomDuFichierDesOligosPourSequencage "./sequencingoligos.tfa"]
	    if {$FicOli==""} { return "" }
	}
	set Texte $FichierOuTexteOliSeq
	set LesOligos {}
	foreach Ligne [split $Texte "\n"] {
	    CreateOligosForSequencing $Ligne $FicOli $ReverseAussi
	}
	return $FicOli
    }
    if { ! [EstUnPAB $FichierOuTexteOliSeq] && ! [regexp " " $FichierOuTexteOliSeq]} {
	set Fichier $FichierOuTexteOliSeq
	if {[file exists $Fichier]} {
	    set FicOli [NomDuFichierDesOligosPourSequencage $Fichier]
	    if {$FicOli==""} { return "" }
	    return [CreateOligosForSequencing [ContenuDuFichier $Fichier] $FicOli $ReverseAussi]
	}
	FaireLire "$FichierOuTexteOliSeq\ndoesn't exist. I'll cancel CreateOligosForSequencing"
	return [list "No sequencing oligo for ($FichierOuTexteOliSeq) which doesn't exist"]
    }

    if {$FicOli==""} { set FicOli [NomDuFichierDesOligosPourSequencage ""] }
    if {$FicOli==""} { return "" }

    set Ligne $FichierOuTexteOliSeq
    Espionne $Ligne

    if {[regexp "SeqOli" $Ligne]} {
	scan $Ligne "%s %s %s %s %s" Nom bidon Debut Fin Sens
	set TFAs [CreateSeqOli $Nom $Debut $Fin $Sens]
	AppendAuFichier $FicOli $TFAs
	return $FicOli
    }
    Espionne "perdu"
    set D ""
    set F ""
    scan $Ligne "%s %s %s" PAB D F
    set Alias [Alias $PAB]
    if {$Alias==""} { set Alias $PAB }

    set Marge 45
    if {$D=="SeqCheck"} {
	set BornesSeqCheck [LesBornesParSeqCheck $PAB]
	if {$BornesSeqCheck==""} { return "" }
	scan $BornesSeqCheck "%s %d %d" PAB DNuc FNuc
	set DNuc [expr $DNuc -$LongueurOliSeq -$Marge]
	set FNuc [expr $FNuc + $Marge]
	set D [expr ($DNuc-1)/3+1]
	set F [expr $FNuc/3]
	set SansPremier 0
    }
    set FichierNuc "[RepertoireDuGenome]/nuctfa/$PAB"
    if { ! [file exists $FichierNuc]} {
	FaireLire "$FichierNuc\ndoesn't exist. I'll cancel CreateOligosForSequencing for it."
	return [list "No sequencing oligo for ($FichierNuc) which doesn't exist"]
    }
    set LesSitesDeMutation [LesMutantsDe $PAB]
    set LesSitesDeMutationN {}
    foreach Site $LesSitesDeMutation {
	lappend LesSitesDeMutationN [expr ($Site-1)*3 + 1]
    }
    set  ToutSeq [QueLaSequenceDuFichierTFA $FichierNuc]
    set DToutSeqP 1
    set FToutSeqP [expr [string length $ToutSeq]/3]
    if {$D==""} { set D $DToutSeqP }
    if {$F==""} { set F $FToutSeqP }

    Wup "D et F indiquent les bornes en PROTEINE"

    set DN [expr ($D-1)*3 + 1]
    set FN [expr ($F-3)*3 + 1]
    set FinVoulue $FN
    set LongTotale [expr $FN-$DN+1]
    set LongVoulue ""
    while {$LongVoulue==""} {
	if {[expr $LongTotale<($LongOptimale+$EcartAutorise)]} { 
	    set LongVoulue $LongTotale
	    set NombrePossible 1
	    break
	} else {
	    set NombrePossible1 [expr $LongTotale/$LongOptimale]
	    set NombrePossible2 [expr $NombrePossible1+1]
	    set LongPossible1 [expr $LongTotale/$NombrePossible1 + 1]
	    set LongPossible2 [expr $LongTotale/$NombrePossible2 + 1]
	    if {[expr abs($LongOptimale-$LongPossible1)<$EcartAutorise]} {
		set NombrePossible $NombrePossible1
		set LongVoulue $LongPossible1
		break
	    }
	    if {[expr abs($LongOptimale-$LongPossible2)<$EcartAutorise]} {
		set NombrePossible $NombrePossible2
		set LongVoulue $LongPossible2
		break
	    }
	    set LongVoulue [ChoixParmi [list \
		    "$LongPossible1 for $NombrePossible1 oligos" \
		    "$LongPossible2 for $NombrePossible2 oligos"]]
	    if {$LongVoulue==""} { continue }
	    scan $LongVoulue "%d" LongVoulue
	    if {$LongVoulue==$LongPossible1} {
		set NombrePossible $NombrePossible1
	    } else {
		set NombrePossible $NombrePossible2
	    }
	}
    }
    set DOli $DN
    if {$SansPremier} { incr DOli $LongVoulue }
    while { $DOli < $FinVoulue} {
	set DOli3 [expr (($DOli-1)/3)*3 + 1]
	set FOli3 [expr $DOli3+$LongueurOliSeq-1]
	while 1 {
	    set ToucheUneMutation 0
	    foreach Site $LesSitesDeMutationN {
		if {$DOli3<=$Site && $Site<=$FOli3} {
		    set FOli3 [expr $Site-9]
		    set DOli3 [expr $FOli3-$LongueurOliSeq+1]
		    set ToucheUneMutation 1
		    break
		}
	    }
	    if { ! $ToucheUneMutation } { break }
	}
	set SeqOliN [string range "n$ToutSeq" $DOli3 $FOli3]
	set SeqOliP [SeqNucToSeqPro $SeqOliN]
	set DOliP [expr ($DOli3-1)/3 + 1]
	set NomDeLOligo "$Alias-${DOli3}to${FOli3}"
	set EnteteOliSeq "SeqOli_$NomDeLOligo sequencing oligo for $PAB $Alias $DOli3 to $FOli3"
	set TFA [SequenceFormatTFA $SeqOliN $EnteteOliSeq "brut"]
	Espionne $TFA
	AppendAuFichier $FicOli $TFA

	if {$ReverseAussi} {
	    set SeqRaC [NucToReverseAndComplementNuc $SeqOliN]
	    set EnteteRaC "SeqOliRaC_$NomDeLOligo sequencing oligoRaC for $PAB $Alias $DOli3 to $FOli3"
	    set TFARaC [SequenceFormatTFA $SeqRaC $EnteteRaC "nucbrut"]
	    AppendAuFichier $FicOli $TFARaC
	}

	incr DOli $LongVoulue
    }
    while {[OuiOuNon "Do you want to verify or remove some sequencing oligos"]} {
	set Nouveau [AfficheFichier $FicOli "AvecRetour"]
	set N [regexp -all {>} $Nouveau]
	if {[OuiOuNon "Do I save these $N oligos in $FicOli?"]} {
	    Sauve $Nouveau dans $FicOli
	    break
	}
    }
    return $FicOli
}

proc TypeDeVecteurGatewayPourTous {} {
    foreach Vecteur [LesVecteurs] {
	Espionne "[TypeDeVecteurGateway $Vecteur] $Vecteur"
    }
}

proc TypeDeVecteurGateway Vecteur {
    if {$Vecteur==""} { return 0 }
    if {[regexp "/" $Vecteur]} {
	set Fichier $Vecteur
    } else {
	set Fichier [FindVector $Vecteur]
	if {[FileAbsent $Fichier]} { return 0 }
    }
    set Seq [QueLaSequenceDuFichierTFA $Fichier]

    if {[regexp -nocase [SEQAttL1] $Seq] && [regexp -nocase [SEQAttL2] $Seq]} { return 1 }
    if {[regexp -nocase [SEQAttR1] $Seq] && [regexp -nocase [SEQAttR2] $Seq]} { return 2 }
    return 0
}

proc LesVecteurs {{VecType ""} {GetThem ""}} {

    if {$VecType==""} { set VecType "pDONR_pDEST" }

    if {$GetThem==""} { set GetThem "GetFilenames" }
    set GetFilenames [string equal -nocase $GetThem "GetFilenames"]
    set GetNames     [string equal -nocase $GetThem "GetNames"]

    set LesPossible {}
    if {[regexp "pDONR" $VecType]} { LConcat LesPossibles [LesFichiersDeType "pDONR" "" "GetAll"] }
    if {[regexp "pDEST" $VecType]} { LConcat LesPossibles [LesFichiersDeType "pDEST" "" "GetAll"] }
    if {$GetNames} {
	set LesNames {}
	foreach F $LesPossibles {
	    set Name [file tail $F]
	    regsub {\.tfa} $Name "" Name
	    lappend LesNames $Name
	}
	return $LesNames
    }
    if {$GetFilenames} { return $LesPossibles }
}

proc InventaireDesVecteurs {{VecType ""}} {
    set LesPossibles [LesVecteurs $VecType "GetFilenames"]
    return [AfficheVariable [join $LesPossibles "\n"] "AvecShow" "${VecType}_Vectors"]
}

proc OlIgbmc {P {Val ""}} {
    global OlIgbmc

    set FichierOlIgbmc "[RepertoireDuGenome]/fiches/oligbmc"

    if {$P=="Save"} {
	if {[info exists OlIgbmc("EstCharge")]} { unset OlIgbmc("EstCharge") }
	if {[info exists OlIgbmc(ListeDesPs)]}  { unset OlIgbmc(ListeDesPs) }
	if {[info exists OlIgbmc(ListeDesIGBMCs)]}  { unset OlIgbmc(ListeDesIGBMCs) }
	SauveLesLignes [array get OlIgbmc] dans $FichierOlIgbmc
	catch {unset OlIgbmc}
	OlIgbmc "Load"
	return $FichierOlIgbmc
    }

    if {$Val!=""} { set OlIgbmc($P) $Val ; lappend OlIgbmc(ListeDesPs) $P ; return $Val }

    if {[info exists OlIgbmc($P)]}          { return [set OlIgbmc($P)] }
    if {[info exists OlIgbmc("EstCharge")]} { return [set OlIgbmc("EstCharge")] }


    if { ! [file exists $FichierOlIgbmc]} { set OlIgbmc("EstCharge") "NoValueAvailable" }
    array set OlIgbmc [LesLignesDuFichier $FichierOlIgbmc]

    foreach {P IGBMC} [array get OlIgbmc] {
	lappend OlIgbmc(ListeDesPs)  $P
	lappend OlIgbmc(ListeDesIGBMCs) $IGBMC
    }
    set OlIgbmc("EstCharge") ""
    
    return [OlIgbmc $P]
}

proc LesPpcrDesPs {} {
    foreach P [P5ofPPCR "LaListeDesPs"] {
	Espionne "$P"
    }
    exit
}

proc TousLesSegmentsConsecutifs {Liste {JoinCar "\n"}} {
    set LL [llength $Liste]
    set LesSegments {}
    foreach N [NombresEntre 1 $LL] {
	foreach D [NombresEntre 0 [expr $LL-$N]] {
	    set F [expr $D+$N-1]
	    set W [lrange $Liste $D $F]
	    lappend LesSegments [join $W $JoinCar]
	}
    }
    return $LesSegments
}

proc AfficheFournisseur Selection {
    if {[regexp "\n" $Selection]} {
	foreach Ligne $Selection {
	    AfficheFournisseur $Ligne
	}
	return ""
    }
    if { ! [regexp {P[0-9]+} $Selection P]} { return "" }
    set Fournis [Fournisseur $P]
    if {$Fournis==""} {
	return [AfficheVariable "Sorry. No order file was found for $P" "" "OrderFileOf_$P"]
    }
    scan $Fournis "%s %s" Lieu Fichier
    set Page "$Fichier\n$Lieu"
    if {[file exists $Fichier]} { append Page "\n[ContenuDuFichier $Fichier]" }
    set Fen [AfficheVariable $Page "AvecOli" "OrderFileOf_$P"]
    Illumine $P $Fen
    return $Fen
}

proc Fournisseur {P {Val ""}} {
    global Fournisseur

    if {$Val!=""} {
	if { ! [info exists Fournisseur($P)]} {
	    set Fournisseur($P) $Val
	    lappend Fournisseur(LaListeDesPs) $P
	} else {
	    append Fournisseur($P) $Val
	}
	return [set Fournisseur(LaListeDesPs)]
    }

    if {[info exists Fournisseur($P)]} { return [set Fournisseur($P)] }
    if {[info exists Fournisseur("EstCharge")]} { return "" }

    set Fournisseur("EstCharge") 1
    array set Fournisseur [LesLignesDuFichier "[RepertoireDuGenome]/fiches/fournisseur"]
    foreach PLu [array names Fournisseur] {
	scan [set Fournisseur($PLu)] "%s" Fournis
	lappend Fournisseur($Fournis) $PLu
	lappend Fournisseur(LaListeDesPs) $PLu
    }
    return [Fournisseur $P]
}

proc ShowBlastOfOligo Selection {
    if {[regexp "\n" $Selection]} {
	foreach Ligne $Selection {
	    ShowBlastOfOligo $Ligne
	}
	return ""
    }
    if { ! [regexp {P[0-9]+} $Selection P]} { return "" }
    set FB "[RepertoireDuGenome]/blastnoligo/$P"
    if {[file exists $FB]} {AfficheFichier $FB "AvecSegAlignement"}
    set FB "[RepertoireDuGenome]/blastnAllProGS/$P"
    if {[file exists $FB]} {AfficheFichier $FB "AvecSegAlignement"}
}

proc ChercheLesOligosDoubles {} {
    foreach P [Oli "LaListeMerci"] {
	set Seq [string toupper [Oli $P Seq]]
	if {[info exists DejaVu($Seq)]} {
	    lappend DejaVu($Seq) "$P [Oli $P Description]"
	    Espionne "\n[join [set DejaVu($Seq)] "\n"]"
	} else {
	    lappend DejaVu($Seq) "$P [Oli $P Description]"
	}
    }
    exit
}

proc MemeAlias {AliasDuSujet AliasDuPGS} {
    if {$AliasDuSujet==""} { return 1 }
    set LesBonsCouples [list \
	    "XPDhs p80hs" \
	    "NURR1 hNURR1" \
	    "ITK SH1-ITK" \
	    "LXRb hLXRb" \
	    "hCOUP-TFIIH hCOUP-TFII" \
	    "hsTFIIEA TF2EAHS" \
	    "SSL1 YLR005WSSL1" \
	    "TFB1 YDR311WTFB1" \
	    "RARa HRARA"]
    if {[lsearch -exact $LesBonsCouples "$AliasDuSujet $AliasDuPGS"]} { return 1 }
    return [string equal -nocase $AliasDuSujet $AliasDuPGS]
}

proc EstUnPABMute PAB {
    return [regexp {^mutation of } [ExtraitInfo $PAB "Muted"]]
}

proc NomDuFichierDesOligosPourMutation FicOli {
    set FicOliOriginal $FicOli
    set Prem 1
    while {$Prem || $FicOli==""} {
	set Prem 0
	FaireLire "Please choose a file to store the oligos I'll create."
	set Rep [file dirname $FicOli]
	set Queue [file tail $FicOli]
	if { ! [regexp ".tfa$" $Queue]} {
	    regsub {\.[^.]+$} $Queue "" Queue
	    append Queue ".tfa"
	}
	set FicOli "$Rep/olimut_$Queue"
	set FicOli [FichierPourSaveAs $FicOli]
	if {$FicOli==""} {
	    if {[OuiOuNon "Do I skip creation of oligos ?"]} {return ""}
	    set FicOli $FicOliOriginal
	    set Prem 1
	}
    }
    while {[file exists $FicOli]} {
	if {[OuiOuNon "$FicOli\nalready exists. Do I append to it ?"]} { return $FicOli }
	if {[OuiOuNon "$FicOli\nalready exists. Do I replace it ?"]} {
	    file delete -force $FicOli
	    return $FicOli
	}
	if {[OuiOuNon "$FicOli\nalready exists.	Do I skip creation of oligos ?"]} {
	    return ""
	}
	if {[OuiOuNon "$FicOli\nalready exist. Do You want to change it ?"]} {
	    return [NomDuFichierDesOligosPourMutation $FicOli]
	}
    }
    return $FicOli
}

proc CreateOligosForMutation {FichierOuTexteOliMut {FicOli ""} {ReverseAussi ""}} {
    JeMeSignale
    if {$ReverseAussi==""} { set ReverseAussi "ReverseAussi" }
    if {$ReverseAussi=="SansReverse" || $ReverseAussi==0 } { set ReverseAussi 0 } else { set ReverseAussi 1 }
 
    global DefaultLengthes
    set SuperDefaultLengthes "5 5 15 15 (AA before, AA after, bases before, bases after)"

    if {[OuiOuNonMemo "Do you want to change the default length of 5' and 3' extensions of the mutation oligos ?" ]} {
	if { ! [info exists DefaultLengthes]} { set DefaultLengthes [Entre $SuperDefaultLengthes] }
    } else {
	set DefaultLengthes $SuperDefaultLengthes
    }

    ScanLaListe $DefaultLengthes NbAAsAvant NbAAsApres NbBasesAvant NbBasesApres

    if {$FichierOuTexteOliMut==""} { return "" }
    if {[regexp "\n" $FichierOuTexteOliMut]} {
	if {$FicOli==""} {
	    set FicOli [NomDuFichierDesOligosPourMutation "./mutationoligos.tfa"]
	    if {$FicOli==""} { return "" }
	}
	set Texte $FichierOuTexteOliMut
	set LesOligos {}
	foreach Ligne [split $Texte "\n"] {
	    if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	    CreateOligosForMutation $Ligne $FicOli $ReverseAussi
	}
	return $FicOli
    }
    if { ! [regexp " " $FichierOuTexteOliMut]} {
	set Fichier $FichierOuTexteOliMut
	if {[file exists $Fichier]} {
	    set FicOli [NomDuFichierDesOligosPourMutation $Fichier]
	    if {$FicOli==""} { return "" }
	    return [CreateOligosForMutation [ContenuDuFichier $Fichier] $FicOli $ReverseAussi]
	}
	FaireLire "$FichierOuTexteOliMut\ndoesn't exist. I'll cancel CreateOligosForMutation"
	return [list "No mutation oligo for ($FichierOuTexteOliMut) which doesn't exist"]
    }

    if {$FicOli==""} { set FicOli [NomDuFichierDesOligosPourMutation ""] }
    if {$FicOli==""} { return "" }

    set Ligne $FichierOuTexteOliMut
    scan $Ligne "%s %s" PAB PABMute

    set FicNucTFA "[RepertoireDuGenome]/nuctfa/$PABMute"
    if { ! [file exists $FicNucTFA]} {
	FaireLire "$FicNucTFA\ndoesn't exists. I'll skip CreateOligosForMutation $Ligne"
	return [list "No mutation oligo for ($FichierOuTexteOliMut) $FicNucTFA doesn't exist"]
    }
    set ToutSeqNuc [QueLaSequenceDuFichierTFA $FicNucTFA]
    set MaxP [expr [string length $ToutSeqNuc]/3]

    set LesCodes [lrange [split [string trim $Ligne] " "] 2 end]
    set Extension [lindex $LesCodes end]
    if { ! [regexp -nocase  {^[a-z]} $Extension]} {
	set LesCodes [lrange $LesCodes 0 end-1]
    } else {
	set Extension ""
    }
    Espionne "\n\n$LesCodes  extension $Extension"
    set LesCoOrdonnes {}
    foreach Code $LesCodes {
	if { ! [regexp -nocase {[a-z]} $Code]} { continue }
#	regsub {[0-9]+} [string toupper $Code] " & " Coco
	regsub {[0-9]+} $Code " & " Coco
	scan $Coco "%s %d %s" AncienP PosAncienP NouveauP
	set LongAncienP [string length $AncienP]
	lappend LesCoOrdonnes "$AncienP $PosAncienP $NouveauP"
    }
    set LesCoOrdonnes [lsort -increasing -integer -index 1 $LesCoOrdonnes]
    set Decalage 0
    set LesVraiesPositionsDebut {}
    set LesVraiesPositionsApres {}
    foreach Co $LesCoOrdonnes {
	scan $Co "%s %d %s" AncienP PosAncienP NouveauP
	set Code "$AncienP$PosAncienP$NouveauP"
	set MutationDeNucleotides [regexp {[a-z]} $Code]
	if {$MutationDeNucleotides} {
	    if { ! [OuiOuNon "I see lowercase letters in $Code!\nOk to mutate nucleotides ?"]} {
		FaireLire "I'll skip $Code"
		continue
	    }
	}
	set PosAncienP [expr $PosAncienP+$Decalage]
	regsub -all -nocase "X" $AncienP  "" VraiAncienP
	regsub -all -nocase "X" $NouveauP "" VraiNouveauP
	set Decalage [expr [string length $VraiNouveauP]-[string length $VraiAncienP]]
	set VraiePositionDebut       $PosAncienP
	set VraiePositionApres [expr $PosAncienP+[string length $VraiNouveauP]]
	lappend LesVraiesPositionsDebut $VraiePositionDebut
	lappend LesVraiesPositionsApres $VraiePositionApres
	if {$MutationDeNucleotides} {
	    set DebN [Maxi 1 [expr $VraiePositionDebut - $NbBasesAvant]]
	    set FinN [Mini   [expr $VraiePositionApres + $NbBasesApres] [expr $MaxP*3]]
	} else {
	    set DebP [Maxi 1 [expr $VraiePositionDebut    - $NbAAsAvant]]
	    set FinP [Mini   [expr $VraiePositionApres -1 + $NbAAsApres] $MaxP]
	    set DebN [expr ($DebP-1)*3     + 1]
	    set FinN [expr ($FinP-1)*3 + 2 + 1]
	}
	set SeqNuc [string range $ToutSeqNuc [expr $DebN - 1] [expr $FinN - 1]]
	set AvecSubRegion [OuiOuNonMemo "Do you want to take a subregion of these mutation oligos ?" 0]
	if {$AvecSubRegion} {
	    set SeqNucOriginal $SeqNuc
	    set DebNOriginal $DebN
	    set FinNOriginal $FinN
	    while 1 {
		FaireLire "For $PABMute $Code\nPlease insert 2 spaces to indicate where to cut (0 to keep full seq)" 
		set SeqNucCutted [Entre $SeqNucOriginal]
		set i1 [string first " " $SeqNucCutted]
		set i2 [string last  " " $SeqNucCutted]
		if {$i1==-1 || $i2==-1} {
		    if {[OuiOuNon "Do we cancel cutting for this oligo ?"]} {break}
		    FaireLire "Please insert 2 or 0 spaces"
		    continue
		}
		set NouveauDebutN [expr $DebN + $i1]
		set NouveauFinN   [expr $FinN - ([string length $SeqNucCutted]-$i2-1)]
		if {[expr ($NouveauFinN - $NouveauDebutN)<10]} {
		    FaireLire "You cut to much ... We redo cutting."
		    continue
		}
		set DebN $NouveauDebutN
		set FinN $NouveauFinN
		set SeqNuc [string range $ToutSeqNuc [expr $DebN - 1] [expr $FinN - 1]]
		set AvecSubRegion 1
		break
	    }
	}
	set SeqPro [SeqNucToSeqPro $SeqNuc]
	regsub -all "." $SeqPro "&  " SeqPro3
	Espionne "$SeqNuc\n$SeqPro3"
	set Entete ""
	set Alias [Alias $PABMute]
	if {$Alias==""} { set Alias $PABMute }
	set AliasCode "$Alias"
	if { ! [regexp "$Code$" $AliasCode]} { append AliasCode "-$Code" }
	if {$AvecSubRegion} { set AliasCode [Entre $AliasCode] }
	set Entete "MutOli_$AliasCode mutation oligo for $PABMute $Alias $Code $DebN $FinN"
	set TFA [SequenceFormatTFA $SeqNuc $Entete "nucbrut"]
	AppendAuFichier $FicOli $TFA
	if {$ReverseAussi} {
	    if {$AvecSubRegion} {
		while 1 {
		    FaireLire "For the REVERSE sequence\n$PABMute $Code\n Please insert 2 spaces to indicate where to cut" 
		    set SeqNucCutted [Entre $SeqNucOriginal]
		    set i1 [string first " " $SeqNucCutted]
		    set i2 [string last  " " $SeqNucCutted]
		    if {$i1==-1 || $i2==-1} {
			if {[OuiOuNon "Do we cancel cutting for this oligo ?"]} {break}
			FaireLire "Please insert 2 or 0 spaces"
			continue
		    }
		    set NouveauDebutN [expr $DebNOriginal + $i1]
		    set NouveauFinN   [expr $FinNOriginal - ([string length $SeqNucCutted]-$i2-1)]
		    if {[expr ($NouveauFinN - $NouveauDebutN)<10]} {
			FaireLire "You cut to much ... We redo cutting."
			continue
		    }
		    set DebN $NouveauDebutN
		    set FinN $NouveauFinN
		    set SeqNuc [string range $ToutSeqNuc [expr $DebN - 1] [expr $FinN - 1]]
		    set SeqPro [SeqNucToSeqPro $SeqNuc]
		    regsub -all "." $SeqPro "&  " SeqPro3
		    Espionne "$SeqNuc\n$SeqPro3"
		    break
		}
	    }
	    if {$AvecSubRegion} { set AliasCode [Entre $AliasCode] }
	    set SeqRaC [NucToReverseAndComplementNuc $SeqNuc]
	    set EnteteRaC "MutOliRac_$AliasCode mutation oligoRac for $PABMute $Alias $Code $DebN $FinN"
	    set TFARaC [SequenceFormatTFA $SeqRaC $EnteteRaC "nucbrut"]
	    AppendAuFichier $FicOli $TFARaC
	}
    }
    return $FicOli
}

proc AffichePof {{Quoi ""}} {
    if {$Quoi==""} { set Quoi "PofOl_PofPPCR_PofMut_PofSeq" }
    set Retour {}
    if {[regexp "AllPs" $Quoi]} {
	set LesPofOl  [PofOl  "LesPofOl"]
	set LesPofMut [PofMut "LesPofMut"]
	set LesPofSeq [PofSeq "LesPofSeq"]
	set LesPs [lsort [concat $LesPofOl $LesPofMut $LesPofSeq]]
	foreach TextP $LesPs {
	    scan $TextP "%s" P
	    set DejaVu($P) 1
	}
	foreach P [Oli "LaListeMerci"] {
	    if {[info exists DejaVu($P)]} { continue }
	    lappend LesPs [Oli $P "AllOnOneLine"]
	}

	set FO [AfficheListe $LesPs "AvecOliAvecFiOl" "PofOl_PofMut_PofSeq"]
	lappend Retour $FO
    }
    if {[regexp "PofOl" $Quoi]} {
	set FO [AfficheListe [PofOl  "LesPofOl"] "AvecOliAvecFiOl" "PofOligos"]
	lappend Retour $FO
    }
    if {[regexp "PofMut" $Quoi]} {
	set FO [AfficheListe [PofMut "LesPofMut"] "AvecOliAvecFiOl" "PofMutation"]
	lappend Retour $FO
    }
    if {[regexp "PofSeq" $Quoi]} {
	set FO [AfficheListe [PofSeq "LesPofSeq"] "AvecOliAvecFiOl" "PofSequencing"]
	lappend Retour $FO
    }
    if {[regexp "PofPPCR" $Quoi]} {
	set FP [AfficheListe [PofPPCR "5_3"]      "AvecOliAvecFiPPCR" "PofPPCR"]
	lappend Retour $FP
    }
    return $Retour
}

proc InventaireDesMatrices {} {
    return [AfficheFichier "[RepertoireDuGenome]/fiches/matrices_of_oligos" "AvecOli"]
}

proc DontCreateAllOligos {} {
    global DontCreateAllOligos
    set DontCreateAllOligos [OuiOuNonMemo "Do I ask each time to remove some oligos ?" 0]
}

proc ShowVirtualPPCR {Selection {Action ""}} {
    global ActionShowVirtualPPCR

    if { ! [info exists ActionShowVirtualPPCR]} { set ActionShowVirtualPPCR "All" }
    if {$Action==""} { set Action $ActionShowVirtualPPCR }
 
    if {[regexp "\n" $Selection]} {
	foreach Sel [split $Selection "\n"] {
	    ShowVirtualPPCR $Sel $Action
	}
	return
    }
    if {[regexp {>(N[0-9]+) } $Selection Match N]} {
	return [ShowVirtualPPCR $N $Action]
    }

    if {$Action=="Choose"} {
	set Action [ChoixParmi [VirtualPPCREnStock "LesQuois"]]
    }
    if {$Action==""} { return "" }
    set ActionShowVirtualPPCR $Action

    set N ""
    foreach NPossible [split $Selection " "] {
	if {[regexp {^N[0-9]+$} $NPossible]} { set N $NPossible ; break}
    }
    if {$N==""} { return "" }

    if {$Action=="All"} {
	set LesInfos {}
	foreach A [VirtualPPCREnStock "LesQuois"] {
	    lappend LesInfos "\n$A :\n[VirtualPPCREnStock $N $A]"
	}
	set Info [join $LesInfos "\n"]
    }  else {
	set Info "[VirtualPPCREnStock $N $Action]"
    }
    set Texte $Info
    set Fen [AfficheVariable $Texte "AvecFormateAvecBlasteAvecVirtualPPCRAvecOli" $N]
    return $Fen
}

proc AfficheVirtualPPCR {} {
    set Page [join [VirtualPPCREnStock LesResumes] "\n"]
    set LesQuois [VirtualPPCREnStock LesQuois]
    return [AfficheVariable $Page "AvecVirtualPPCR" AllVirtualPPCRs]
}

proc SequenceSansOligosDuVirtualPPCR N {
    set Seq [VirtualPPCREnStock $N "Seq"]
    set P5  [VirtualPPCREnStock $N "P5"]
    set P3  [VirtualPPCREnStock $N "P3"]

    set S5 [Oli $P5 "SeqSignals"]
    set S3 [NucToReverseAndComplementNuc [Oli $P3 "SeqSignals"]]

    if { ! [regexp -nocase $S5 $Seq]} { FaireLire "Error I can't find $P5 in virtualPPCR $N" }
    if { ! [regexp -nocase $S3 $Seq]} { FaireLire "Error I can't find $P3 in virtualPPCR $N" }

    set SeqSujet $Seq
    regsub -nocase "^$S5" $SeqSujet "" SeqSujet
    regsub -nocase "$S3$" $SeqSujet "" SeqSujet

    return $SeqSujet
}

proc VirtualPPCREnStock {N {Quoi ""}} {
    global VirtualPPCREnStock

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

    if {$Quoi=="LesRec1"}         { return [Rec1 $N LesRec1] }
    if {$Quoi=="LesFichiersRec1"} { return [Rec1 $N LesFichiers] }

    set RepDesVirtualPPCR "[RepertoireDuGenome]/ppcr_virtuels"
    if { ! [info exists VirtualPPCREnStock("EstCharge")]} { 
	set VirtualPPCREnStock("EstCharge") 1
	set LesResumes {}
	set LesQuois {}
	set VirtualPPCREnStock(LaListeDesNs) {}
	foreach Fichier [glob -nocomplain "$RepDesVirtualPPCR/N*"] {
	    set Queue [file tail $Fichier]
	    if {[regexp {~$|\.20[0-9]{4,}$} $Queue]} { continue }
	    set Entete [EnteteDuFichierTFA $Fichier]
	    scan $Entete "%s %s %s %s %s %s %s %s %s" Nlu ppcr for PGS Sujet with oligos P5 P3
	    if { ! [regexp "^>" $Nlu]} { continue }
	    regsub ">" $Nlu "" Nlu
	    lappend VirtualPPCREnStock(LaListeDesNs) $Nlu 
	    set FullName [StringSuivant "FN: " dans $Entete]
#???	    lappend VirtualPPCREnStock(N,$FullName) $Nlu
	    set VirtualPPCREnStock($Nlu,FullName) $FullName
	    set VirtualPPCREnStock($Nlu,PGS) $PGS
	    set VirtualPPCREnStock($Nlu,Sujet) $Sujet
	    set VirtualPPCREnStock($Nlu,P5)  $P5
	    set VirtualPPCREnStock($Nlu,P3)  $P3
	    set VirtualPPCREnStock($Nlu,File) $Fichier
	    set Resume "$Nlu $PGS [format "%-13s" [Alias $PGS]] $P5 $P3   $FullName"
	    set VirtualPPCREnStock($Nlu,Resume) $Resume
	    lappend LesResumes $Resume
	}
	set LesQuois {}
	lappend LesQuois "Resume" "FullName" "PGS" "P5" "P3" "Seq" "SeqSubject" "TFA" "File"
	lappend LesQuois "LesRec1" "LesFichierRec1" 
	set VirtualPPCREnStock(LesQuois)   $LesQuois
	set VirtualPPCREnStock(LesResumes) $LesResumes
    }
    
    if {$N=="LaListeDesNs"}   { return [set VirtualPPCREnStock(LaListeDesNs)] }
    if {$N=="LesQuois"}       { return [set VirtualPPCREnStock(LesQuois)] }
    if {$N=="LesResumes"}     { return [set VirtualPPCREnStock(LesResumes)] }

    if {$Quoi==""} { set Quoi "TFA" }
    if { ! [info exists VirtualPPCREnStock($N,FullName)]} { return "" }
    if {$Quoi=="TFA"} { return [ContenuDuFichier "$RepDesVirtualPPCR/$N"] }
    if {$Quoi=="Seq"} { return [QueLaSequenceDuFichierTFA "$RepDesVirtualPPCR/$N"] }
    if {$Quoi=="SeqSubject"} { return [SequenceSansOligosDuVirtualPPCR $N] }

    if {[info exists VirtualPPCREnStock($N,$Quoi)]} { return [set VirtualPPCREnStock($N,$Quoi)] }
}

proc TestNewVirtualPPCR {} {
    set PPCR "GFP-1-239 +++ AttB1 XhoI +++ XhoI AttB2"
    AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFaire
    Espionne [NewVirtualPPCR $PPCR "PGS311" "GFP-1-239"]
    Espionne [NewVirtualPPCR $PPCR "PGS311" "GFP-1-239"]
    exit
}

proc NewVirtualPPCR {PPCR {PGS ""} {Sujet ""}} {
    global NewVirtualPPCR

    JeMeSignale

    if {0} {
	set Alias [Alias $PGS]
	regsub -all {\-} $Alias "\\\-" XAlias
	if { ! [regexp $XAlias $Sujet]} {
	    FaireLire "l'alias de $PGS $Alias n'est pas dans le sujet $Sujet"
	}
    }

    set RepDesVirtualPPCR  "[RepertoireDuGenome]/ppcr_virtuels"
    if {$PPCR=="Load"} {
	set nMax 1000
	foreach Nlu [VirtualPPCREnStock "LaListeDesNs"] {
	    set FullName [VirtualPPCREnStock $Nlu "FullName"]
	    lappend NewVirtualPPCR($FullName)  $Nlu
	    regsub -all {[^0-9]} $Nlu "" Numero
	    set n [Base10 $Numero]
	    set nMax [Maxi $nMax $n]
	}
	set NewVirtualPPCR(LastNumber) $nMax
	set NewVirtualPPCR("EstCharge") 1
	return
    }
    
    if { ! [info exists NewVirtualPPCR("EstCharge")]} { NewVirtualPPCR "Load" }

    set P5 [P5ofPPCR $PPCR]
    set P3 [P3ofPPCR $PPCR]
Espionne $PGS
    set A5 [BaClon Trio $PGS $Sujet $P5]
    set A3 [BaClon Trio $PGS $Sujet $P3]
    
    set N5 [expr ($A5-1)*3+1]
    set N3 [expr ($A3-1)*3+3]

    set AskForDummy 0
    set Dummy 0
    Espionne "I got P5=$P5 P3=$P3 A5=$A5 A3=$A3 N5=$N5 N3=$N3"
    if {$P5=="" || $P3=="" || $A5=="" || $A3=="" || $N3<$N5 } {
	if {$AskForDummy && [OuiOuNon "There is a problem with NewVirtualPPCR $PPCR $PGS $Sujet \n \
		I got P5=$P5 P3=$P3 A5=$A5 A3=$A3 N5=$N5 N3=$N3 \n \
		Do I create a dummy PPCR (if NO I'll cancel)?" 0]} {
	    set Dummy 1
	} else {
	    return ""
	}
    } 

    set FiNuc "[RepertoireDuGenome]/nuctfa/$PGS"
    set SeqPGS [ZoneADNDuFichierTFA $N5 $N3 $FiNuc]

    set SeqAv [Oli $P5 SeqSignals]
    set SeqAp [NucToReverseAndComplementNuc [Oli $P3 SeqSignals]]

    set SeqPPCR "$SeqAv$SeqPGS$SeqAp"
    regsub -all -nocase {[^a-z]} $SeqPPCR "" SeqPPCR
    if { ! [info exists NewVirtualPPCR(LastNumber)]} { set NewVirtualPPCR(LastNumber) 1000 }
    set n [set NewVirtualPPCR(LastNumber)]
    incr n
    set Nppcr [format "%s%4.4d" "N" $n]

    set FullName "$PGS $Sujet ppcr: $PPCR"
    Espionne "FullName $FullName"
    if {! $Dummy && [info exists NewVirtualPPCR($FullName)]} {
	Espionne "Old VirtualPPCR $PPCR $PGS $Sujet I got P5=$P5 P3=$P3 A5=$A5 A3=$A3 N5=$N5 N3=$N3"
	foreach OldN [set NewVirtualPPCR($FullName)] {
	    set FichierOldN "$RepDesVirtualPPCR/$OldN"
	    Espionne $FichierOldN
	    if {[file exists $FichierOldN]} {
		set SeqOldN [QueLaSequenceDuTFA $FichierOldN]
		if {[string equal -nocase $SeqPPCR $SeqOldN]} {
		    return "$OldN same already existed"
		}
		VoisinADN ">TheOldPPCR_$OldN\n$SeqOldN\n>TheNewPPCR_$Nppcr\n$SeqPPCR"
		AfficheVariable "During creation of $Nppcr I detect that following equivalent \n\
			Ppcr [set NewVirtualPPCR($FullName)] from $FullName\nalready exist\n\
			Please compare Old with New in the other window\
			Then I'll ask you what to do." "AvecRetour"
		set GardeVieux 1
		if {[OuiOuNon "Do I delete the old $OldN replacing it with $Nppcr ?"]} {
		    if {[OuiOuNon "Ok to delete the file \n$FichierOldN\n\
			    Don't worry if  I 'll speak again about $OldN in this process,\n \
			    I can't forget so easely this old boy $OldN ..." ]} {
			file delete $FichierOldN
			set GardeVieux 0
		    }
		}
		if {$GardeVieux && [OuiOuNon "Do I cancel creation of $Nppcr ?"]} { return "$OldN different but I keep it" }
	    }
	}
    }
    set Entete "$Nppcr Ppcr for $PGS $Sujet with oligos $P5 $P3 FN: $FullName"
    if {$Dummy} {
	regsub "Ppcr" $Entete "DUMMY Ppcr" Entete
	set SeqPPCR "ATGTGA"
    }
    set TFA [SequenceFormatTFA $SeqPPCR $Entete "nucbrut"]
    Espionne "NewVirtualPPCR $PPCR $PGS $Sujet I got P5=$P5 P3=$P3 A5=$A5 A3=$A3 N5=$N5 N3=$N3"
    if { ! [file exists $RepDesVirtualPPCR]} { file mkdir $RepDesVirtualPPCR }
    Sauve $TFA dans "$RepDesVirtualPPCR/$Nppcr"
    set NewVirtualPPCR(LastNumber) $n
    lappend NewVirtualPPCR($FullName)  $Nppcr
    return $Nppcr
}

proc OligoEnStock Seq {
    global OligoEnStock

    if {$Seq=="Reload"} {
	if {[info exists OligoEnStock]} { unset OligoEnStock }
	set Seq "LaListeMerci"
    }

    set Seq [string toupper $Seq]

    if {[info exists OligoEnStock($Seq)]} { return [set OligoEnStock($Seq)] }
    if {[info exists OligoEnStock(LALISTEMERCI)]} { return {} }

    set OligoEnStock(LALISTEMERCI) [Oli LaListeMerci]
    foreach P [set OligoEnStock(LALISTEMERCI)] {
	set SeqOli [string toupper [Oli $P]]
	lappend OligoEnStock($SeqOli) $P
    }
    return [OligoEnStock $Seq]
    
    
}

proc MutateSequencesListedIn {FichierOuListeOuLigne} {
    if { ! [regexp " " $FichierOuListeOuLigne]} {
	set LesLignes [LesLignesDuFichier $FichierOuListeOuLigne]
    } else {
	if {[regexp " " [lindex $FichierOuListeOuLigne 0]]} {
	    set LesLignes $FichierOuListeOuLigne
	} else {
	    set LesLignes [list $FichierOuListeOuLigne]
	}
    }
    set LesMutes {}
    foreach Ligne $LesLignes {
	if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
	scan $Ligne "%s %s" PAB PABMute
	set LesCodes [lrange [LesMotsDeLaLigne $Ligne] 2 end]
	set Extension [lindex $LesCodes end]
	if { ! [regexp -nocase  {^[a-z]} $Extension]} {
	    set LesCodes [lrange $LesCodes 0 end-1]
	} else {
	    set Extension ""
	}

	Wup "We replace * the coding of STOP by O which is not used as aa code" 
	set LesCodesSansEtoile {}
	foreach Code $LesCodes {
	    if {[regexp {\*} $Code]} {
		regsub -all {\*} $Code "O" Code
	    }
	    lappend LesCodesSansEtoile $Code
	}
	set LesCodes $LesCodesSansEtoile

	Espionne "$LesCodes  extension=>$Extension<"
	set CodeDeMutation [join $LesCodes " "]
	lappend LesMutes [MutateSequence $PAB $CodeDeMutation $Extension $PABMute]
    }
    return [join $LesMutes "\n"]
}

proc MutateSequence {{PAB ""} {CodeDeMutation ""} {Extension ""} {PABMute ""}} {
    while {$PAB==""} {
	FaireLire "Please enter the [PreFixe] to mutate."
	set PAB [Entre "[PreFixe]"]
	if {[EstUnPAB $PAB]} { break }
	if {$PAB=="" && [OuiOuNon "Do I cancel MutateSequence ?"]} { return "" }
    }

    if {$CodeDeMutation==""} {
	FaireLire "Please enter the codes for mutation\n\
		\nF602E\nF602AP S455T R665W\nF602X\nF602*\nFPA602RW\nX55FRAP\n..."
	set CodeDeMutation [Entre "F602E"]
    }
    if {$PABMute==""} {
	regsub -nocase -all {[A-Z]} $PAB "" Numero
	set Numero [Base10 $Numero]
	set NumeroMute [expr $Numero+1000]
	set PABMute [format "%s%3.3d" [PreFixe] $NumeroMute]
	while { ! [OuiOuNon "Do I use $PABMute as mutant name"]} {
	    set PABMute [Entre $PABMute]
	}
    }
    set FichierNucTfaMute "[RepertoireDuGenome]/nuctfa/$PABMute"
    set FichierProtTfaMute "[RepertoireDuGenome]/prottfa/$PABMute"
    set OldPABMute ""
    while {[file exists $FichierNucTfaMute]} {
	FaireLire "A mutant of $PAB already exists ($PABMute)\n\
		Please enter an other number. \n\
		(or the same to overwrite; or an empty string to skip)"
	set OldPABMute $PABMute
	set PABMute [Entre $PABMute]
	if {$PABMute==""          && [OuiOuNon "Do I skip creation of $PABMute ?"]} { return "" }
	if {$PABMute==$OldPABMute && [OuiOuNon "Do I replace the existing $PABMute"]} { break }
	set FichierNucTfaMute  "[RepertoireDuGenome]/nuctfa/$PABMute"
	set FichierProtTfaMute "[RepertoireDuGenome]/prottfa/$PABMute"
    }

    set Alias [Alias $PAB]
    if {[regexp "^=" $Extension]} {
	set AliasMute $Extension
    } else {
	if {$Extension==""} {
	    set Extension $CodeDeMutation
	    regsub " " $Extension "-" Extension
	    set Extension "-$Extension"
	}
	if {$Extension=="-DontModifyAlias"} {
	    set AliasMute $Alias
	} else {
	    set AliasMute "$Alias$Extension"
	}
    }

    set FichierNucTfa "[RepertoireDuGenome]/nuctfa/$PAB"
    set Seq [QueLaSequenceDuFichierTFA $FichierNucTfa]
    set SeqMute [Mute $CodeDeMutation $Seq]
    set Entete [EnteteDuFichierTFA $FichierNucTfa]
    set Access [EnteteDuFichierTFA $FichierNucTfa "access"]
    regsub $Access $Entete "$AliasMute muted $CodeDeMutation of" EnteteMute
    set TFA [SequenceFormatTFA $SeqMute $EnteteMute "nucbrut"]
    Sauve $TFA dans $FichierNucTfaMute

    set FichierProtTfa "[RepertoireDuGenome]/prottfa/$PAB"
    set SeqProt [SeqNucToSeqPro $SeqMute]
    set TFAProt [SequenceFormatTFA $SeqProt $EnteteMute "protbrut"]
    Sauve $TFAProt dans $FichierProtTfaMute

    if {$Extension=="-DontModifyAlias"} {
	InformeSansDemander $PABMute "=CopyOf_$PAB"
	InformeSansDemander $PABMute "=Corrected: correction of $PAB $Alias $CodeDeMutation"
    } else {
	InformeSansDemander $PABMute "=Alias: $AliasMute"
	InformeSansDemander $PABMute "=Muted: mutation of $PAB $Alias $CodeDeMutation"
    }
    set D [Box $PAB debut]

    set F [Box $PAB fin]
    set O [Box $PAB orient]
    if {[Box $PABMute Nom]!=""} { 
	set LignePAB "[Box $PAB nom] [Box $PAB debut] [Box $PAB fin] [Box $PAB orient]"
	set FichierBornes "[RepertoireDuGenome]/fiches/bornesdespabs"
	set LesLignes [LesLignesDuFichier $FichierBornes]
	set i [lsearch -exact $LesLignes $LignePAB]
	set LesNouvellesLignes [lreplace $LesLignes $i $i]
	SauveLesLignes $LesNouvellesLignes dans $FichierBornes
    }
    Box $PABMute debut  $D
    Box $PABMute fin    $F
    Box $PABMute orient $O
    AppendAuFichier "[RepertoireDuGenome]/fiches/bornesdespabs" "$PABMute $D $F $O"
    ListeDesPABs $PABMute
    Box $PABMute nom    $PABMute
    Box $PABMute debut  $D
    Box $PABMute fin    $F
    Box $PABMute orient $O
    LesPABsDansLOrdre "ReplaceListReplaceFile"
    return "$PAB $PABMute $CodeDeMutation"
}

proc Mute {Code Seq} {
    Wup "Code can be a list of codes separated with space"

    JeMeSignale
    if {[regexp " " $Code]} {
	set LesCoOrdonnes {}
	foreach Co [split $Code " "] {
	    if { ! [regexp -nocase {[a-z]} $Co]} { continue }
	    regsub {[0-9]+} $Co " & " Coco
	    scan $Coco "%s %d %s" AncienP PosAncienP NouveauP
	    set LongAncienP [string length $AncienP]
	    lappend LesCoOrdonnes "$AncienP $PosAncienP $NouveauP"
	}
	set LesCoOrdonnes [lsort -decreasing -integer -index 1 $LesCoOrdonnes]
	set NouveauSeq $Seq
	foreach Co $LesCoOrdonnes {
	    regsub -all " " $Co "" Co
	    set NouveauSeq [Mute $Co $NouveauSeq]
	}
	return $NouveauSeq
    }
    regsub {[0-9]+} $Code " & " Coco
    scan $Coco "%s %d %s" AncienP PosAncienP NouveauP
    set LongAncienP [string length $AncienP]
    set LongAncienN [expr $LongAncienP*3]
    regsub "X" $NouveauP "" NouveauP 
    regsub "x" $NouveauP "" NouveauP 
    set LongNouveauP [string length $NouveauP]

#rR Attention, here we mutate NUCLEOTIDES 
    if {[regexp {^[a-z]+$} "$AncienP$NouveauP"] && \
	    [OuiOuNonMemo "I see that you use lowercase letters.\nPosition in Nuc count\n\
	    Ok to mutate nucleotides ?"]} {
	set DebAncienN [expr $PosAncienP-1]
	set FinAncienN [expr $DebAncienN + $LongAncienP - 1]
 	set NouveauSeq [string replace $Seq $DebAncienN $FinAncienN $NouveauP]
	return $NouveauSeq
    }
#rR Attention, here we mutate NUCLEOTIDES 
#rR Attention, here we mutate NUCLEOTIDES 
    if {[regexp {^[a-z]+$} "$NouveauP"] && [regexp {^[A-Z]+$} "$AncienP"] && \
	    [OuiOuNonMemo "For $Code , I see that you use lowercase letters in $NouveauP\n\
	    and uppercase in $AncienP\nSo position is in AA count\nOk to mutate the aa to nucleotides ?"]} {
	set DebAncienN [expr ($PosAncienP-1)*3]
	set FinAncienN [expr $DebAncienN + $LongAncienP*3 - 1]
 	set NouveauSeq [string replace $Seq $DebAncienN $FinAncienN $NouveauP]
	return $NouveauSeq
    }
#rR Attention, here we mutate NUCLEOTIDES 

    set DebAncienN [expr ($PosAncienP-1)*3]
    set FinAncienN [expr $DebAncienN+$LongAncienN-1]
    set AncienN [string range [string toupper $Seq] $DebAncienN $FinAncienN]
    set LesNouveauxCodons {}
    foreach {A B C} [split $AncienN ""] P [split $AncienP ""] N [split $NouveauP ""] {
	if {$N==""} { break }
	set Codon "$A$B$C"
	if {$Codon!=""} {
	    Espionne ">$Codon<   >$P<   >$N< $PosAncienP"
	    set AA [AAduCodon $Codon] 
	    if {$P!="" && $AA!=$P} {
		FaireLire "$P from $Code \n\
			doesn't correspond to translation of $Codon from the nucleic seq.\n\
			I ignore it. But, please, verify your sequences."
	    }
	}
	set NouveauCodon [PlusProcheCodon $Codon [LesCodesGenetiques $N]]
	lappend LesNouveauxCodons $NouveauCodon
    }
    set NouveauxCodons [join $LesNouveauxCodons ""]
    set NouveauSeq [string replace $Seq $DebAncienN $FinAncienN $NouveauxCodons]
    return $NouveauSeq
}

proc ChoixDUneListeDeSitesDeCoupure {} {

    FaireLire "Please select as much sites as you want.\nStop with 'StopAsking'"

    set LeChoix {}
    while 1 {
	set SC [ChoixDUnSiteDeCoupure]
	if {$SC=="SansCoupure"} {
	    if {[OuiOuNon "Do we stop now ?"]} { break }
	    continue
	}
	scan $SC "%s %s %d" Coupure CoupN LongCoupN
	set   SC "$CoupN $LongCoupN"
	if {[info exists DejaVu($SC)]} { continue }
	set DejaVu($SC) 1
	lappend LeChoix "$SC"
    }
    return $LeChoix
}

proc CoupureParEnzyme {{Qui ""} {Quoi ""}} {
    global CoupureParEnzyme
    if {[info exists CoupureParEnzyme($Qui,$Quoi)]} { return $CoupureParEnzyme($Qui,$Quoi) }
    if {[info exists CoupureParEnzyme("EstCharge")]} { return "" }

    foreach Coup [LesCoupuresPossibles] {
	set Type "N"
	scan $Coup "%s %s %s" Enzyme Pos Type
	set CoupureParEnzyme($Enzyme,position) $Pos
	set CoupureParEnzyme($Enzyme,type) $Type
	set Seq [Signal $Enzyme SEQ]
	set CoupureParEnzyme($Enzyme,sequence) $Seq
	lappend CoupureParEnzyme(ListeDes,Enzymes) $Enzyme
    }
    set CoupureParEnzyme("EstCharge") 1
    return [CoupureParEnzyme $Qui $Quoi]
}

proc EstUneProtease P {
    foreach PP [list "Thrombin" "TEV2" "TEVS" "Protease3C"] {
	if {$P==$PP} { return 1 }
    }
    return 0
}

proc LesCoupuresPossibles {} {
    set LesCoupuresPossibles [list "Thrombin 12 P" "TEV2 18 P" "TEVS 18 P" "Protease3C 18 P" \
	    "NdeI 3 N" "BamHI 3 N" "SpeI 3 N"]
    return $LesCoupuresPossibles
}

proc ChoixDUnSiteDeCoupure {{ChoixPourCoupure ""}} {

    if {$ChoixPourCoupure==""} { set ChoixPourCoupure "Ask" }
    if {$ChoixPourCoupure=="SansCoupure"} { return "SansCoupure" }

    while {$ChoixPourCoupure=="Ask" || [regexp -nocase {^[a-z\-0-9]+ +[0-9]+$} $ChoixPourCoupure]} {
	if {$ChoixPourCoupure=="Ask"} {
	    set LesCoups [LesCoupuresPossibles]
	    lappend LesCoups "OtherSignal" "NucleicSequence" "NoCuttingSite" "StopAsking"
	    set Choix [ChoixParmi $LesCoups]
	} else {
	    set Choix $ChoixPourCoupure
	}
	if {$Choix=="NoCuttingSite"} { return "SansCoupure" }
	if {$Choix==""} {
	    if { ! [OuiOuNon "NoCuttingSite ?"]} { continue }
	    set ChoixPourCoupure "SetToSansCoupure"
	    return "SansCoupure"
	} elseif {$Choix=="StopAsking"} {
	    return "SansCoupure"
	} elseif {$Choix=="OtherSignal"} {
	    FaireLire "Please give SignalName and Position"
	    set Choix [Entre "Thrombin 12 P"]
	    set Sign ""
	    set Pos ""
	    scan $Choix "%s %d" Sign Pos
	    if { ! [EstUnSignal $Sign] || ! [regexp {^[0-9]+$} $Pos]} {
		FaireLire "$Sign is not a signal name or Position is bad."
		continue
	    }
	    set CoupN [Signal $Sign]
	    set LongCoupN $Pos
	    set Coupure $Sign
	    set ChoixPourCoupure "SetToSignalName"
	} elseif {$Choix=="NucleicSequence"} {
	    FaireLire "Please give a nucleic sequence and Position"
	    set Choix [Entre "CATATG 3 N"]
	    set NucSeq ""
	    set Pos ""
	    scan $Choix "%s %d" NucSeq Pos
	    if { ! [regexp -nocase {^[a-z]+$} $NucSeq] || ! [regexp {^[0-9]+$} $Pos ]} {
		FaireLire "Something is wrong ... we'll try again"
		continue
	    }
	    set CoupN $NucSeq
	    set LongCoupN $Pos
	    set Coupure $NucSeq
	    set ChoixPourCoupure "SetToNucleicSequence"
	} elseif {[regexp -nocase {^NucSeq_[ATGCN]+ [0-9]+$} $Choix]} {
	    regsub {^NucSeq_} $Choix "" SeqPos
	    scan $SeqPos "%s %d" NucSeq Pos
	    set CoupN $NucSeq
	    set LongCoupN $Pos
	    set Coupure $NucSeq
	    set ChoixPourCoupure "SetToNucleicSequence"
	} else {
	    scan $Choix "%s %d" Sign Pos
	    set CoupN [Signal $Sign]
	    set LongCoupN $Pos
	    set Coupure $Sign
	    set ChoixPourCoupure "SetToSignal"
	}
	set CoupP [SeqNucToSeqPro $CoupN]
	set LongCoupP [expr $LongCoupN/3]
	set CoupN [string toupper $CoupN]
	set CoupP [string toupper $CoupP]
    }
    return "$Coupure $CoupN $LongCoupN $CoupP $LongCoupP"
}

proc CoupureDesADNCirculairesPourTous {} {
    set RepDestin "[RepertoireDuGenome]/coupure"
    set LesFichiersCrees {}
    foreach R2 [Rec2 LaListeDes Rec2] {
	set FichierTFA [Rec2 $R2 Fichier]
	if {[FileAbsent $FichierTFA]} { continue }
	set Coupe [QuelleCoupure $R2]
	if {$Coupe==""} { continue }
	set Type "N"
	scan $Coupe "%s %s %s" Enzyme Pos Type
	if {$Type!="P"} { continue }
	set Seq [Signal $Enzyme SEQ]
	set LesFic [CoupureDesADNCirculaires [list $FichierTFA] [list "$Seq $Pos"] $RepDestin $Enzyme]
	LConcat LesFichiersCrees $LesFic
    }
    return $LesFichiersCrees
}

proc CoupureDesADNCirculaires {{LesFichiersTFA ""} {LesSeqPos ""} {RepDestin ""} {Enzyme ""}} {

    if {$LesSeqPos=={}} {
	set LesSeqPos [ChoixDUneListeDeSitesDeCoupure]
    }
    if {$LesFichiersTFA=={}} {
	set LesFichiersTFA [LesFichiersDeType "Rec2"]
    }

    if {$RepDestin==""} {
	FaireLire "Please browse for the directory where to store the files"
	set RepDestin [ChoixDuRepertoire [RepertoireDuGenome]]
    }
    set Rep $RepDestin
    set LesFichiersCrees {}
    foreach Fichier $LesFichiersTFA {
	set Queue [file tail $Fichier]
	regsub {.tfa$|.nucfa$} $Queue "" Queue
	set Access [EnteteDuFichierTFA $Fichier "access"]
	regsub -nocase {^(rec1_|rec2_|fusion_)} $Access "" Access
	set ADN [QueLaSequenceDuFichierTFA $Fichier]
	set ZonesEtSites [CoupureDUnADNCirculaire $ADN $LesSeqPos]
	set Zones [lindex $ZonesEtSites 0]
	set Sites [lindex $ZonesEtSites 1]
	foreach Zone $Zones Site $Sites {
	    set BeauSite [join $Site "-"]
	    if {$Enzyme!=""} { set BeauSite $Enzyme }
	    set BeauAccess "cut_${Access}_$BeauSite"
	    set FichierCree "$Rep/cut_${Queue}_$BeauSite.nuctfa"
	    set nBases [string length $Zone]
	    set TFA [SequenceFormatTFA $Zone "$BeauAccess $nBases bases" "nucbrut"]
	    Espionne [Sauve $TFA dans $FichierCree]
	    lappend LesFichiersCrees $FichierCree

	    set CDS ""
	    foreach {A B C} [split $Zone ""] {
		set Codon "$A$B$C"
		if {[CodonStopPossible $Codon]} { break }
		append CDS $Codon
	    }
	    set nAA [string length $CDS]
	    set SeqPro [SeqNucToSeqPro $CDS]
	    set ProtTFA [SequenceFormatTFA $SeqPro "$BeauAccess $nAA AA" "protbrut"]
	    set FichierCreeProt $FichierCree
	    regsub ".nuctfa$" $FichierCreeProt ".prottfa" FichierCreeProt
	    Espionne [Sauve $ProtTFA dans $FichierCreeProt]
	    lappend LesFichiersCrees $FichierCreeProt
	}
    }
    return $LesFichiersCrees
}

proc CoupureDUnADNCirculaire {ADN LesSeqPos} {

    set LongADN [string length $ADN]
    Espionne $LongADN
    set Double [string toupper "$ADN$ADN$ADN"]

    foreach SeqPos $LesSeqPos {
	scan $SeqPos "%s %d" Seq Pos
	set Seq [string toupper $Seq]
	set iMin -1
	Espionne $Seq
	while 1 {
	    set i [string first $Seq $Double $iMin]
	    if {$i<0} { break }
	    set iMin [expr $i+1]
	    set Site [expr $i+$Pos]
	    lappend LesSites $Site
	    set SeqDuSite($Site) $Seq
	    incr Site $LongADN
	    lappend LesSites $Site
	    set SeqDuSite($Site) $Seq
	}
    }
    set LesSites [lsort -unique -integer $LesSites]
    set LesZones {}
    set LesSitesDeCoupure {}
    foreach SiteA [lrange $LesSites 0 end-1] SiteB [lrange $LesSites 1 end] {
	Espionne "$SiteA $SiteB"
	if {[info exists DejaVu($SiteA)]} { break }
	set DejaVu([expr $SiteA+$LongADN]) 1
	set FinSiteB [expr $SiteB-1]
	set Zone [string range $Double $SiteA $FinSiteB]
	lappend LesZones $Zone
	if {$FinSiteB>$LongADN} { set FinSiteB [expr $FinSiteB-$LongADN] } 
	lappend LesSitesDeCoupure "$SiteA $FinSiteB [set SeqDuSite($SiteA)] [set SeqDuSite($SiteB)]"
    }
    return [list $LesZones $LesSitesDeCoupure]
}

proc LesSujetsDansLeBonOrdre LesSujets {
    set LesBeauxSujets {}
    foreach Sujet $LesSujets {
	set LesMots [split $Sujet "-"]
	set F [lindex $LesMots end]
 	set D [lindex $LesMots end-1]
	set BeauSujet $Sujet
	if {[regexp {^[0-9]+$} $D] && [regexp {^[0-9]+$} $F]} {
	    set Reste [join [lrange $LesMots 0 end-2] "-"]
	    set BeauSujet [format "%s\-%5.5d\-%5.5d" $Reste $D $F]
	}
	lappend LesBeauxSujets $BeauSujet
	set MonSujet($BeauSujet) $Sujet
    }
    set LesBeauxTries [lsort $LesBeauxSujets]
    set LesTries {}
    foreach BeauSujet $LesBeauxTries {
	lappend LesTries [set MonSujet($BeauSujet)]
    }
    return $LesTries
}

proc CreeToutesLesNotesPourClonage {{Liste ""}} {

    if {$Liste==""} { set Liste [ListeDesPABs] }

    set RepNotes "[RepertoireDuGenome]/notes"
    if { ! [file exists RepNotes]} { file mkdir $RepNotes }
    foreach Nom $Liste {
	set FichierNotes "$RepNotes/$Nom"
	set LesSujets [split [BaClon LesSujets $Nom] " "]
	set LesSujets [LesSujetsDansLeBonOrdre $LesSujets]
	set LesOligos [split [BaClon LesOligos $Nom] " "]

	Espionne $LesSujets

	set TexteTitre "Note for $Nom [Alias $Nom] [CodeMutation $Nom All] [DefinitionRapide $Nom]"
	
	set LesLignesSujets {}
	set OldLigne ""
	foreach Sujet $LesSujets {
	    set Ligne [format "%-15s" $Sujet]
	    set LesPDuTrio {}
	    foreach P $LesOligos {
		if {[BaClonExists Trio $Nom $Sujet $P]} { lappend LesPDuTrio $P }
	    }
	    set LesPDuTrio [ListeSansDoublon $LesPDuTrio]
	    if {[llength $LesPDuTrio]==0} {
		append Ligne " NoOligoFound"
	    } elseif {[llength $LesPDuTrio]!=2} {
		append Ligne " OligosFound [join $LesPDuTrio " "]"
	    } else {
		set A [lindex $LesPDuTrio 0]
		set B [lindex $LesPDuTrio 1]
		set pA [BaClon Trio $Nom $Sujet $A]
		set pB [BaClon Trio $Nom $Sujet $B]
		if {$pA>$pB} { set W $A ; set A $B ; set B $W ; set W $pA ; set pA $pB ; set pB $W }
		Espionne "$Nom $Sujet $A $pA $B $pB"
		set dA [expr $pA - [string length [Oli $A SeqSignals]]/3 -1]
		set fA [expr $pA + [string length [Oli $A SeqSubject]]/3 -1]
		set dB [expr $pB - [string length [Oli $B SeqSignals]]/3 -1]
		set fB [expr $pB + [string length [Oli $B SeqSubject]]/3 -1]
		lappend LesPPCRsADessiner($Nom) "$Sujet [expr ($pA-1)*3+1] [expr $pB*3] \
			$A [expr ($dA-1)*3+1] [expr $fA*3] \
			$B [expr ($dB-1)*3+1] [expr $fB*3]"  
		set BlancDevant [string repeat "." [Maxi [expr $pA/10] 2]]
		set BlancDedans [string repeat "-" [Maxi [expr ($pB-$pA)/10] 2]]
		set TxtP " $BlancDevant $A $BlancDedans $B"
		append Ligne $TxtP
	    }
	    if {$Ligne!=$OldLigne} {
		lappend LesLignesSujets $Ligne
	    }
	    set OldLigne $Ligne
	}
	if {$LesLignesSujets=={}} {
	    set TexteSujets "No subject found"
	} else {
	    set TexteSujets [join $LesLignesSujets "\n"]
	}
	if {$LesOligos=={}} {
	    set TexteOligos "No oligos found"
	} else {
	    set TexteOligos {}
	    foreach P $LesOligos {
		lappend TexteOligos [Oli $P "Description"]
	    }
	    set TexteOligos [join $TexteOligos "\n"]
	}

	catch {unset DejaVu}
	foreach P $LesOligos { set DejaVu($P) 1 }
	set OtherOligos {}
	foreach P [LesOligosDuPGS $Nom] {
	    if {[info exists DejaVu($P)]} { continue }
	    lappend OtherOligos [Oli $P "Description"]
	}
	if {$OtherOligos==""} {
	    set TexteOtherOligos ""
	} else {
	    set TexteOtherOligos "Additional Oligos :\n[join $OtherOligos "\n"]"
	}

	set LeTextePPCR {}
	foreach N [LesVirtualPPCRsDuPGS $Nom] {
	    lappend LeTextePPCR [VirtualPPCREnStock $N "Resume"]
	}
	if {$LeTextePPCR=={}} {
	    set TextePPCR "No PPCR found"
	} else {
	    set TextePPCR [join $LeTextePPCR "\n"]
	}

	set LeTexteRec1 {}
	foreach R1 [Rec1 $Nom LesRec1] {
	    lappend LeTexteRec1 [Rec1 $R1 "Description"]
	}
	if {$LeTexteRec1=={}} {
	    set TexteRec1 "No Rec1 found"
	} else {
	    set TexteRec1 [join $LeTexteRec1 "\n"]
	}

	set LeTexteRec2 {}
	foreach R2 [Rec2 $Nom LesRec2] {
	    lappend LeTexteRec2 [Rec2 $R2 "Description"]
	}
	if {$LeTexteRec2=={}} {
	    set TexteRec2 "No Rec2 found"
	} else {
	    set TexteRec2 [join $LeTexteRec2 "\n"]
	}

	set Texte "$TexteTitre\n\n$TexteSujets\n\n$TexteOligos\n$TexteOtherOligos\
		\n\n$TextePPCR\n\n$TexteRec1\n\n$TexteRec2"
	Espionne [Sauve $Texte dans $FichierNotes ]
    }
    if {[info exists LesPPCRsADessiner]} {
	SauveLesLignes [array get LesPPCRsADessiner] dans "[RepertoireDuGenome]/fiches/lesppcrsadessiner"
    }
}

proc MailAuxDestinataires {FichierTXTCommandeOligos {LesDestinataires {}} {Sujet ""}} {
    if {$LesDestinataires=={}} {
	set LesDestinataires {}
	lappend LesDestinataires "Peggy.Mathon@igbmc.u-strasbg.fr"
	lappend LesDestinataires "Marie.Herledan@igbmc.u-strasbg.fr"
	lappend LesDestinataires "Marie-France.Tinland@igbmc.u-strasbg.fr"
	lappend LesDestinataires "Didier.Busso@igbmc.u-strasbg.fr"
	lappend LesDestinataires "Sylvia.Eiler@igbmc.u-strasbg.fr"
	lappend LesDestinataires "Arnaud.Poterszman@igbmc.u-strasbg.fr"
	lappend LesDestinataires "Raymond.Ripp@igbmc.u-strasbg.fr"
	lappend LesDestinataires "europrim@invitrogen.com"
	set LesDestinataires [ChoixDesPresents $LesDestinataires]
    }
    if {$Sujet==""} { set Sujet [Entre "[file tail $FichierTXTCommandeOligos]"] }
    if {$LesDestinataires=={}} { return {} }
    foreach Destinataire $LesDestinataires {
	Espionne [MailFichier $FichierTXTCommandeOligos $Destinataire $Sujet]
    }
    return $LesDestinataires
}

proc LigneAccessPourLOligo P {
    set LesSujets [Oli $P Subjects]
    set Sens      [Oli $P Sens]
    set Signals   [Oli $P Signals]
    set Seq       [Oli $P Seq]
    set SeqSujet  [Oli $P SeqSubject]

    set Type      [Oli $P Type]
    set TypeUtilisation $Type
    if {$Type=="SynOli"} { set TypeUtilisation "PCR" }
    
    set Fournis   [Fournisseur $P]
    set OlIgbmc   [OlIgbmc $P]

    set Tm [TMDeLaSequence $SeqSujet]

    set LesPoMa [PositionSurMatrices $P]
    if {0 && [llength $LesPoMa]>1 && $Type!="MutOli"} {
	FaireLire "I found more than 1 matrix for $P. Please select one of them."
	set PoMa [ChoixParmi $LesPoMa]
    } else {
	set PoMa [lindex $LesPoMa 0]
    }
    set AA -1
    set NA -1
    set Orient "F"
    set PAB ""
    scan $PoMa "%s %d %d %s %s" P AA NA Orient PAB
    if {$AA<0} {
	set Matrice ""
    } else {
	set Matrice [Alias $PAB]
    }
    set Sens ""
    if {$Orient=="F"} {
	set Sens "sens"
	set Tm5p "tm5p_$Tm"
	set LesSST {}
	foreach Suj $LesSujets {
	    set SST "${Signals}_$Suj $Tm5p"
	    lappend LesSST $SST
	}
	set signal [join $LesSST "+"]
    }
    if {$Orient=="R"} {
	set Sens "antisens"
	set Tm3p "tm3p_$Tm"
	set LesSST {}
	foreach Suj $LesSujets {
	    set SST "${Suj}_${Signals} $Tm3p"
	    lappend LesSST $SST
	}
	set signal [join $LesSST "+"]
    }

    set code_IGBMC        $OlIgbmc
    regsub "OLIGO\:"      $code_IGBMC "" code_IGBMC
    set sequence          $Seq    
    set brin              $Sens
    set proteine          $Matrice      
    if {$Type=="MutOli"} {
	set mutation [Oli $P CodeMutation]
    } else {
	set mutation          ""
    }
    set utilisation       $TypeUtilisation 
    set longueur          [string length $Seq]
    set signal            $signal
    if {$Fournis!=""} {
	set demandeur $Fournis
    } else {
	set demandeur ""
    }
    set date_commande     ""
    set date_reception    "" 
    set codon_de_l_oligo1 ""
    set boite             ""

    set LaLigne {}
    lappend LaLigne $P
    lappend LaLigne $code_IGBMC       
    lappend LaLigne $sequence         
    lappend LaLigne $brin             
    lappend LaLigne $proteine         
    lappend LaLigne $mutation         
    lappend LaLigne $utilisation
    lappend LaLigne $longueur
    lappend LaLigne $signal           
    lappend LaLigne $demandeur        
    lappend LaLigne $date_commande    
    lappend LaLigne $date_reception   
    lappend LaLigne $codon_de_l_oligo1
    lappend LaLigne $boite            

    set Ligne [join $LaLigne "\"\t\""]
    set Ligne "\"$Ligne\""
    return $Ligne
}

proc NumeroSuivant {DernierP {Format ""} {IncrValue 1}} {

    Wup "P0123 or TOTO1234 or To_Salut1234 . If no 4 digit use Format"

    if {$Format==""} { set Format "%s%4.4d" }

    regsub -all {[0-9]}  $DernierP "" Lettre 
    regsub -all {[^0-9]} $DernierP "" Numero
    set Numero [Base10 $Numero]
    incr Numero $IncrValue
    set ProchainP [format $Format $Lettre $Numero]
    return $ProchainP
}


proc StockeCetOligo {Entete Sequence {ForceProchainP ""} {FichierOli ""}} {
    global DernierPStocke

    if {$Entete=="Reset"} {
	if {[info exists DernierPStocke]} { unset DernierPStocke }
	return ""
    }

    if {$ForceProchainP==""} { set ForceProchainP "AutoNumbering" }
    if {$ForceProchainP=="AutoNumbering"} {
	if { ! [info exists DernierPStocke]} { 
	    set LesExistants [lsort [Oli "LaListeMerci"]]
	    set DernierPStocke [lindex $LesExistants end]
	    set OriProchainP [NumeroSuivant $DernierPStocke]
	    set ProchainP $OriProchainP
	    while { ! [OuiOuNon "Do I start oligos numbering with $ProchainP ?"]} {
		set ProchainP [Entre $OriProchainP]
		if {[regexp -nocase "Test" $ProchainP]} {
		    set ProchainP "T7701"
		    set DernierPStocke $ProchainP
		}
	    }
	} else {
	   set ProchainP [NumeroSuivant $DernierPStocke] 
	}
    } else {
	set ProchainP $ForceProchainP
    }

    set DernierPStocke $ProchainP

    if {[regexp "^T7" $ProchainP]} { return $ProchainP }

    regsub "Pxxxx" $Entete $ProchainP Entete
    set TFA [SequenceFormatTFA $Sequence $Entete "nucbrut"]
    if {$FichierOli==""} { set FichierOli "[RepertoireDuGenome]/oligos/$ProchainP.tfa" }
    return [Sauve $TFA dans $FichierOli]
}

proc FormatageEntete {Entete {PourQui ""} {P ""}} {
JeMeSignale
    set BelleEntete $Entete

    if {[regexp "sequencing oligo" $Entete]} {
	set LesSeqOli {}
	foreach E [split $Entete "+"] {
	    scan $E "%s" SeqOli
	    if {$LesSeqOli!={}} { regsub {SeqOli(Rac|)_} $SeqOli " " SeqOli }
	    lappend LesSeqOli $SeqOli
	}
	if {$P!=""} { set BelleEntete "$P " } else { set BelleEntete "" }
	append BelleEntete [join $LesSeqOli " "]
	return $BelleEntete
    }

    if {[regexp "mutation oligo" $Entete]} {
	set LesMutOli {}
	foreach E [split $Entete "+"] {
	    scan $E "%s" MutOli
	    if {$LesMutOli!={}} { regsub {MutOli(Rac|)_} $MutOli " " MutOli }
	    lappend LesMutOli $MutOli
	}
	if {$P!=""} { set BelleEntete "$P " } else { set BelleEntete "" }
	append BelleEntete [join $LesMutOli " "]
	return $BelleEntete
    }

    if {$PourQui==""} { set PourQui "PourCommande" }

    set TM ""
    if {[regexp { tm[53]p_[0-9]+} $Entete Match]} { set TM [string trim $Match] }

    set LesLis [DecomposeLaLigne $Entete]
Espionne $LesLis
    set LesSujets [lindex $LesLis 0]
    set LesAvs    [lindex $LesLis 1]
    set LesAps    [lindex $LesLis 2]

    set Sujet [join $LesSujets " "]
    set SigAv [join $LesAvs "_"]
    set SigAp [join $LesAps "_"]
    if {[regexp "PourOligo" $PourQui]} {
	if {$SigAv!=""} {
	    if {[regexp "BrocOli" $Entete] && [regexp "PourOligoNonBrocOli" $PourQui]} {
		set SigAvNB [StringApres " replaces " dans $Entete]
		Espionne $SigAvNB
		if {$SigAvNB==""} {
		    FaireLire "Ca merde avec le BrocOli $Entete"
		} else {
		    set SigAv $SigAvNB 
		}
	    }
	    set BelleEntete "$P 5' oligo with signal $SigAv for $Sujet"
	}
	if {$SigAp!=""} {	
	    if {[regexp "BrocOli" $Entete] && [regexp "PourOligoNonBrocOli" $PourQui]} {
		set SigApNB [StringApres " replaces " dans $Entete]
		if {$SigApNB==""} {
		    FaireLire "Ca merde avec le BrocOli $Entete"
		} else {
		    set SigAp $SigApNB 
		}
	    }
	    set BelleEntete "$P 3' oligo with signal $SigAp for $Sujet"
	}
	if {$SigAv=="" && $SigAp==""} {
	    set BelleEntete "$P oligo without signal for $Sujet"
	}
	if {[regexp "BrocOli" $Entete]} {
	    if {[regexp "PourOligoNonBrocOli" $PourQui]} {
		set CuttedSignal [StringApres "BrocOli with" dans $Entete]
		set FullSignal [StringApres " replaces " dans $Entete]
		set TexteBrocOli "RebuildedBrockenOli of $CuttedSignal"
	    } else {	    
		set TexteBrocOli "BrocOli [StringSuivant "BrocOli " dans $Entete] seeFull AfterMe"
	    }
	    append BelleEntete " $TexteBrocOli" 
	}
    }

    if {$PourQui=="PourCommande"} {
	set PremierSujet [lindex $LesSujets 0]
	set Racine "trululuturlu"
	if {[regexp {^[^\-]+\-} $PremierSujet Match]} { set Racine $Match }
	set LesAutresSujets {}
	foreach AutreSujet [lrange $LesSujets 1 end] {
	    regsub $Racine $AutreSujet "" AutreSujet
	    lappend LesAutresSujets $AutreSujet
	}
	set AutresSujets "[join $LesAutresSujets " "]"
	if {$P!=""} { set BelleEntete "$P " } else { set BelleEntete "" }
	set TexteBrocOli ""
	if {[regexp "BrocOli" $Entete]} {
	    set TexteBrocOli " BrocOli [StringSuivant "BrocOli " dans $Entete]"
	}
	if {$SigAv!=""} {
	    append BelleEntete "${SigAv}_$PremierSujet $AutresSujets $TexteBrocOli $TM"
	}
	if {$SigAp!=""} {
	    append BelleEntete "${PremierSujet}_$SigAp $AutresSujets $TexteBrocOli $TM"
	}
	if {$SigAv=="" && $SigAp==""} {
	    append BelleEntete "$PremierSujet $AutresSujets $TexteBrocOli $TM"
	}
    }
    return $BelleEntete
}

proc PofPPCR {{Quoi ""}} {
    if {$Quoi==""} { set Quoi "5_3" }
    set LesPofPPCR {}
    foreach PPCR [lsort -unique [concat [P5ofPPCR "LaListeDesPPCRs"] [P3ofPPCR "LaListeDesPPCRs"]]] {
	set P5 "     "
	set LesP5s [P5ofPPCR $PPCR]
	if {$LesP5s!={}} { set P5 [join $LesP5s " "] }
	set P3 "     "
	set LesP3s [P3ofPPCR $PPCR]
	if {$LesP3s!={}} { set P3 [join $LesP3s " "] }
	if {[regexp "5" $Quoi]} { lappend LesPofPPCR "$P5    $PPCR" } 
	if {[regexp "3" $Quoi]} { lappend LesPofPPCR "$P3    $PPCR" } 
	lappend LesPofPPCR ""
    }
    return $LesPofPPCR
}

proc P5ofPPCR {{PPCR ""} {Val ""}}  {
    global P5ofPPCR

    set FichierP5ofPPCR "[RepertoireDuGenome]/fiches/P5ofPPCR"
    if {$PPCR=="Save"} {
	unset P5ofPPCR(LaListeDesPPCRs)
	unset P5ofPPCR(LaListeDesPs)
	unset P5ofPPCR("EstCharge")
	SauveLesLignes [array get P5ofPPCR] dans $FichierP5ofPPCR
	unset P5ofPPCR
	P5ofPPCR Load
	return $FichierP5ofPPCR
    }	

    if {$PPCR==""} {
	return [list \
		"P5ofPPCR \"Sujet === SignauxAvant === SignauxApres\"" \
		"P5ofPPCR LaListeDesPPCRs" \
		"P5ofPPCR LaListeDesPs"]
    }

    if {$Val!=""} {
	if {[OuiOuNonMemo "Do I load already existing PofPPCR"]} {
	    P5ofPPCR Load
	    P3ofPPCR Load
	}
	set P5ofPPCR("EstCharge") ""
	if {[info exists P5ofPPCR($PPCR)] && [set P5ofPPCR($PPCR)]!=$Val} {
#rR	    FaireLire "P5ofPPCR $PPCR\n already exists it was [set P5ofPPCR($PPCR)] and now $Val" 
	}
	set P5ofPPCR($PPCR) $Val
	lappend P5ofPPCR(LaListeDesPPCRs) $PPCR
	lappend P5ofPPCR(LaListeDesPs) $Val
	set P5ofPPCR(LaListeDesPs) [lsort -unique [set P5ofPPCR(LaListeDesPs)]]
	return $Val
    }

    if {[info exists P5ofPPCR($PPCR)]}       { return [set P5ofPPCR($PPCR)] }
    if {[info exists P5ofPPCR("EstCharge")]} { return [set P5ofPPCR("EstCharge")] }

    Wup "From here we load existing"

    if {[info exists P5ofPPCR]} { unset P5ofPPCR }
    if { ! [file exists $FichierP5ofPPCR] } { return "NoValueAvalaible" }

    array set P5ofPPCR [LesLignesDuFichier $FichierP5ofPPCR]    
    set LesP {}
    set LesPP {}
    foreach {PP P} [array get P5ofPPCR] {
	lappend LesP $P
	lappend LesPP $PP
    }
    set P5ofPPCR("EstCharge") ""
    set P5ofPPCR(LaListeDesPs) [lsort -unique $LesP]
    set P5ofPPCR(LaListeDesPPCRs) [lsort -unique $LesPP]
    
    return [P5ofPPCR $PPCR]
}

proc P3ofPPCR {{PPCR ""} {Val ""}}  {
    global P3ofPPCR

    set FichierP3ofPPCR "[RepertoireDuGenome]/fiches/P3ofPPCR"
    if {$PPCR=="Save"} {
	unset P3ofPPCR(LaListeDesPPCRs)
	unset P3ofPPCR(LaListeDesPs)
	unset P3ofPPCR("EstCharge")
	SauveLesLignes [array get P3ofPPCR] dans $FichierP3ofPPCR
	unset P3ofPPCR
	P3ofPPCR Load
	return $FichierP3ofPPCR
    }	

    if {$PPCR==""} {
	return [list \
		"P3ofPPCR \"Sujet === SignauxAvant === SignauxApres\"" \
		"P3ofPPCR LaListeDesPPCRs" \
		"P3ofPPCR LaListeDesPs"]
    }

    if {$Val!=""} {
	if {[OuiOuNonMemo "Do I load already existing PofPPCR"]} {
	    P5ofPPCR Load
	    P3ofPPCR Load
	}
	set P3ofPPCR("EstCharge") ""
	if {[info exists P3ofPPCR($PPCR)] && [set P3ofPPCR($PPCR)]!=$Val} {
#rR	    FaireLire "P3ofPPCR $PPCR\n already exists it was [set P3ofPPCR($PPCR)] and now $Val" 
	}
	set P3ofPPCR($PPCR) $Val
	lappend P3ofPPCR(LaListeDesPPCRs) $PPCR
	lappend P3ofPPCR(LaListeDesPs) $Val
	set P3ofPPCR(LaListeDesPs) [lsort -unique [set P3ofPPCR(LaListeDesPs)]]
	return $Val
    }

    if {[info exists P3ofPPCR($PPCR)]} { return [set P3ofPPCR($PPCR)] }
    if {[info exists P3ofPPCR("EstCharge")]} { return [set P3ofPPCR("EstCharge")] }

    Wup "From here we load existing"

    if {[info exists P3ofPPCR]} { unset P3ofPPCR }
    if { ! [file exists $FichierP3ofPPCR] } { return "NoValueAvalaible" }

    array set P3ofPPCR [LesLignesDuFichier $FichierP3ofPPCR]    
    set LesP {}
    set LesPP {}
    foreach {PP P} [array get P3ofPPCR] {
	lappend LesP $P
	lappend LesPP $PP
    }
    set P3ofPPCR("EstCharge") ""
    set P3ofPPCR(LaListeDesPs) [lsort -unique $LesP]
    set P3ofPPCR(LaListeDesPPCRs) [lsort -unique $LesPP]
    
    return [P3ofPPCR $PPCR]
}

proc OldP3ofPPCR {{PPCR ""} {Val ""}}  {
    global P3ofPPCR

    if {$PPCR==""} {
	return [list \
		"P3ofPPCR \"Sujet === SignauxAvant === SignauxApres\"" \
		"P3ofPPCR LaListeDesPPCRs" \
		"P3ofPPCR LaListeDesPs"]
    }

    if {$Val!=""} {
	if {[OuiOuNonMemo "Do I load existing PofPPCR"]} {
	    P5ofPPCR Load
	    P3ofPPCR Load
	}
	set P5ofPPCR("EstCharge") ""
	set P3ofPPCR("EstCharge") ""
	if {[info exists P3ofPPCR($PPCR)] && [set P3ofPPCR($PPCR)]!=$Val} {
	    FaireLire "P3ofPPCR $PPCR\n already exists it was [set P3ofPPCR($PPCR)] and now $Val" 
	}
	set P3ofPPCR($PPCR) $Val
	return $Val
    }

    if {$Val!=""} {
	if {[OuiOuNonMemo "Do I load existing P3ofPPCR"]} { P3ofPPCR Load }
	set P3ofPPCR("EstCharge") ""
	lappend P3ofPPCR($PPCR) $Val
	return $Val
    } 

    if {[info exists P3ofPPCR($PPCR)]} { return [set P3ofPPCR($PPCR)] }
    if {[info exists P3ofPPCR("EstCharge")]} { return [set P3ofPPCR("EstCharge")] }

    if {[info exists P3ofPPCR]} { unset P3ofPPCR }
    set FichierP3ofPPCR "[RepertoireDuGenome]/fiches/P3ofPPCR"
    if { ! [file exists $FichierP3ofPPCR] } { return "NoValueAvalaible" }

    array set P3ofPPCR [LesLignesDuFichier $FichierP3ofPPCR]    
    set LesPPCRs [lsort [array names P3ofPPCR]]
    set P3ofPPCR("EstCharge") ""
    set P3ofPPCR(LaListeDesPPCRs) $LesPPCRs
    set LesP {}
    foreach PP $LesPPCRs {
	if {[regexp "EstCharge" $PP]} { continue }
	lappend LesP [set P3ofPPCR($PP)]
    }
    set P3ofPPCR(LaListeDesPs) [lsort -unique $LesP]
    
    return [P3ofPPCR $PPCR]
}

proc PofSeq {{Oli ""}} {
    global PofSeq

    if {$Oli==""} {
	return [list \
		"PofSeq GR" \
		"PofSeq PGS002" \
		"PofSeq LaListeDesOligos" \
		"PofSeq LaListeDesPs" \
		"PofSeq LesPofSeq"]
    }

    if {[info exists PofSeq($Oli)]} { return [set PofSeq($Oli)] }
    if {[info exists PofSeq("EstCharge")] && $Oli!="LesPofSeq"} { return [set PofSeq("EstCharge")] }
    if {[info exists PofSeq("EstCharge")] && $Oli=="LesPofSeq"} {
	set LeTexte {}
	foreach O [array names PofSeq] {
	    if {[regexp "EstCharge|LaListe" $O]} { continue }
	    set LesPs [set PofSeq($O)]
	    lappend LeTexte "[join $LesPs " "]    $O"
	}
	set LeTexte [lsort $LeTexte]
	return $LeTexte
    }

    if {[info exists PofSeq]} { unset PofSeq }
    set FichierPofSeq "[RepertoireDuGenome]/fiches/PofSeq"
    if { ! [file exists $FichierPofSeq] } {
	if { ! [OuiOuNon "Do I create fiches/PofSeq with ./oligos/* ?"]} {
	    set PofSeq("EstCharge") ""
	    return "NoValueAvalaible"
	}
	foreach P [Oli "LaListeMerci"] {
	    if {[Oli $P Type]!="SeqOli"} { continue }
	    lappend PofSeq(LaListeDesPs) $P
	    set Sens [Oli $P "Sens"]
	    if {$Sens=="5'"} { set FouR "F" } else { set FouR "R" } 
	    set LesSujets [Oli $P "Subjects"]
	    foreach Sujet $LesSujets {
		lappend PofSeq($Sujet-$FouR) $P
		lappend PofSeq(LaListeDesOligos-$FouR) $P
		if {$Sens=="5'"} {
		    lappend PofSeq($Sujet) $P
		    lappend PofSeq(LaListeDesOligos) $P
		}
	    }
	}
	SauveLesLignes [array get PofSeq] dans $FichierPofSeq
	return [PofSeq $Oli]
    }

    array set PofSeq [LesLignesDuFichier $FichierPofSeq]    
    set PofSeq("EstCharge") ""
    return [PofSeq $Oli]
    set LesOlis [lsort [array names PofSeq]]
    set PofSeq(LaListeDesOligos) $LesOlis
    set LesP {}
    foreach O $LesOlis {
	lappend LesP [set PofSeq($O)]
    }
    set PofSeq(LaListeDesPs) [lsort -unique $LesP]
    return [PofSeq $Oli]
    
}

proc PofMut {{Oli ""}} {
    global PofMut

    if {$Oli==""} {
	return [list \
		"PofMut GR-M1" \
		"PofMut GR-M1-H602R" \
		"PofMut PGS002 H602R" \
		"PofMut LaListeDesOligos" \
		"PofMut LaListeDesPs" \
		"PofMut LesPofMut"]
    }

    if {[info exists PofMut($Oli)]} { return [set PofMut($Oli)] }
    if {[info exists PofMut("EstCharge")] && $Oli!="LesPofMut"} { return [set PofMut("EstCharge")] }
    if {[info exists PofMut("EstCharge")] && $Oli=="LesPofMut"} {
	set LeTexte {}
	foreach O [array names PofMut] {
	    if {[regexp "EstCharge|LaListe" $O]} { continue }
	    set LesPs [set PofMut($O)]
	    set P [lindex $LesPs 0]
	    set LesAutresPs [lrange $LesPs 1 end]
	    set RefIGBMC [format "%-14s" [OlIgbmc $P]]
	    set Texte "$P $RefIGBMC [format "%-25s" $O]"
	    if {$LesAutresPs!={}} { append Texte " with [join $LesAutresPs " "]" }
	    lappend LeTexte $Texte
	}
	set LeTexte [lsort $LeTexte]
	return $LeTexte
    }

    if {[info exists PofMut]} { unset PofMut }
    set FichierPofMut "[RepertoireDuGenome]/fiches/PofMut"
    if { ! [file exists $FichierPofMut] } {
	if { ! [OuiOuNon "Do I create fiches/PofMut with ./oligos/* ?"]} {
	    set PofMut("EstCharge") ""
	    return "NoValueAvalaible"
	}
	foreach P [Oli "LaListeMerci"] {
	    if {[Oli $P Type]!="MutOli"} { continue }
	    lappend PofMut(LaListeDesPs) $P
	    set Sens [Oli $P "Sens"]
	    if {$Sens=="5'"} { set FouR "F" } else { set FouR "R" } 
	    set Code [Oli $P "CodeMutation"]
	    set LesSujets [Oli $P "Subjects"]
	    foreach Sujet $LesSujets {
		lappend PofMut($Sujet-$FouR) $P
		lappend PofMut(LaListeDesOligos-$FouR) $P
		set PofMut($Sujet-$Code-$FouR) $P
		if {$Sens=="5'"} {
		    lappend PofMut($Sujet) $P
		    set PofMut($Sujet-$Code) $P
		    lappend PofMut(LaListeDesOligos) $P
		}
	    }
	}
	SauveLesLignes [array get PofMut] dans $FichierPofMut
	return [PofMut $Oli]
    }

    array set PofMut [LesLignesDuFichier $FichierPofMut]    
    set PofMut("EstCharge") ""
    return [PofMut $Oli]
    set LesOlis [lsort [array names PofMut]]
    set PofMut(LaListeDesOligos) $LesOlis
    set LesP {}
    foreach O $LesOlis {
	lappend LesP [set PofMut($O)]
    }
    set PofMut(LaListeDesPs) [lsort -unique $LesP]
    return [PofMut $Oli]
    
}

proc PofOl {{Oli ""}} {
    global PofOl

    if {$Oli==""} {
	return [list \
		"PofOl \"Sujet === SignalAvant === \"" \
		"PofOl \"Sujet ===  === SignalAPres\"" \
		"PofOl P1234" \
		"PofOl LaListeDesOligos" \
		"PofOl LaListeDesPs" \
		"PofOl LesPofOl"]
    }

    if {[regexp "===$" $Oli]} { append Oli " " }

    if {[info exists PofOl($Oli)]} { return [set PofOl($Oli)] }
    if {[info exists PofOl("EstCharge")] && $Oli!="LesPofOl"} { return [set PofOl("EstCharge")] }
    if {[info exists PofOl("EstCharge")] && $Oli=="LesPofOl"} {
	set LeTexte {}
	foreach O [PofOl "LaListeDesOligos"] {
	    if {[regexp "EstCharge|LaListe" $O]} { continue }
	    set LesPs [set PofOl($O)]
	    set WarningBrocOli ""
	    foreach P $LesPs {
		if {[Oli $P "IsRebuildedBrockenOli"]} {
		    set Brocken [Oli $P "Brocken"]
		    append WarningBrocOli " $P rebuilded BrocOli from $Brocken"
		}
	    }
	    set Premier [lindex $LesPs 0]
	    set RefIGBMC [format "%-14s" [OlIgbmc $Premier]]
	    set Four [string range "[Fournisseur $Premier]     " 0 4]
	    lappend LeTexte "[join $LesPs " "]  $Four $RefIGBMC [format "%-50s" $O] $WarningBrocOli"
	}
	set LeTexte [lsort $LeTexte]
	return $LeTexte
    }

    if {[info exists PofOl]} { unset PofOl }
    set FichierPofOl "[RepertoireDuGenome]/fiches/PofOl"
    if { ! [file exists $FichierPofOl] } { return "NoValueAvalaible" }

    array set PofOl [LesLignesDuFichier $FichierPofOl]    
    set LesOlis {}
    set LesPs {}
    foreach N [lsort [array names PofOl]] {
	if {[EstUnP $N]}       { lappend LesPs $N }
	if {[regexp "===" $N]} { lappend LesOlis $N }
    }
    foreach O $LesOlis {
	set SesP [split $PofOl($O) " "]
	foreach P $SesP {
	    if { ! [EstUnP $P]} { continue }
	    lappend LesP $P
	    lappend PofOl($P) $O
	}
    }
    set LesPs [lsort -unique $LesP]
    set PofOl(LaListeDesPs) $LesP
    set PofOl(LaListeDesOligos) $LesOlis
    set PofOl("EstCharge") ""

    return [PofOl $Oli]
}

proc CreeBBC {{NomDeLaBanque ""} {Specif ""}} {
    return [CreeLaBanqueBlastClonage $NomDeLaBanque $Specif]
}

proc CreeLaBanqueBlastClonage {{NomDeLaBanque ""} {Specif ""}} {
    if {$NomDeLaBanque==""} { set NomDeLaBanque "All[file tail [RepertoireDuGenome]]" }

    set LesTermesSpecifs {}
    if {$Specif!=""} {
	set LesTermesSpecifs [LesVirtualPPCRsDuPGS $Specif]
	lappend LesTermesSpecifs $Specif
    }

    if {[regexp "/" $NomDeLaBanque]} {
	set RepDeLaBanque [file dirname $NomDeLaBanque]
	set NomDeLaBanque [file tail $NomDeLaBanque]
    } else {
	set RepDeLaBanque "[RepertoireDuGenome]/banques"
	set NomDeLaBanque [file tail $NomDeLaBanque]	
    }

    set Banque "$RepDeLaBanque/$NomDeLaBanque"
    while {[file exists $Banque]} {
	if {[OuiOuNon "$Banque already exists. Do I cancel CreeLaBanqueBlastClonage ?"]} { return $Banque }
	if {[OuiOuNon "$Banque already exists. Do I replace it ?"]} { break }
    }
	
#    set LesGlobs [list "nuctfa/*" "rec1/*" "rec2/*" "ppcr/*" "ppcr_virtuels/*" "oligos/*.tfa" "vecteurs/pDONR/*.tfa" "vecteurs/pDEST/*.tfa"]
    set LesGlobs [list "nuctfa/*" "ppcr_virtuels/*" "oligos/*.tfa"]
    foreach Glob $LesGlobs {
	if {[regexp "^/" $Glob]} {
	    set FiGlob $Glob
	} else {
	    set FiGlob "[RepertoireDuGenome]/$Glob"
	}
	foreach FiTFA [glob -nocomplain $FiGlob] {
	    set Queue [file tail $FiTFA]

	    if {$Specif!=""} {
		set Ok 0
		foreach Terme $LesTermesSpecifs {
		    if {[regexp {^P[0-9]+.tfa$} $Queue] || [regexp $Terme $Queue]} {set Ok 1 ; break}
		}
		if { ! $Ok } { continue }
	    }
	    Espionne "I keep $Queue"
	    if {[regexp {~$|\.20[0-9]{4,}$} $Queue]} { continue }
	    if { ! [regexp "^>" [PremiereLigneDuFichier $FiTFA]]} { continue }
	    Espionne $FiTFA
	    lappend LeTFA [ContenuDuFichier $FiTFA]
	}
    }
    SauveLesLignes $LeTFA dans $Banque
    exec formatdb -i $Banque -p F
    return $Banque
}

proc CreeLaBanqueBlastDesVecteurs {{Banque ""} {RepDestination ""} {RepVecteurs ""}} {

    if {$Banque==""} { set Banque "AllVectors" }
    if {$RepVecteurs==""} { set  RepVecteurs "[RepertoireDuGenome]/vecteurs/p*" }
    if {$RepDestination==""} { set RepDestination "[RepertoireDuGenome]/banques" }

    set FicBanque "$RepDestination/$Banque"

    while {[file exists $FicBanque]} {
	if {[OuiOuNon "$FicBanque already exists. Do I replace it ?"]} { break }
	if {[OuiOuNon "$FicBanque already exists. Do I cancel CreeLaBanqueBlastDesVecteurs ?"]} { return "" }
    }

    foreach FicTFA [glob -nocomplain "$RepVecteurs/*.tfa"] {
	lappend LesTFAs [ContenuDuFichier $FicTFA]
    }
    SauveLesLignes $LesTFAs dans $FicBanque

    NousAllonsAuBoulot $RepDestination
    if {[catch {exec formatdb -i $Banque -p F} Message]} {
	FaireLire "Error from formatdb :\n$Message"
	OnRevientDuBoulot
	return ""
    }
    OnRevientDuBoulot
    return $FicBanque
}

proc TriFragments {Page {Maniere ""} {Action ""}} {

    if {$Action==""} { set Action "Affiche" } 

    if {$Maniere==""} { set Maniere "Ask" }
    if {$Maniere=="Ask"} {
	set Maniere [ChoixParmi [list \
		"FillLimitsWith_000" \
		"FullLeftRightOnSameLine" \
		"1_3_0" \
		"0_3_1" \
		"0_" \
		"1_" \
		"2_" \
		"3_" \
		"Other"]]
    }
    if {$Maniere=="Other"} { set Maniere [Entre "0_1_2_3_"] }

    set LesLignes [split $Page "\n"]
    if {$Maniere=="FillLimitsWith_000"} {
	foreach Ligne $LesLignes {
	    if {[regexp -- {^[^_]+_([^ \-_]+\-[0-9]+\-[0-9]+)_} $Ligne Match Sujet]} {
		set LesMots [split $Sujet "-"]
		ScanLaListe $LesMots N D F
		set BeauSujet [format "%s-%4.4d-%4.4d" $N $D $F] 
		regsub -- "\-" $Sujet "\\\-" SujetRX
		regsub $SujetRX $Ligne $BeauSujet Ligne
		set DiffLong [expr [string length $BeauSujet]-[string length $Sujet]]
		set iB [string first " " $Ligne]
		regsub [string repeat " " $DiffLong] $Ligne "" Ligne
	    }
	    lappend LesLignesTriees $Ligne
	}
    } elseif {[regexp {^[0-9]+_[0-9]*} $Maniere]} {
	set Maniere [string trim $Maniere "_"]
	set LOrdre [split $Maniere "_"]
	
	set LesLignesTriees [LesLignesTrieesSurUneClefEntete $LesLignes $LOrdre]
    } elseif {$Maniere=="FullLeftRightOnSameLine"} {
	foreach Ligne $LesLignes {
	    set Entete ""
	    scan $Ligne "%s %d %d %f %f" Entete Residues Charged Molecularweight Isoelectricpoint
	    if {$Entete==""} { continue }
	    regsub "_" $Entete " " ZoNom
	    scan $ZoNom "%s %s" Zone Nom
	    if { ! [info exists DejaVu($Nom)]} { lappend LesNoms $Nom }
	    set DejaVu($Nom) 1
	    foreach Var [list Entete Residues Charged Molecularweight Isoelectricpoint] {
		set P($Nom,$Zone,$Var) [set $Var]
	    }
	}
	foreach Nom $LesNoms {
	    set ZoNom [string range "All_$Nom" 0 36]
	    set ChargedF [set P($Nom,Full,Charged)]
	    set ChargedL [set P($Nom,Left,Charged)]
	    set ChargedR [set P($Nom,Righ,Charged)]
	    set MolecularweightF [set P($Nom,Full,Molecularweight)]
	    set MolecularweightL [set P($Nom,Left,Molecularweight)]
	    set MolecularweightR [set P($Nom,Righ,Molecularweight)]
	    set IsoelectricpointF [set P($Nom,Full,Isoelectricpoint)]
	    set IsoelectricpointL [set P($Nom,Left,Isoelectricpoint)]
	    set IsoelectricpointR [set P($Nom,Righ,Isoelectricpoint)]
	    lappend LesLignesTriees [format "%-40.40s  %3d %3d %3d  %10.2f %10.2f %10.2f  %5.2f %5.2f %5.2f" \
		    $ZoNom \
		    $ChargedF $ChargedL $ChargedR \
		    $MolecularweightF $MolecularweightL $MolecularweightR \
		    $IsoelectricpointF $IsoelectricpointL $IsoelectricpointR ]
	    
	}
    } else {
	return $Page
    }
    set BellePage [join $LesLignesTriees "\n"]
    if {$Action=="Retour"} { return $BellePage }
    return [AfficheVariable $BellePage "AvecTriFragments"]
}

proc AliasPourClonage Nom {
    global AliasPourClonage
    if {[info exists AliasPourClonage($Nom)]} { return [set AliasPourClonage($Nom)] }
    set Alias ""
    if {$Alias==""} { set Alias [Alias $Nom] }
    if {$Alias==""} { set Alias [Narcisse $Nom] }
    if {$Alias==""} { set Alias $Nom }
    set AliasPourClonage($Nom) $Alias
    return $Alias
}

proc CreeLesFichiersExtension5PrimeDeRec2 Rec2 {

    set Rec2 [file tail $Rec2]
    regsub ".tfa$" $Rec2 "" Rec2

    set Titre  "Fus_$Rec2"
    set Fusion "Fus_$Rec2"
    set FiFuN "[RepertoireDuGenome]/fusion/$Fusion.nuctfa"
    set FiFuP "[RepertoireDuGenome]/fusion/$Fusion.prottfa"

    set Keep 1
    if {$Keep && [FileExists $FiFuP]} { return "$FiFuN $FiFuP" }


    set NucFusion [NucExtension5PrimeDeRec2 $Rec2]
    if {$NucFusion==""} {
	FaireLire "NucExtension5PrimeDeRec2 $Rec2\nis empty."
	return ""
    }

    
    set NucTFA [SequenceFormatTFA $NucFusion "$Titre" "nucbrut"]
    Espionne [Sauve $NucTFA dans $FiFuN]
    set ProtFusion [SeqNucToSeqPro $NucFusion]
    set ProtTFA [SequenceFormatTFA $ProtFusion "$Titre" "protbrut"]
    Espionne [Sauve $ProtTFA dans $FiFuP]
    return "$FiFuN $FiFuP"
}

proc LesLignesTrieesSurUneClefEntete {LesLignes LesIndices} {

    if {$LesIndices=={}} { return $LesLignes }

    set Indice [lindex $LesIndices 0]

    set Car "_"

    set LesLignesTriees {}
    set LesClefs {}
    foreach Ligne $LesLignes {
	set Entete ""
	scan $Ligne "%s" Entete
	if {$Entete==""} { continue }
	set LesMots [split $Entete $Car]
	set Clef [lindex $LesMots $Indice]
	lappend LesLignesPour($Clef) $Ligne
	lappend LesClefs $Clef
    }
    foreach Clef [lsort -unique $LesClefs] {
	set LesLignes [set LesLignesPour($Clef)]
	foreach Ligne $LesLignes {
	    lappend LesLignesTriees $Ligne
	}
    }
    return [LesLignesTrieesSurUneClefEntete $LesLignesTriees [lrange $LesIndices 1 end]]
}

proc PeptideSortPourLesFusionsPourCertains {} {
    FaireLire "Please select some fusions.\nI'll proceed step by step (Nxxxx)\n\
	    But First choose ONE cutting site."
    set ChoixCoupure [ChoixDUnSiteDeCoupure]
    if {$ChoixCoupure==""} { return {} }
    set LesFiFu [glob -nocomplain "[RepertoireDuGenome]/fusion/*.nuctfa"]
    set LesFiFu [lsort [ChoixDesPresents $LesFiFu]]
    if {$LesFiFu=={}} { return {} }
    set LaCharrette {}
    set OldN "Trululu"
    lappend LesFiFu "ThatsAllFolks"
    set LesReports {}
    foreach FiFu $LesFiFu {
	if { ! [regexp {/Fus_N[0-9]+_} $FiFu N]} {
	    if {$FiFu != "ThatsAllFolks"} {
		FaireLire "the file name \n$FiFu\n is not as I expected. I'll skip"
		continue
	    }
	    set N "ThatsAllFolks"
	}
	if {$OldN=="Trululu" || $N==$OldN} {
	    lappend LaCharrette $FiFu
	    set OldN $N
	    continue
	}
	if {$N!=$OldN} {
	    set R [AffichePeptideSortPourLesFusions $LaCharrette $ChoixCoupure "SansAffichage"]
	    set LaCharrette {}
	    lappend LesReports $R
	    Espionne $R
	}
	set OldN $N
    }
    return $LesReports
}

proc AffichePeptideSortPourLesFusions {{LesFiFu ""} {ChoixPourCoupure ""} {AvecAffichage ""}} {

    if {$AvecAffichage=="SansAffichage"} { set AvecAffichage 0 } else { set AvecAffichage 1 }

    if {$LesFiFu==""} {
	set LesFiFu [glob -nocomplain "[RepertoireDuGenome]/fusion/*.nuctfa"]
	set LesFiFu [ChoixDesPresents $LesFiFu]
    }
    if {$LesFiFu=="AllFusion"} {
	set LesFiFu [glob -nocomplain "[RepertoireDuGenome]/fusion/*.nuctfa"]
    }
    if {$LesFiFu==""} { return "" }

    if {[llength [split $ChoixPourCoupure " "]]==5} {
	set ChoixCoupure $ChoixPourCoupure
    } else {
	set ChoixCoupure [ChoixDUnSiteDeCoupure $ChoixPourCoupure]
    }
    set LongCoupP ""
    scan $ChoixCoupure "%s %s %d %s %d" Coupure CoupN LongCoupN CoupP LongCoupP
#    if {$LongCoupP==""} { return {} }
    foreach FiFu $LesFiFu {
	set Nom [file tail $FiFu]
	regsub ".nuctfa" $Nom "" Nom
	regsub ".prottfa" $FiFu ".nuctfa" FiFuN

	lappend LesNoms $Nom

	set SeqN [QueLaSequenceDuTFA $FiFuN]
	set SeqP [SeqNucToSeqPro $SeqN]
	set Zone(Seq) "Full"
	set LesVariablesSeq [list "Seq"]
	if {$Coupure!="SansCoupure"} {
	    set iDebutCoupure [string first $CoupN [string toupper $SeqN]]
	    set lastDebutCoupure [string last $CoupN [string toupper $SeqN]]
	    if {$iDebutCoupure!=$lastDebutCoupure} {
		FaireLire "At least two sites for $Coupure are possible. \nI'll take the first one : $iDebutCoupure"
	    }
	    if {$iDebutCoupure>=0} {
		set GaucheSeqN [string range $SeqN 0 [expr $iDebutCoupure+$LongCoupN-1]]
		set DroiteSeqN [string range $SeqN [expr $iDebutCoupure+$LongCoupN] end]
	    }
	    set GaucheSeqP [SeqNucToSeqPro $GaucheSeqN]
	    set DroiteSeqP [SeqNucToSeqPro $DroiteSeqN]
	    lappend LesVariablesSeq "GaucheSeq" "DroiteSeq"
	    set Zone(GaucheSeq) "Left"
	    set Zone(DroiteSeq) "Righ"
	}
	foreach VariableSeq $LesVariablesSeq {
	    set CR      [CodonsRares [set [set VariableSeq]N] "AvecBlanc"]
	    set PepSort [PeptideSort [set [set VariableSeq]P]]
	    if {[info exists TPep]} { unset TPep }
	    DecortiquePeptideSort $PepSort "" TPep
	    set Residues         [set TPep(Residues)]
	    set Molecularweight  [set TPep(Molecularweight)]
	    set Charged          [set TPep(Charged)]
	    set Isoelectricpoint [set TPep(Isoelectricpoint)]
	    
	    set SeqCompressee ""
	    append SeqCompressee [string range [set [set VariableSeq]P] 0 5]
	    append SeqCompressee "..."
	    append SeqCompressee [string range [set [set VariableSeq]P] end-5 end]
	    set ZoNom [string range "[set Zone($VariableSeq)]_$Nom" 0 36]
	    lappend LesFragments [format "%-40.40s %4d %3d %10.2f %5.2f %s %s" \
		    $ZoNom \
		    $Residues $Charged \
		    $Molecularweight $Isoelectricpoint \
		    $SeqCompressee \
		    $CR ]
	}
    }
    set LesFragments [LesLignesTrieesSurUneClefEntete $LesFragments [list 0 3 1]]
    if {$AvecAffichage} {
	FaireLire "I'll show you the report. Please don't forget to save it."
	AfficheVariable [join $LesFragments "\n"] "AvecTriFragments" PeptideSortSurFusion
    } else {
	set LesNR1 {}
	foreach Nom $LesNoms {
	    regsub {_[^_]+$} $Nom "" NR1
	    lappend LesNR1 $NR1
	}
	set NomFusRep [join [lsort -unique $LesNR1] "-"]
	set FichierReport "[RepertoireDuGenome]/fusionreport/${NomFusRep}_[Date].txt"
	return [SauveLesLignes $LesFragments dans $FichierReport]
    }
    return $LesFragments
}

proc PpcrEnStock {FiPpcr {Quoi ""}} {
    if { ! [regexp "/" $FiPpcr]} { set FiPpcr "[RepertoireDuGenome]/ppcr/$FiPpcr" }
    if { ! [file exists $FiPpcr]} { regsub ".tfa$" $FiPpcr "" FiPpcr }
    if { ! [file exists $FiPpcr]} { append FiPpcr ".tfa"}
    if { ! [file exists $FiPpcr]} { return "" }

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

    if {$Quoi=="TFA"} { return [ContenuDuFichier $FiPpcr] }

    set Entete [EnteteDuFichierTFA $FiPpcr "access"]
    if {$Quoi=="Header"} { return $Entete }

    regsub -nocase "^ProduitPcr_" $Entete "" Entete
    set LSAvAp [DecomposeLaLigne $Entete]
    Espionne $LSAvAp
    set Sujet [lindex $LSAvAp 0] 
    set LesAv [lindex $LSAvAp 1] 
    set LesAp [lindex $LSAvAp 2]

    if {$Quoi=="Sujet"}    { return $Sujet }
    if {$Quoi=="Signals5"} { return $LesAv }
    if {$Quoi=="Signals3"} { return $LesAp }

    set Seq [QueLaSequenceDuFichierTFA $FiPpcr]

    set SeqAv {}
    foreach Sign $LesAv {
	lappend SeqAv [string totitle [Signal $Sign]]
    }
    set SeqAv [join $SeqAv ""]
    if {$Quoi=="SeqSignals5"} { return $SeqAv }

    set SeqAp {}
    foreach Sign $LesAp {
	lappend SeqAp [string totitle [Signal $Sign]]
    }
    set SeqAp [join $SeqAp ""]
    if {$Quoi=="SeqSignals3"} { return $SeqAp }

    set SeqSujet $Seq
    regsub -nocase "^$SeqAv" $SeqSujet "" SeqSujet
    regsub -nocase "$SeqAp$" $SeqSujet "" SeqSujet

    if {$Quoi=="SeqSubject"} { return $SeqSujet }
}

proc TestNucExtension5PrimeDeRec2 FiRec2 {
    set TFA [SequenceFormatTFA [NucExtension5PrimeDeRec2 $FiRec2] "fusion" "nucbrut"]
    Espionne [Sauve $TFA dans "testfusion.tfa"]
}

proc NucExtension5PrimeDeRec2 {Rec2} {

    set Rec2 [file tail $Rec2]
    regsub ".tfa$" $Rec2 "" Rec2

    if {$Rec2!=[EnteteDuFichierTFA [Rec2 $Rec2 Fichier] "access"]} {
	FaireLire "$Rec2 is not in my rec2 database !"
	return ""
    }
    set NucTotal [Rec2 $Rec2 "Sequence"]

    set Rec1 [Rec2 $Rec2 "R1"]
    if {$Rec1!=""} {
	set N [Rec1 $Rec1 "N"]
	set NucSujet [VirtualPPCREnStock $N SeqSubject]
    } else {
	set Entete [EnteteDuFichierTFA $FiRec2]
	scan $Entete "%s" Entete
	set LesMots [split $Entete "_"]
	Espionne $LesMots
	foreach Mot $LesMots {
	    if {[EstUnSignal $Mot]} { continue }
	    if {$Mot=="Rec2"} { continue }
	    set Sujet $Mot
	    break
	}
	set NucSujet [PPCREnStock $Sujet "SeqSubject"]
    }
    if {$NucSujet==""} { return "" }
    set NucExtension5Prime [NucExtension5Prime $NucTotal $NucSujet]
    return $NucExtension5Prime
} 

proc CoOlPourTous {{Action ""}}  {
    if {$Action==""} {
	set Action [ChoixParmi [list "Show"   "RecalculateAndShow" \
		"RecalculateAndReturnPofOl"   "ReturnPofOl"\
		"RecalculateAndReturnPofPPCR" "ReturnPofPPCR"\
		"RecalculateAndReturnCoOl"    "ReturnCoOl"]]
    }

    if { [regexp "Recalculate" $Action] } {
	set FichierLesPsRejetes "[Fiches]/LesPsRejetes"
	if {[OuiOuNon "Do I run MiseAJourDesPDesExistings ?"]} {
	    MiseAJourDesPDesExist|ings
	}
	if {[OuiOuNon "Do I run PositionSurMatricePourTous ?"]} {
	    PositionSurMatricesPourTous
	}
	InventaireDesFichiersClonage
	set LesPs {}
	while {$LesPs=={}} {
	    if {[OuiOuNon "Do you want to enter a list of Oligos"]} {
		set LesPs [Entre "P2639 P2643"]
		continue
	    }
	    if {1 || [OuiOuNon "Do I use Oli to list existing oligos (instead of CloDo) ?"]} {
		set LesPs [Oli LaListeMerci]
	    } else {
		set LesPs [CloDo ListAllPlease oligos]
	    }
	}
	set CreePofPPCR [OuiOuNon "Do I recalculate all PofPPCR ?"]
	if {$CreePofPPCR} {
	    set CreeVirtualPPCR 0
	    FaireLire "Please notate that you have to rerun CoOlPourTous to create the VirtualPPCRs"
	} else {
	    set CreeVirtualPPCR [OuiOuNon "Do I create VirtualPPCRs ?"]
	}
	foreach P $LesPs {
Espionne $P
	    set TypeOli  [Oli $P Type]
	    if {$TypeOli!="SynOli"} { continue }
	    set PSujets  [Oli $P Subjects]
	    set PSignals [Oli $P Signals]
	    regsub -all "_" $PSignals " " PSigs
	    set PSens    [Oli $P Sens]
	    if {$PSens=="5'"} {
		set POliSignals " === $PSigs === "
	    } else {
		set POliSignals " ===  === $PSigs"
	    }
	    foreach Ma [MatOl $P Matrice] \
		    AA [MatOl $P AA] \
		    NA [MatOl $P NA] \
		    Or [MatOl $P Orient] \
		    Su [MatOl $P Subjects] {
Espionne "$P $AA $NA $Or $Su =$Ma="
		if {0 && [Oli $P "IsRebuildedBrockenOli"]} {
		    set Brocken [Oli $P "Brocken"] 
		    set Ma [MatOl $Brocken Subjects]
		}
		set PGS [file tail $Ma]
		set CoOl "[string repeat x 50]\n$P"
		if {$TypeOli=="MutOli"} {
		    set Code [Oli $P "CodeMutation"]
		    append CoOl "\n     $Or oligo to mutate $Code in $PGS [Alias $PGS] at $AA $NA and for $Su"   
		    lappend LeTexte "$CoOl"
		    continue
		}
		if {[Oli $P "IsBrocOli"]} {
		    set Full [Oli $P "Full"]
		    append CoOl "\n     $Or BrocOli for Full $Full for $PGS [Alias $PGS]"   
		    lappend LeTexte "$CoOl"
		    continue
		}
		if {$PGS==""} { continue }
		BaClonAppend LesOligos $PGS $P 
		set LesSujets [split $Su " "]
		append CoOl [format " %5d %5d %s %s %s %s" $AA $NA $Or $PGS [Alias $PGS] $Su]
		if {$Or=="F"} { set Sens "5'" } else { set Sens "3'" }
		set AliasDuPGS [Alias $PGS]
		foreach Sujet $LesSujets {
		    regsub {\-[0-9]+\-[0-9]+$} $Sujet "" AliasDuSujet
		    if {  ! [MemeAlias $AliasDuSujet $AliasDuPGS]} {
			AppendAuFichier $FichierLesPsRejetes "$P $PGS $AliasDuPGS $AliasDuSujet $Sujet"
			continue 
		    }
		    set LesSigPourPPCRPossibles {}
		    BaClonAppend LesSujets $PGS $Sujet
		    BaClonSet LesSujets $PGS [lsort -unique [BaClon LesSujets $PGS]]
		    BaClonAppend LesOligosDuCouple $PGS $Sujet $P
		    BaClonSet Trio $PGS $Sujet $P $AA 
		    append CoOl "\n\n        $Sujet"
		    set LesOlis [ItsOligos $Sujet]
		    if {$LesOlis==""} {
			Espionne "KO car $Sujet$POliSignals\nnot in \n$LesOlis"
			append CoOl "\n      ooooo no oligo found"
		    } else {
			set OK 0
			foreach Oli $LesOlis {
			    Espionne "Oli $Oli"
			    if { ! [string equal "$Sujet$POliSignals" $Oli]} { continue }
			    append CoOl "\n        $Oli"
			    set OK 1
			    regsub "===  ===" $POliSignals "===" SigPourPPCR
			    if { ! [regexp {=== *$} $SigPourPPCR]} { append SigPourPPCR " ===" } 
			    lappend LesSigPourPPCRPossibles $SigPourPPCR
			    lappend PofOl($Oli) $P
			    append CoOl "\n        PofOl : [join [set PofOl($Oli)] " "]"
			}
			if { ! $OK } {
			    Espionne "KO car $Sujet$POliSignals\nnot in \n$LesOlis"
			    append CoOl "\n        ooooo no corresponding signal found"
			}
		    }
		    set LesPPCR [ItsPPCR $Sujet]
		    if {$LesPPCR==""} {
			append CoOl "\n      ppppp no ppcr found"
		    } else {
			set OK 0
			foreach PPCR $LesPPCR {
			    regsub -all {\+} $PPCR "=" xPPCR
			    if { ! [regexp {=== *$} $xPPCR]} { append xPPCR " ===" } 
			    foreach SigPourPPCR $LesSigPourPPCRPossibles {
				if { ! [regexp $SigPourPPCR $xPPCR]} { continue }
				append CoOl "\n        $PPCR"
				set OK 1
				if {$CreePofPPCR} {
				    if {$Sens=="5'"} {
					P5ofPPCR $PPCR $P
				    } else {
					P3ofPPCR $PPCR $P
				    }
				}
			    }
			    if {[P5ofPPCR $PPCR]!={} && [P5ofPPCR $PPCR]!="NoValueAvailable"} {
				append CoOl "\n        P5ofPPCR : [join [P5ofPPCR $PPCR] " "]"
			    }
			    if {[P3ofPPCR $PPCR]!={} && [P3ofPPCR $PPCR]!="NoValueAvailable"} {
				append CoOl "\n        P3ofPPCR : [join [P3ofPPCR $PPCR] " "]"
			    }
			    if {    [P5ofPPCR $PPCR]!={} && [P5ofPPCR $PPCR]!="NoValueAvailable" && \
				    [P3ofPPCR $PPCR]!={} && [P3ofPPCR $PPCR]!="NoValueAvailable"} {
				if {$CreeVirtualPPCR} {
				    NewVirtualPPCR $PPCR $PGS $Sujet
				}
			    }
			}
			if { ! $OK } { append CoOl "\n     ppppp no corresponding oligo found" }
		    }
		}
		lappend LeTexte $CoOl
	    }
	}
	set LesPofOl {}
	foreach Oli [lsort [array names PofOl]] {
	    set LesPs [lsort -unique [set PofOl($Oli)]]
	    set PofOl($Oli) $LesPs
	    lappend LesPofOl "[join $LesPs " "]    $Oli"
	}
	set LesPofOl [lsort $LesPofOl]
	if {[OuiOuNon "Do I save PofOl ?"]} {
	    SauveLesLignes [array get PofOl] dans "[RepertoireDuGenome]/fiches/PofOl"
	}
	set LesPofPPCR {}
	foreach PPCR [lsort -unique [concat [P5ofPPCR LaListeDesPPCRs] [P3ofPPCR LaListeDesPPCRs]]] {
	    if {[P5ofPPCR $PPCR]!=""} {
		set LesP5s [lsort -unique [P5ofPPCR $PPCR]]
		P5ofPPCR $PPCR $LesP5s
		set P5 [join $LesP5s " "]
	    } else {
		set P5 "     "
	    } 
	    if {[P3ofPPCR $PPCR]!=""} {
		set LesP3s [lsort -unique [P3ofPPCR $PPCR]]
		P3ofPPCR $PPCR $LesP3s
		set P3 [join $LesP3s " "]
	    } else {
		set P3 "     "
	    } 
	    lappend LesPofPPCR "$P5    $PPCR" 
	    lappend LesPofPPCR "$P3    $PPCR"
	    lappend LesPofPPCR ""
	}
	if {$CreePofPPCR} {
	    P5ofPPCR Save
	    P3ofPPCR Save
	}
	if {[OuiOuNon "Do I save BaClon ?"]} { BaClon Save }    
	if { ! $CreeVirtualPPCR} {
	    FaireLire "Don't forget to rerun CoOlPourTous to create the VirtualPPCRs"
	}
    }
    if {[regexp "Show" $Action]} {

	if { ! [info exists LesPofOl]} {
	    set LesPofOl [PofOl "LesPofOl"]
	}
	set FO [AfficheVariable [join $LesPofOl "\n"]   "AvecOliAvecFiOl" "PofOligos"]

	if { ! [info exists LesPofPPCR]} {
	    set LesPofPPCR [PofPPCR]
	}
	set FP [AfficheVariable [join $LesPofPPCR "\n"] "AvecOliAvecFiPPCR" "PofPPCR"]
	if { ! [info exists LeTexte]} {
	    set LeTexte {}
	    foreach PGS [ListeDesPABs] {
		if {[BaClon LesSujets $PGS]==""} {
		    lappend LeTexte "$PGS no subjects nor oligos"
		    continue
		}
		set LesSujets [BaClon LesSujets $PGS]
		lappend LeTexte "$PGS [Alias $PGS] concerns [llength $LesSujets] subjects"
		foreach Sujet $LesSujets {
		    lappend LeTexte "       $Sujet"
		    foreach P [BaClon LesOligosDuCouple $PGS $Sujet] {
			set AA [BaClon Trio $PGS $Sujet $P]
			lappend LeTexte "          $P [format "%4d" $AA] [Oli $P Description]"
		    }
		}
		
	    }
	}
	set FC [AfficheVariable [join $LeTexte "\n"] \
		"AvecOliAvecShowItsOligosAvecFiOlAvecShowItsPPCRAvecFiPPCRAvecShowItsPPCR" \
		CoOlPourTous]
	return [list $FO $FP $FC]
    }
    return 
}

proc CreeLeTFADesEnzymesDeRestriction Fichier {
    regsub ".txt$" $Fichier ".tfa" FicEnz
    set FicEnz [FichierPourSaveAs $FicEnz]
    if {$FicEnz==""} { return "" }
    foreach Ligne [LesLignesDuFichier $Fichier] {
	set Enz ""
	set Seq ""
	scan $Ligne "%s %s" Enz Seq
	if {$Enz=="" || $Seq==""} { continue }
	lappend LesEnz ">$Enz .."
	lappend LesEnz "$Seq"
	lappend LesEnz ""
    }
    return [SauveLesLignes $LesEnz dans $FicEnz]
}

proc BlastNDeLOligoPourTous {{Banque ""}} {
    set SaveOlIgbmc 0
    set LesPs [Oli "LaListeMerci"]
    foreach P $LesPs {
	set Seq [Oli $P "Seq"]
	set FB [BlastNDeLOligo $P $Banque]
	Espionne "$P $FB"
	set Fournis [Fournisseur $P]
	set MaxEssais 3
	foreach Ligne [LesLignesDuFichier $FB] {
	    if {[regexp "^>" $Ligne] || [regexp "no hits found" $Ligne]} { break }
	    if {[regexp {^OLIGO\:} $Ligne]} {
		if { ! [incr MaxEssais -1]} { break }
		scan $Ligne "%s" BanqueId
		set LEmbl [LaSequenceDesBanques $BanqueId $BanqueId AccessOK "OnVeutEMBL"]
		set NomDansOLIGO [StringApres ":" dans $BanqueId]
		set TFA [SequenceFormatTFA [join $LEmbl "\n"] $BanqueId "embl"]
		set SeqCible [QueLaSequenceDuTexteTFA $TFA]
		set NouvelleInfo "IGBMC detected_through_a_blastn_in_OLIGO $FB"
		if {[string equal -nocase $Seq $SeqCible]} {
		    if {$Fournis=="" || $Fournis=="IGBMC"} {
			set NouveauFournis $NouvelleInfo
		    } elseif { ! [regexp $NouvelleInfo $Fournis]} {
			set NouveauFournis "$Fournis $NouvelleInfo"
		    }
		    Fournisseur $P $NouveauFournis
		    set SaveOlIgbmc 1
		    OlIgbmc $P $BanqueId
		    break 
		}
		continue
	    }
	}
    }
    if {$SaveOlIgbmc} { OlIgbmc Save }
    return
}

proc BlastNDeLOligo {P {Banque ""}} {

    if {$Banque==""} {
	set NomBanque "All[file tail [RepertoireDuGenome]]"
	set Banque "[RepertoireDuGenome]/banques/$NomBanque"
    } else {
	set NomBanque [file tail $Banque]
    }
    set FicQuery [FiSeqOl $P]
    if { ! [file exists $FicQuery]} { return "" }

    set RepBlast "[RepertoireDuGenome]/blastn$NomBanque"
    if { ! [file exists $RepBlast]} { File mkdir $RepBlast }

    set Keep [OuiOuNonMemo "Do I keep existing files in $RepBlast"]
 
    set FichierBlast "$RepBlast/$P"

    if {$Keep && [file exists $FichierBlast]} { return $FichierBlast }
    
    if {[catch {exec blastall -p blastn -d $Banque -i $FicQuery -F F -o "$FichierBlast.encours"} Message] } {
	Warne "Error during blastall for $P . I got message :\n$Message"
    }
    if { ! [file exists "$FichierBlast.encours"]} { return "" }
    File rename -force "$FichierBlast.encours" "$FichierBlast"
    
    return $FichierBlast
}

proc DepartSequencage {{LesFichiersRec1 ""} {Quoi ""}} {
    if {$LesFichiersRec1==""} {
	FaireLire "Please select the rec1 files You want to send to the Sequencing Service"
	set LesFichiersRec1 [LesFichiersDeType "Rec1"]
    }
    set RepDepartSequencage "[RepertoireDuGenome]/departsequencage" 
    if { ! [file exists $RepDepartSequencage]} { File mkdir $RepDepartSequencage }
    set FichierNDSFic "$RepDepartSequencage/nds_fichier"

    if {$LesFichiersRec1=="GetAll" && $Quoi=="Lines"} {
	if {[file exists $FichierNDSFic]} {
	    return [LesLignesDuFichier $FichierNDSFic]
	} else {
	    return {}
	}
    }
    set DernierNDS "NDS10000"
    if {[file exists $FichierNDSFic]} {
	foreach Ligne [LesLignesDuFichier $FichierNDSFic] {
	    scan $Ligne "%s %s" NDS Fichier
	    set FichierDepartSequencage($NDS) $Fichier
	    lappend NumeroDepartSequencage($Fichier) $NDS
	    set DernierNDS $NDS
	}
    }
    if {$LesFichiersRec1=="GetAll" && $Quoi=="Files"} {
	return [lsort [array names NumeroDepartSequencage]]
    }
    if {$LesFichiersRec1=="GetAll" && $Quoi=="NDS"} {
	return [lsort [array names FichierDepartSequencage]]
    }
    if {$LesFichiersRec1=="GetLast" && $Quoi=="NDS"} {
	return [lindex [lsort [array names FichierDepartSequencage]] end]
    }
    if {$LesFichiersRec1=="GetNdsOf"} {
	if {[info exists NumeroDepartSequencage($Quoi)]} {
	    return [set NumeroDepartSequencage($Quoi)]
	} else {
	    return ""
	}
    }
    if {$LesFichiersRec1=="GetFilesOf" || $LesFichiersRec1=="GetFileOf"} {
	if {[info exists FichierDepartSequencage($Quoi)]} {
	    return [set FichierDepartSequencage($Quoi)]
	} else {
	    return ""
	}
    }

    regsub "NDS" $DernierNDS "" NumDernier
    set LesNouveaux {}
    foreach Fichier $LesFichiersRec1 {
	set DernierNDS [format "NDS%5.5d" [incr NumDernier]]
	lappend LesNouveaux "$DernierNDS $Fichier"
    }
    while 1 { 
	set Texte "\n\n         Please Validate /All or //No \n\n"
	append Texte [join $LesNouveaux "\n"]
	append Texte "\n\n         Please Validate /All or //No"
	set OK [AfficheVariable $Texte "AvecRetour" "New_Departure_to_Sequencing_Service"]
	if {$OK!=""} { break }
	if {[OuiOuNon "Do I cancel Departure to Sequencing Service ?"]} { return {} }
    }
    foreach Ligne $LesNouveaux {
	scan $Ligne "%s %s" NDS Fichier
	set FichierDepartSequencage($NDS) $Fichier
	lappend NumeroDepartSequencage($Fichier) $NDS
    }
    set LesToutLeMonde {}
    foreach NDS [lsort [array names FichierDepartSequencage]] {
	lappend LesToutLeMonde "$NDS [set FichierDepartSequencage($NDS)]"
    }
    SauveLesLignes $LesToutLeMonde dans $FichierNDSFic
    return $LesNouveaux
}

proc GenereFragments {{Comment ""} {Fichier ""} {PAB ""} {FichierTFAs ""}} {
    while {$Comment==""} {
	if {[OuiOuNon "Do You want to used an already created fragment file ?"]} {
	     set Fichier [ButineArborescence "All" $Fichier]
	     if {$Fichier!=""} {
		 set Comment "FromExisting"
		 break
	     }
	 }
	if {[OuiOuNon "Do You have a file with predefined fragments ?\n\
		... containing lines as follow : \nPGS048 2 234\nPGS048 56 234\nPGS050 1 565"]} {
	    set Comment "Predefinis"
	    break
	}
	if {[OuiOuNon "Do You have a file with limits for one sequence ?\n\
		... containing lines as follow : \n1\n24\n55\n777"]} {
	    set Comment "AvecLimites"
	    break
	}
	if {[OuiOuNon "Do You want to give the limits ?"]} {
	    set Fichier "AskForLimits"
	    set Comment "AvecLimites"
	    break
	}
	if {[OuiOuNon "Do I cancel ?"]} { return "" }
     }
     set LeTFAs {}
     set LesFicN {}
     set LesFicP {}
     if {$Comment=="Predefinis"} {
	 while {$Fichier==""} {
	     FaireLire "Please browse for the file containing the fragment limits (PGS Start End(must be +1) Alias)."
	     set Fichier [ButineArborescence "All" "."]
	     if {$Fichier=="" && [OuiOuNon "Do I cancel ?"]} { return "" }
	 }

	 FaireLire "Please choose the directory to store the all isolate files (nuctfa and prottfa)"
	 set Rep [tk_chooseDirectory -mustexist 1 -initialdir "."]
	 set LesNomDuAlias {}
	 foreach Ligne [LesLignesDuFichier $Fichier] {
	     if { ! [regexp -nocase {[a-z0-9]} $Ligne]} { continue }
	     set Frag ""
	     set Alias ""
	     set AliasBis ""
	     scan $Ligne "%s %s %s %s %s" PAB Debut Fin Alias AliasBis
	     Espionne "PAB $PAB  Debut $Debut  Fin $Fin  Alias $Alias  AliasBis $AliasBis"
	     if { ! [regexp {^b?[0-9]+$} $Debut]} {
		 set Frag $Debut
		 set Debut $Fin
		 set Fin $Alias
		 set Alias $AliasBis
	     }
	     if {$Alias==""} { set Alias [AliasPourClonage $PAB] }

	     if {$Fin=="end"} {
		 set FicN "[RepertoireDuGenome]/nuctfa/$PAB"
		 set SeqN [QueLaSequenceDuFichierTFA $FicN]
		 set L [string length $SeqN]
		 set CodonEnd [string range $SeqN end-2 end]
		 if {[CodonStopPossible $CodonEnd]} {
		     set Fin [expr $L-3]
		 } else {
		     set Fin $L
		 }
		 set Fin [expr $Fin/3]
	     }

	     regexp {^([^_])+} $Alias NomDuAlias
	     if { ! [info exists DejaVu($NomDuAlias)]} { lappend LesNomDuAlias $NomDuAlias }
	     set DejaVu($NomDuAlias) 1

	     Espionne "$PAB $Frag $Debut $Fin $Alias"
	     set LesSequencesNP [IsoleUnDomaine $PAB $Debut $Fin "RetournerSeqNucAndSeqPro"]

	     ScanLaListe $LesSequencesNP SeqN SeqP

	     set FicN    "$Rep/$Alias-$Debut-$Fin.nuctfa"
	     set FicP    "$Rep/$Alias-$Debut-$Fin.prottfa"
	     set EnteteN "$Alias-$Debut-$Fin  [string length $SeqN] bases"
	     set EnteteP "$Alias-$Debut-$Fin  [string length $SeqP] AAs"
	     set TfaN [SequenceFormatTFA $SeqN $EnteteN "nucbrut"]
	     lappend LeTFAs $TfaN
	     lappend LesFicN [Sauve $TfaN dans $FicN]
	     if { ! [regexp "b" $Debut] && ! [regexp "b" $Fin] } {
		 set TfaP [SequenceFormatTFA $SeqP $EnteteP "protbrut"]
		 lappend LesFicP [Sauve $TfaP dans $FicP]
	     }
	 }
     } elseif {$Comment=="AvecLimites" || $Comment=="FromExisting"} {
	 set LesFragments {}
	 if {$Comment=="FromExisting"} {
	     set LesFragments [LesLignesDuFichier $Fichier]
	 }
	 if {$LesFragments=={} } {
	     if {$Fichier=="" && [OuiOuNon "can You browse for a file with limits ?"]} {
		 set Fichier [ButineArborescence "All" "./"]
	     }
	     if {$Fichier=="" && [OuiOuNon "Do I cancel ?"]} { return "" }
	     while {$PAB==""} {
		 FaireLire "Please enter a [PreFixe] number"
		 set PAB [Entre [PreFixe]]
		 set FichierTfa "[RepertoireDuGenome]/nuctfa/$PAB"
		 if {[file exists $FichierTfa]} { break }
		 if {[OuiOuNon "$FichierTfa\doesn't exists.\nDo I cancel ?"]} { return "" }
		 set PAB ""
	     }
	     if {$Fichier=="AskForLimits"} {
		 set Bornes ""
		 while {$Bornes==""} {
		     set SeqN [QueLaSequenceDuFichierTFA $FichierTfa]
		     set Start [string range $SeqN 0 2]
		     set Stop  [string range $SeqN end-2 end]
		     set AvantStop  [string range $SeqN end-2 end]
		     set Commentaire "($Start ... $Stop [AAduCodon $Start] [AAduCodon $Stop]) Please give the end position + 1"
		     set D 1
		     set F [string length $SeqN]
		     set Dp [expr ($D-1)/3+1]
		     set Fp [expr ($F-3)/3+1]
		     set Bornes [Entre "$Dp $Fp $Commentaire"]
		     if {$Bornes=="" && [OuiOuNon "Do I cancel ?"]} { return "" }
		 }
		 regsub { *\(.*$} $Bornes "" Bornes
		 Espionne $Bornes
		 while {[regexp "  " $Bornes]} { regsub -all "  " $Bornes " " Bornes }
		 set LesBornesDesFragments [split [string trim $Bornes] " "]
	     } else {
		 set LesBornesDesFragments [LesLignesDuFichier $Fichier]
	     }
	     set LesFragments {}
	     while {$LesFragments=={}} {
		 set LesFragments [CombineLesFragments $PAB $LesBornesDesFragments]
		 if {$LesFragments=={} && [OuiOuNon "Do I cancel GenereFragments ? "]} { return "" }
	     }
	     if {[OuiOuNon "Do I save these fragments in a file ?"]} {
		 set FicFrags [FichierPourSaveAs "./[Alias $PAB].frag"]
		 if {$FicFrags==""} { return "" }
		 SauveLesLignes $LesFragments dans $FicFrags
	     }
	 }
	 FaireLire "Please choose the directory to store the isolate files (nuctfa and prottfa)"
	 set Rep [tk_chooseDirectory -mustexist 1 -initialdir "."]
	 set LesNomDuAlias {}
	 foreach Fragment $LesFragments {
	     scan $Fragment "%s %s %s %s" PAB Frag Debut Fin
	     Espionne "$PAB $Frag $Debut $Fin"

	     set Alias [AliasPourClonage $PAB]
	     set NomDuAlias ""
	     regexp {^([^_])+} $Alias NomDuAlias
	     if { ! [info exists DejaVu($NomDuAlias)]} { lappend LesNomDuAlias $NomDuAlias }
	     set DejaVu($NomDuAlias) 1

	     set LesSequencesNP [IsoleUnDomaine $PAB $Debut $Fin "RetournerSeqNucAndSeqPro"]
	     ScanLaListe $LesSequencesNP SeqN SeqP
	     Espionne "SeqN $PAB $Frag $Debut $Fin $SeqN"
	     Espionne "SeqP $PAB $Frag $Debut $Fin $SeqP"

	     set FicN    "$Rep/$Alias-$Debut-$Fin.nuctfa"
	     set FicP    "$Rep/$Alias-$Debut-$Fin.prottfa"
	     set EnteteN "$Alias-$Debut-$Fin  [string length $SeqN] bases"
	     set EnteteP "$Alias-$Debut-$Fin  [string length $SeqP] AAs"
	     set TfaN [SequenceFormatTFA $SeqN $EnteteN "nucbrut"]
	     lappend LeTFAs $TfaN
	     lappend LesFicN [Sauve $TfaN dans $FicN]
	     if { ! [regexp "b" $Debut] && ! [regexp "b" $Fin] } {
		 set TfaP [SequenceFormatTFA $SeqP $EnteteP "protbrut"]
		 lappend LesFicP [Sauve $TfaP dans $FicP]
	     }

	 }
     }
     set NomConstruction [join $LesNomDuAlias "-"]
     while {$FichierTFAs==""} {
	 FaireLire "Please give a name for the TFAs construction file"     
	 set FichierTFAs [FichierPourSaveAs "./$NomConstruction.tfa"]
	 if {$FichierTFAs=="" && [OuiOuNon "Do I cancel GenereFragments ?"]} { return "" }
     }	 
     SauveLesLignes $LeTFAs dans $FichierTFAs
     return $FichierTFAs
}

proc AfficheLesFragmentsDeMutation Nom {
    set LesFragments [CombineLesFragments $Nom "MutationFragments"]
    Espionne $LesFragments
    while {[OuiOuNon "Do we continue to combine these fragments ?"]} {
	set LesFragments [CombineLesFragments $Nom $LesFragments]
    }
    return $LesFragments
}

proc CombineLesFragments {Nom {LesBornesDesFragments ""}} {
    JeMeSignale
    set FichierNucTFA "[RepertoireDuGenome]/nuctfa/$Nom"
    set ToutNuc [QueLaSequenceDuFichierTFA $FichierNucTFA]
    set LesFragments {}

    set FragmentsDeMutation 0
    if {$LesBornesDesFragments==""} {
	if { ! [OuiOuNon "Do You want to see the mutation fragments ?"]} { return "" }
    }
    if {$LesBornesDesFragments=="MutationFragments"} {
	set FragmentsDeMutation 1
	set Entete [EnteteDuFichierTFA $FichierNucTFA]
	if { ! [regexp { muted (.+) of } $Entete Match Codes]} {
	    FaireLire "Sorry I can't find 'muted code1 code2 code3 of' in $Entete"
	    return ""
	}
	set LesCoOrdonnes [list 1]
	foreach Code [split $Codes " "] {
	    if { ! [regexp -nocase {[a-z]} $Code]} { continue }
	    regsub {[0-9]+} [string toupper $Code] " & " Coco
	    scan $Coco "%s %d %s" AncienP PosAncienP NouveauP
	    set LongAncienP [string length $AncienP]
	    lappend LesCoOrdonnes $PosAncienP
	}
	lappend LesCoOrdonnes [expr [string length $ToutNuc]/3]
	set LesCoOrdonnes [lsort -increasing -integer $LesCoOrdonnes]
	set LesBornesDesFragments $LesCoOrdonnes
    }

    set Frag "A"
    set LesBornesDesFragmentsOK {}
    foreach X $LesBornesDesFragments {
	if {[regexp -nocase "end" $X]} { set X [expr ([string length $ToutNuc]+4)/3] }
	if { ! [regexp {[0-9]+} $X Bon]} { continue }
	lappend LesBornesDesFragmentsOK $Bon
    }
    set LesBornesDesFragments $LesBornesDesFragmentsOK
    foreach DP [lrange $LesBornesDesFragments 0 end-1] FP [lrange $LesBornesDesFragments 1 end] {
	incr FP -1
	set LesSequencesNP [IsoleUnDomaine $Nom $DP $FP "RetournerSeqNucAndSeqPro"]
	ScanLaListe $LesSequencesNP SeqN SeqP
	set PepSort [PeptideSort $SeqP]
	if {[info exists TPep]} { unset TPep }
	DecortiquePeptideSort $PepSort "" TPep
	Espionne [array get TPep]
	set Residues         [set TPep(Residues)]
	set nBases           [expr $Residues*3]
	set Molecularweight  [set TPep(Molecularweight)]
	set Charged          [set TPep(Charged)]
	set Isoelectricpoint [set TPep(Isoelectricpoint)]

	set SeqCompressee ""
	append SeqCompressee [string range $SeqP 0 5]
	append SeqCompressee "..."
	append SeqCompressee [string range $SeqP end-5 end]
	lappend LesFragments [format "%s %6s %5d %5d %4d %4d %3d %10.2f %5.2f %s" \
		$Nom \
		$Frag \
		$DP $FP \
		$Residues $nBases $Charged \
		$Molecularweight $Isoelectricpoint \
		$SeqCompressee]
	set Frag [NextALPHA $Frag]
    }
    if {[llength $LesFragments]==1} {
	set Choix [AfficheVariable [join $LesFragments "\n"] "AvecRetour" PleaseSelectContigousLines]
	if {$Choix=="" && [OuiOuNon "Do I cancel CombineLesFragments ?"]} { return "" }
	return $LesFragments
    }
    set Choix ""
    FaireLire "You can now create several contigous fragments"
    set TousLesFragments {}
    if {$FragmentsDeMutation} {
	set LesFragmentsDeMutation [TousLesSegmentsConsecutifs $LesFragments]
    }
    set Ever 1
    while $Ever {
	if {$FragmentsDeMutation} {
	    if {$LesFragmentsDeMutation=={}} {
		set OK [AfficheVariable [join $TousLesFragments "\n"] "AvecRetour" PleaseValidate]
		break
	    } else {
		set Choix [lindex $LesFragmentsDeMutation 0]
		set LesFragmentsDeMutation [lrange $LesFragmentsDeMutation 1 end]
	    }
	} else {
	    set Choix [AfficheVariable [join $LesFragments "\n"] "AvecRetour" PleaseSelectContigousLines]
	    if {$Choix=="" && \
		    [OuiOuNon "Did You choose enough fragments\n or maybe You want to reset selection"]} {
		set Tout [join $TousLesFragments "\n"]
		set Selection [AfficheVariable $Tout "AvecRetour" PleaseValidate]
		if {$Selection==""} {
		    if {[OuiOuNon "Do You want to cancel CombineFragments ?"]} { return "" }
		    if {[OuiOuNon "Do You really want to empty all selection You did ?"]} {
			set TousLesFragments {}
		    }
		    continue
		}
		if {$Selection==$Tout} { break }
		if {[OuiOuNon "Do You really want to keep only following selection\n$Selection"]} {
		    set TousLesFragments [split $Selection "\n"]
		    break
		}
		continue
	    }
	}
	Espionne $Choix
	set LeChoix [split $Choix "\n"]
	set DP ""
	set NomDuFragment ""
	foreach Fragment $LeChoix {
	    scan $Fragment "%s %s %d %d" NomLu FragLu DPlu FPlu
	    if {$DP==""} { set DP $DPlu }
	    set FP $FPlu
	    append NomDuFragment $FragLu
	}
	set LesSequencesNP [IsoleUnDomaine $Nom $DP $FP "RetournerSeqNucAndSeqPro"]
	ScanLaListe $LesSequencesNP SeqN SeqP
	set PepSort [PeptideSort $SeqP]
	if {[info exists TPep]} { unset TPep }
	DecortiquePeptideSort $PepSort "" TPep
	set Residues         [set TPep(Residues)]
	set nBases           [expr $Residues*3]
	set Molecularweight  [set TPep(Molecularweight)]
	set Charged          [set TPep(Charged)]
	set Isoelectricpoint [set TPep(Isoelectricpoint)]

	set SeqCompressee ""
	append SeqCompressee [string range $SeqP 0 5]
	append SeqCompressee "..."
	append SeqCompressee [string range $SeqP end-5 end]
	lappend TousLesFragments [format "%s %6s %5d %5d %4d %4d %3d %10.2f %5.2f %s" \
		$Nom \
		$NomDuFragment \
		$DP $FP \
		$Residues $nBases $Charged \
		$Molecularweight $Isoelectricpoint \
		$SeqCompressee]
#	AfficheVariable [join $TousLesFragments "\n"] "" TheFragmentsYouSelect]
	set Choix ""
    }
    return $TousLesFragments
}

proc NommageAuto {Access {Systeme ""} {Rep "./"}} {
    if {$Systeme==""            } { return [TmpFile] }
    if {$Systeme=="Ask_for_each"} { return [FichierPourSaveAs "$Rep/Access"] }
    if {$Systeme=="Use_access"  } { return "$Rep/$Access" }
    if {$Systeme=="Use_access_but_remove_signals"} {
	set LesVilains [Signal "LaListeDesAccess"]
	lappend LesVilains "ProduitPCR"
	set Nouveau "_${Access}_"
	foreach Vilain $LesVilains {
	    regsub -all "_${Vilain}_" $Nouveau "_" Nouveau
	}
	regsub -all "_" $Nouveau "" Nouveau
	while {$Nouveau==""} {
	    FaireLire "I removed all signals from $Access and got an empty text. how do I call the file ?"
	    set Nouveau [Entre $Access]
	}
	return "$Rep/$Nouveau"
    }
    return "$Rep/$Access"
}

proc LesFichiersUnAUnDuTFAs {Fichier {Rep ""} {Systeme ""}} {
    if {$Rep==""} { set Rep [tk_chooseDirectory -mustexist 1 -initialdir "[RepertoireDuGenome]/.."] }


    if {$Systeme=="" && [OuiOuNon "Do You want to use one of my specific naming system ?"]} {
	set Systeme [ChoixParmi [list "TmpFile" "Use_access" "Use_access_but_remove_signals" "Ask_for_each"]]
    }

    foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess"] {
	set TFA [LaSequenceDuTFAs $Fichier $Access]
	set FicTFA [NommageAuto $Access $Systeme $Rep]
	set FicTFACree [Sauve $TFA dans $FicTFA]
	lappend LesFicTFACrees $FicTFACree 
    }
    return $LesFicTFACrees
}

proc OrdaliDeLaSelection {Page Selection {NomDuFichierOrigine ""}} {
    set Reste [AfficheRognure $Page $Selection "Retour" $NomDuFichierOrigine "In"]
    OrdaliDuTexteMSF $Reste $NomDuFichierOrigine -viewer
    return $Reste
}

proc IsoleEtAfficheUnDomaineNucleique {{NomOuTexte ""} {DP ""} {FP ""}} {
    set SeqNuc [IsoleUnDomaine $NomOuTexte $DP $FP "RetournerSeqNuc"]
    return [AfficheVariable $SeqNuc "AvecFormate"]
}

proc IsoleUnDomaine {{NomOuTexte ""} {DP ""} {FP ""} {QuoiRetourner ""}} {
JeMeSignale
    Wup "QuoiRetourner can be RetournerSeqNuc RetournerSeqPro RetournerSeqNucAndSeqPro"
    Wup "QuoiRetourner can be RetournerSeqNucIfOK ..."
    Wup "otherwize QuoiRetourner is the list of the 2 filenames"

    if {[EstUnPAB $NomOuTexte]} {
	set Nom $NomOuTexte
	set FicPro "[RepertoireDuGenome]/prottfa/$Nom"
	set FicNuc "[RepertoireDuGenome]/nuctfa/$Nom"
	set SeqPro [QueLaSequenceDuFichierTFA $FicPro]
	set SeqNuc [QueLaSequenceDuFichierTFA $FicNuc]
	set Alias [AliasPourClonage $Nom]
    } elseif {[regexp "\n" $NomOuTexte] && [regexp {^>} $NomOuTexte]} {
	set FicNuc ""
	set FicPro ""
	set TFA $NomOuTexte
	set SeqNuc [QueLaSequenceDuTexteTFA $TFA]
	set LongNuc [string length $SeqNuc]
	set SeqPro [SeqNucToSeqPro $SeqNuc]
	set Entete [EnteteDuTexteTFA $TFA]
	scan $Entete "%s" Access
	regsub ">" $Access "" Access
	set Nom $Access
	set Alias $Access
    }
    set LongProt [string length $SeqPro]

    while {$FP==""} {
	FaireLire "Please enter start and stop position for the protein\n \(or 'bases nnn nnn' if nuc)"
	if {$DP==""} { set DP 1 }
	set FPpropose $LongProt
	set DN [expr ($DP-1)*3+1]
	set FN [expr ($FPpropose-1)*3+3]
	set SS [Entre "$DP $LongProt bases $DN $FN"]
	if {$SS==""} {
	    if {[OuiOuNon "Do I cancel ?"]} { return "" } else { continue }
	} 
	if {[regexp -nocase {^ *b} $SS]} {
	    catch {unset SeqPro}
	    scan $SS "%s %d %d" bidon DNlu FNlu
	    if {$DNlu<$FNlu} {
		if {($QuoiRetourner!="RetournerSeqNuc" && $QuoiRetourner!="RetournerSeqNucIfOK") \
			&& [expr ($FNlu-$DNlu+1)%3]!=0} {
		    FaireLire "$DNlu $FNlu doesn't correspond to a n*3 bases sequence. Please enter again."
		    continue 
		}
		set SeqN [string range $SeqNuc [expr $DNlu-1] [expr $FNlu-1]] 
		set DPlu [expr ($DNlu-3)/3+1]
		set FPlu [expr ($FNlu-1)/3+1]
	    } else {		
		if {($QuoiRetourner!="RetournerSeqNuc" && $QuoiRetourner!="RetournerSeqNucIfOK") \
			&& [expr ($DNlu-$FNlu+1)%3]} {
		    FaireLire "$DNlu $FNlu doesn't correspond to a n*3 bases sequence. Please enter again."
		    continue 
		}
		set SeqN [string range $SeqNuc [expr $FNlu-1] [expr $DNlu-1]] 
		set SeqN [NucToReverseAndComplementNuc $SeqN]
		set LongSeqN [string length $SeqNuc]
		set DNlu [expr $LongSeqN-$DNlu+1]
		set FNlu [expr $LongSeqN-$FNlu+1]
		set DPlu [expr ($DNlu-3)/3+1]
		set FPlu [expr ($FNlu-1)/3+1]
	    }
	} else {	    
	    set DPlu 99999
	    set FPlu -9999
	    scan $SS "%d %d" DPlu FPlu	    
	    if {$FPlu<$DPlu && [OuiOuNon "Do I reverse and complement the sequence $FPlu $DPlu ?"]} {
		catch {unset SeqPro}
		set BonneFin [strign length $SeqNuc]
		while {[expr $BonneeFin%3]} { incr BonneFin -1 }		
		set SeqNuc [string range $SeqNuc 0 [expr $BonneFin-1]]
		set SeqNuc [NucToReverseAndComplementNuc $SeqNuc]
		set SeqPro [SeqNucToSeqPro $SeqNuc]
		set NowLongPro [string length $SeqPro] 
		set DPlu [expr $NowLongProt-$DPlu+1]
		set FPlu [expr $NowLongProt-$FPlu+1]
		Espionne "$DNlu $FNlu $DPlu $FPlu"
	    }
	}
	if {[regexp "RetournerSeqNuc" $QuoiRetourner] && \
		1<=$DNlu && $DNlu<$FNlu && $FNlu<=$LongNuc}  { set DN $DNlu ; set FN $FNlu ; break }
	if {1<=$DPlu && $DPlu<$FPlu && $FPlu<=$LongProt} { set DP $DPlu ; set FP $FPlu ; break }
	FaireLire "Please choose correct limits between 1 and $LongProt" 
    }

    if {[info exists SeqN]} {
	set SeqP [SeqNucToSeqPro $SeqN]
    } else {
	set NucOnly 1
	if {[regexp "b" $DP]} {
	    regsub "b" $DP "" DN
	    set NucOnly 1
	} else {
	    set DN [expr ($DP-1)*3+1]
	}
	if {[regexp "b" $FP]} {
	    regsub "b" $FP "" FN
	    set NucOnly 1
	} else {
	    set FN [expr ($FP-1)*3+3]
	}
	set SeqN [string range $SeqNuc [expr $DN-1] [expr $FN-1]]
	if { $NucOnly } {
	    set SeqP ""
	    set FicP ""
	} else {
	    if {[info exists SeqPro]} {
		set SeqP [string range $SeqPro [expr $DP-1] [expr $FP-1]]
		set SeqPVerif [SeqNucToSeqPro $SeqN]
		if { ! [string equal -nocase $SeqP $SeqPVerif]} {
		    if {[OuiOuNon "$DN $FN\n$SeqP\n$SeqPVerif\n\
			Your protein sequence is not the exact translation of the nucleic.\n\
			Do I cancel ?"]} { return "" }
		}
	    } else {
		set SeqP [SeqNucToSeqPro $SeqN]
	    }
	}
    }
    if {$QuoiRetourner=="RetournerSeqNuc"} { return $SeqN }
    if {$QuoiRetourner=="RetournerSeqPro"} { return $SeqP }
    if {$QuoiRetourner=="RetournerSeqNucAndSeqPro"} { return [list $SeqN $SeqP] }
    
    regsub -all {.} $SeqP "&  " SeqP3
    set Retour [AfficheVariable "$SeqP3\n$SeqN" "AvecRetour" ""]
    if {$Retour==""} { return "" }

    if {$QuoiRetourner=="RetournerSeqNucIfOK"} { return $SeqN }
    if {$QuoiRetourner=="RetournerSeqProIfOK"} { return $SeqP }
    if {$QuoiRetourner=="RetournerSeqnucAndSeqProIfOK"} { return "$SeqN $SeqP" }

    while { ! [OuiOuNon "Do I save the prot and nuc in .tfa files ?"]} {
	if {[OuiOuNon "Do I cancel ?"]} { return "" }
    }


    set FicN "$Alias-$DP-$FP.nuctfa"
    set FicN [FichierPourSaveAs $FicN]

    if { ! $NucOnly } {
	set FicP "$Alias-$DP-$FP.prottfa"
	set FicP [FichierPourSaveAs $FicP]
	
	set TfaP [SequenceFormatTFA $SeqP "$Alias-$DP-$FP extracted from prot $Nom" "protbrut"]
	if {$TfaP==""} { return "" }
	Sauve $TfaP dans $FicP
    }
    set TfaN [SequenceFormatTFA $SeqN "$Alias-$DP-$FP extracted from nuc $Nom bases $DN to $FN" "protbrut"]
    if {$TfaN==""} { return "" }
    Sauve $TfaN dans $FicN

    return [list $FicP $FicN]
} 

proc SequenceDesSignaux {Signaux {Sens ""}} {

    Wup "Signaux can be a list or a text with '_' separating the signals"

    if {[regexp "_" $Signaux]} {
	set LesSignaux [split $Signaux "_"]
    } else {
	set LesSignaux $Signaux
    }

    set LesSeq {}
    foreach Signal $LesSignaux {
	lappend LesSeq [Signal $Signal]
    }
    set Seq [join $LesSeq " "]
    if {$Sens=="3'"} { set Seq [NucToReverseAndComplementNuc $Seq] }
    return $Seq
}

proc LesSujetsAvecOligos {} {
    set LesSujetsAvecOligos {}
    foreach P [Oli "LaListeMerci"] {
	foreach Sujet [Oli $P Subjects] {
	    lappend LesSujetsAvecOligos [format "%-20s %s" $Sujet $P]
	}
    }
    return $LesSujetsAvecOligos
}

proc ShowOli {Selection {Action ""}} {
    global ActionOli

    if { ! [info exists ActionOli]} { set ActionOli "All" }
    if {$Action==""} { set Action $ActionOli }
 
    if {[regexp "\n" $Selection]} {
	foreach Sel [split $Selection "\n"] {
	    ShowOli $Sel $Action
	}
	return
    }
    if {[regexp { (P[0-9]+) \-+ (P[0-9]+)} $Selection Match P1 P2]} {
	set fP1 [ShowOli $P1 $Action]
	set fP2 [ShowOli $P2 $Action]
	return "$fP1 $fP2"
    }
    if {[regexp { >(P[0-9]+) } $Selection Match P]} {
	return [ShowOli $P $Action]
    }

    if {$Action=="Choose"} {
	set Action [ChoixParmi [lrange [Oli] 2 end]]
    }
    if {$Action==""} { return "" }
    set ActionOli $Action

    set P ""
    foreach PPossible [split $Selection " "] {
	if {[regexp {^P[0-9]+$} $PPossible]} { set P $PPossible ; break}
    }
    if {$P==""} { return "" }

    if {$Action=="All"} {
	set LesInfos {}
	if {[PourWscope]} {
	    lappend LesInfos "<<<KeepChevrons<h3>Oligo <a href='[WscopeScience]&AfficheFournisseur&$P'>$P</a></h3>KeepChevrons>>>"
	}
	foreach A [lrange [Oli] 2 end-1] {
	    lappend LesInfos "\n$A :\n[Oli $P $A]"
	    if {$A=="Type"} {
		set Fournis [Fournisseur $P]
		regsub " " $Fournis "\n " Fournis
		lappend LesInfos "\nFournisseur: $Fournis"
		lappend LesInfos " [OlIgbmc $P]"
	    }
	}
	set Info [join $LesInfos "\n"]
    }  else {
	set Info "[Oli $P $Action]"
    }
    set Texte $Info
    set Fen [AfficheVariable $Texte "AvecFormateAvecBlasteAvecOli" $P]
    return $Fen
}

proc Oli {{P ""} {Quoi "Seq"}} {

    Wup "Reads the file in oligos/P.tfa using FiSeqOl"
    Wup "Quoi can be Seq TFA Sens Signals Subjects SeqSignals SeqSubject TfaSubject"

    if {$P==""} { return "Oli Pxxxx Type Description TFA Seq Sens Signals Subjects SeqSignals SeqSubject TfaSubject All" }

    if {$P=="LaListeMerci"} { return [FiSeqOl "LaListeMerci"] }
	
    set Fichier [FiSeqOl $P]
    if { ! [file exists $Fichier]} { return "" }

    set Entete [EnteteDuFichierTFA $Fichier "all"]
    if {$Entete==""} { return "" } 
    if {[regexp {\(} $Entete]} { regsub { *\(.*} $Entete "" Entete }
    regsub ">" $Entete "" Entete
    set Seq [QueLaSequenceDuFichierTFA $Fichier]

    if {$Quoi=="Seq"} { return $Seq }
    if {$Quoi=="TFA"||$Quoi=="All"} { return [ContenuDuFichier $Fichier] }

    if {$Quoi=="Description"} { return $Entete }
    if {$Quoi=="AllOnOneLine"} { return "$Entete $Seq" }
    if {[regexp "ignoreoli|oligoignore" $Entete]} {
	if {$Quoi=="Type"} { return "IgnoreOli" } 
	if {$Quoi=="SeqSubject" || $Quoi=="SeqSignals"} { return [QueLaSequenceDuFichierTFA $Fichier] }
	if {$Quoi=="TfaSubject" || $Quoi=="TfaSignals"} { return [ContenuDuFichier $Fichier] }
	if {$Quoi=="Sens"} { return "5'" }
	if {[regexp "^Is" $Quoi]} { return 0 }
	return ""
    }
    if {[regexp "SeqOli_|SeqOliRac_" $Entete Match]} {
	if {$Quoi=="Type"} { return "SeqOli" } 
	if {$Quoi=="SeqSubject" || $Quoi=="SeqSignals"} { return [QueLaSequenceDuFichierTFA $Fichier] }
	if {$Quoi=="TfaSubject" || $Quoi=="TfaSignals"} { return [ContenuDuFichier $Fichier] }
	if {$Match=="SeqOli_"} { set Sens "5'" } else { set Sens "3'" }
	if {$Quoi=="Sens"} { return $Sens }
	set Reste [StringSuivant $Match dans $Entete]
	set LesMots [LesMotsDeLaLigne $Reste]
	set LesSujets {}
	foreach Mot $LesMots {
	    set LesChamps [split $Mot "-"]
	    set Code [lindex $LesChamps end]
	    set Sujet [join [lrange $LesChamps 0 end-1] "-"]
	    lappend LesSujets $Sujet
	    lappend LesCodes $Code
	}
	set PremierCode [lindex $LesCodes 0]
	if {$Quoi=="Subjects"} { return $LesSujets }
	if {$Quoi=="CodeSequence" || $Quoi=="Signals"} { return $PremierCode }
	if {[regexp "^Is" $Quoi]} { return 0 }
	FaireLire "Please verify the call to \n[JeMeSignale Get]"
	return ""
    }
    if {[regexp "MutOli_|MutOliRac_" $Entete Match]} {
	if {$Quoi=="Type"} { return "MutOli" } 
	if {$Quoi=="SeqSubject" || $Quoi=="SeqSignals"} { return [QueLaSequenceDuFichierTFA $Fichier] }
	if {$Quoi=="TfaSubject" || $Quoi=="TfaSignals"} { return [ContenuDuFichier $Fichier] }
	if {$Match=="MutOli_"} { set Sens "5'" } else { set Sens "3'" }
	if {$Quoi=="Sens"} { return $Sens }
	set Reste [StringSuivant $Match dans $Entete]
	set LesMots [LesMotsDeLaLigne $Reste]
	set LesSujets {}
	set BonCode "x1x"
	foreach Mot $LesMots {
	    set LesChamps [split $Mot "-"]
	    set Code [lindex $LesChamps end]
	    if {$BonCode!="x1x" && $BonCode!=$Code} {
		FaireLire "I found two different mutation codes in $P"
	    }
	    set BonCode $Code
	    set Sujet [join [lrange $LesChamps 0 end-1] "-"]
	    lappend LesSujets $Sujet
	}
	if {$Quoi=="Subjects"} { return $LesSujets }
	if {$Quoi=="CodeMutation" || $Quoi=="Signals"} { return $BonCode }
	FaireLire "Please verify the call to \n[JeMeSignale Get]"
	return ""
    }
    if {$Quoi=="Type"} { return "SynOli" } 
    set Signaux ""
    scan $Entete "%s %s %s %s %s %s" Access Sens oligo with signal Signaux
    if {$Quoi=="IsBrocOli"}              { return [regexp "BrocOli " $$Entete] }
    if {$Quoi=="IsRebuildedBrockenOli"}  { return [regexp "RebuildedBrockenOli " $Entete] }
    if {$Quoi=="ItsGenericOligo"}        { return [StringApres "BrocOli with " dans $Entete] }
    if {$Quoi=="SignalsFull"}            { return [StringApres "replaces" dans $Entete] }
    if {$Quoi=="Full"}                   { return [StringApres "seeFull" dans $Entete] }
    if {$Quoi=="Brocken"}                { return [StringApres "seeBrocken" dans $Entete] }
    if {$Quoi=="Sens"}                   { return $Sens }
    if {$Quoi=="Signals"}                { return $Signaux }
    if {$Quoi=="Subjects"} {
	if {[regexp -nocase "RebuildedBrockenOli" $Entete]} {
	    set Full [StringApres "seeBrocken" dans $Entete]
	    return [Oli $Full "Subjects"]
	}
	set LesSujets {}
	foreach S [lrange [split $Entete " "] 7 end] {
	    if {[string equal -nocase $S "BrocOli"]} { break }
	    if {[string equal -nocase $S "RebuildedBrockenOli"]} { break }
	    lappend LesSujets $S
	}
	return $LesSujets
    }
    if { $Quoi=="SeqSignals" || $Quoi=="SeqSubject" || $Quoi=="TfaSubject"} {
	set SeqSignaux [SequenceDesSignaux $Signaux $Sens]
	Espionne "$Signaux $Sens $SeqSignaux"
	set Seq [QueLaSequenceDuFichierTFA $Fichier]
	regsub -all " " $SeqSignaux "" SeqSignauxSansBlancs
	regsub -all " " $Seq        "" SeqSansBlancs
	if { ! [regexp -nocase "^$SeqSignauxSansBlancs" $Seq]} {
	    FaireLire "For Oligo $P : wrong signals \n$SeqSignauxSansBlancs\nin\n$SeqSansBlancs"
	}
	if {$Quoi=="SeqSignals"} { return $SeqSignauxSansBlancs }
	if {$Quoi=="SeqSubject" || $Quoi=="TfaSubject"} {
	    regsub -nocase "^$SeqSignauxSansBlancs" $SeqSansBlancs "" SeqSubject
	    if {$Quoi=="TfaSubject"} {
		regsub ">" $Entete ">Subj_" EntetePourSubject
		regsub " with " $EntetePourSubject " without " EntetePourSubject
		set TfaSubject [SequenceFormatTFA $SeqSubject $EntetePourSubject "nucbrut"]
		return $TfaSubject
	    }
	    return $SeqSubject
	}
    }
    FaireLire "Please verify the call to \n[JeMeSignale Get]"
    return ""
}

proc LaSequenceDuTFAsMultiEntete {FichierTFAs Access} { 
    global LesSequencesDuTFAs

    Wup "Same as LaSequenceDuTFAs execept that it accepts several access on a header line"

    Wup "Loads the sequence corresponding to Access from a multiple tfa file (can be a  blast database)"
    Wup "Not sure that it works well if wrong '>b:id access'"

    if {[info exists LesSequencesDuTFAs($FichierTFAs,$Access)]} {
	return [set LesSequencesDuTFAs($FichierTFAs,$Access)]
    }
    if {[info exists LesSequencesDuTFAs($FichierTFAs)]} {
	return ""
    }
    foreach Ligne [LesLignesDuFichier $FichierTFAs] {
	if { ! [regexp -nocase {[a-z0-9_>]} $Ligne]} { continue }
	if {[regexp "^>" $Ligne]} {
	    regsub "^>" $Ligne "" Ligne
	    set LesAcessLus {}
	    foreach Champ [split $Ligne "+"] {
		set AccessLu ""
		scan $Champ "%s" AccessLu
		lappend LesAccessLus $AccessLu
		set LesSequencesDuTFAs($FichierTFAs,$AccessLu) ">$AccessLu"
		lappend LesSequencesDuTFAs($FichierTFAs,LaListeDesAccess) $AccessLu
	    }
	    continue
	}
	foreach AccessLu $LesAccessLus {
	    append LesSequencesDuTFAs($FichierTFAs,$AccessLu) "\n$Ligne"
	}
    }
    set LesSequencesDuTFAs($FichierTFAs) "SontChargees"
    return [LaSequenceDuTFAsMultiEntete $FichierTFAs $Access]
}


proc WarneReading Texte {
    global WarneReading
    global RepertoireDuGenome

    set Fichier "$RepertoireDuGenome/fiches/warne_reading"

    if { ! [info exists WarneReading]} {
	if {[file exists $Fichier]} {
	    if {0 && [OuiOuNon "Do I warne reading problems in warne_reading file ?"]} {
		set WarneReading 1
		File delete -force $Fichier
	    } else {
		set WarneReading 0
	    }
	} else {
	    set WarneReading 1
	}
    }
    if { ! $WarneReading} { return "" } 
    return [AppendAuFichier $Fichier $Texte]
}

proc Signal {{S ""} {TFAouSEQ ""}} {
    global RepertoireDuGenome
    global MemoSignaux
   
    if {$S==""} { set S "ListOf" ; set TFAouSEQ "TFA" }
    if {[PourWscope] && $S=="ListOf"} { set S "All" ; set TFAouSEQ "HTML" }

    if {$TFAouSEQ==""} { set TFAouSEQ "SEQ" }
    set TFAouSEQ [string toupper $TFAouSEQ]

    if {[info exists MemoSignaux($S,$TFAouSEQ)]} { return [set MemoSignaux($S,$TFAouSEQ)] }
    if {[info exists MemoSignaux("EstCharge")]}  { return "" }

    set MemoSignaux("EstCharge") 1
    set FichierTFAs [LeFichierDesSignaux]
    set LesAccess [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess"] 
    set MemoSignaux(LaListeDesAccess,SEQ) $LesAccess
    foreach Signal [lsort $LesAccess] {
	set TFA [LaSequenceDuTFAs $FichierTFAs $Signal]
	set MemoSignaux($Signal,TFA) $TFA
	set MemoSignaux($Signal,SEQ) [QueLaSequence $TFA]
	if {[regexp "_" $Signal]} {
	    regsub "_" $Signal "" Signal
	    set MemoSignaux($Signal,TFA) $TFA
	    set MemoSignaux($Signal,SEQ) [QueLaSequence $TFA]
	}
	lappend MemoSignaux(ListOf,SIGNALS) $Signal
	lappend MemoSignaux(ListOf,TFA) $TFA
    }
    set MemoSignaux(All,TFA) [join $MemoSignaux(ListOf,TFA) "\n"]
    set MemoSignaux(All,HTML) "<pre>\n$MemoSignaux(All,TFA)\n</pre>"
    return [Signal $S $TFAouSEQ]
}

proc MemeOligo {A B {Ap ""}} {

    if {[string equal -nocase $A $B]} { return 1 }

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

    if {$Ap && [regexp -nocase "gggtC" $B]} {
	set BonB "agaaagct$B"
	set m [Mini [string length $A] [string length $BonB]]
	incr m -1
	if {[string equal -nocase [string range $A 0 $m] [string range $BonB 0 $m]]} {
	    Espionne "Ai recupere par agaaagct \n$A\n$B"
	    return 1
	}
    }
    if {$Ap && [regexp -nocase "gaaagct" $B]} {
	set BonB "a$B"
	set m [Mini [string length $A] [string length $BonB]]
	incr m -1
	if {[string equal -nocase [string range $A 0 $m] [string range $BonB 0 $m]]} {
	    Espionne "Ai recupere par a \n$A\n$B"
	    return 1
	}
    }
   
    set lA [string length $A]
    set lB [string length $B]

    set L [expr [Mini $lA $lB] - 1 ]

    if {[expr abs($lA-$lB) > $L ]} { return 0 }

    set pA [string range $A 0 $L]
    set pB [string range $B 0 $L]

    if {[string equal -nocase $pA $pB]} {
	Espionne "Ai recupere le debordement pour \n$A\n$B"
	return 1
    }
    return 0    
}

proc FichierPpcrSansAttBAdapter Fichier {
    set Entete [EnteteDuFichierTFA $Fichier "all"]
    if { ! [regexp {AttB[12]_?Adapter} $Entete]} { return $Fichier }
    set Seq [QueLaSequenceDuFichierTFA $Fichier]
    if { ! [regexp -nocase [SEQAttB1Adapter] $Seq] && ! [regexp -nocase [SEQAttB2Adapter] $Seq]} {
	return $Fichier
    }
    if { ! [regexp [SEQAttB1] $Seq]} {
	regsub -nocase [SEQAttB1Adapter] $Seq [SEQAttB1] Seq
    }
    if { ! [regexp [SEQAttB2] $Seq]} {
	regsub -nocase [SEQAttB2Adapter] $Seq [SEQAttB2] Seq
    }
    regsub -nocase {AttB1_?Adapter} $Entete "AttB1" Entete
    regsub -nocase {AttB2_?Adapter} $Entete "AttB2" Entete

    return [Sauve [SequenceFormatTFA $Seq $Entete "nucbrut"] dans "[TmpFile].tfa"]
} 

proc UnOligoDePlusPour {P TFA} {
    set FiSeqOl [FiSeqOl $P]
    set Rep [file dirname $FiSeqOl]
    if { ! [file exists $Rep]} { file mkdir $Rep }
    if { ! [file exists $FiSeqOl]} {
	return [Sauve $TFA dans $FiSeqOl]
    }
    set LL [LesLignesDuFichier $FiSeqOl]
    set OldEntete [lindex $LL 0]
    set OldSeq  [join [lrange $LL 1 end] ""]
    set OldPSig [join [lrange [split $OldEntete " "] 0 6] " "]

    set AA [split $TFA "\n"]
    set NewEntete [lindex $AA 0]
    set NewSeq [join [lrange $AA 1 end] ""]
    set NewPSig [join [lrange [split $NewEntete " "] 0 6] " "]

    if { ! [string equal -nocase $OldSeq $NewSeq]} {
	FaireLire "Different oligo sequences for $P\n$OldSeq\n$NewSeq\n I'll keep the first one."
    }

    if { ! [string equal -nocase $OldPSig $NewPSig]} {
	FaireLire "Different oligo signal header for $P\n$OldPSig\n$NewPSig\n I'll keep the first one."
    }
    set NouvelleEntete "$OldEntete [lindex [split $NewEntete " "] end]"

    set NewLL [lreplace $LL 0 0 $NouvelleEntete]
    return [SauveLesLignes $NewLL dans $FiSeqOl]
}

proc TfaTmpFromGCG FiOl {
    set LesLignes [LesLignesDuFichier $FiOl]
    set Entete [lindex $LesLignes 1]
    set TFA [SequenceFormatTFA_l [lrange $LesLignes 2 end] $Entete "gcg"]
    return [Sauve $TFA dans "[TmpFile].tfa"] 
}

proc FiSeqOl P {

    if {$P=="LaListeMerci"} {
	foreach F [glob -nocomplain "[RepertoireDuGenome]/oligos/P*.tfa"] {
	    set NomP [file tail $F]
	    regsub ".tfa$" $NomP "" NomP
	    lappend LesPs $NomP
	}
	return $LesPs
    }

    return "[RepertoireDuGenome]/oligos/$P.tfa"
} 

proc LesSujetsDeLOligo_NOT_YET_USED {P {Action ""} {Valeur ""}} {
    if {$Action==""} { set Action "get" }

    set FiSujOl [FiSujOl $P]

    if {$Action=="get"} {
	if {$Valeur=="filename"} { return $FiSujOl }
	if {[file exists $FiSujOl]} {
	    return [LesLignesDuFichier $FiSujOl]
	} else {
	    return {} 
	}
    }
    if {$Action=="set"} {
	return [SauveLesLignes $Valeur dans $FiSujOl]
    }
    if {$Action=="append"} {
	set LesSujets [LesSujetsDeLOligo $P]
	if {[lsearch $LesSujets -exact $Valeur]<0} { lappend LesSujets $Valeur }
	SauveLesLignes $Valeur dans $FiSujOl
	return $LesSujets
    }
}

proc InventaireDeLaDatabaseClonage {} {
    set Choix [ChoixParmi [list \
	"Show_OligosTogether" \
	"Show_Oligos" \
	"Show_VirtualPPCR" \
	"Show_AllRec1" \
	"Show_AllRec2" \
	"Show_VEDidier" \
	"Show_Localisation" \
	"" \
	"Show_Matrices" \
	"Show_pDONR_pDEST" \
	"Show_pDONR" \
	"Show_pDEST" \
	"Show_Signals" \
	"Show_BrocOli" \
	"Show_GluOli" \
	"Show_pEntr" \
	"Show_CoOl" \
	"Show_Spine" \
	"" \
	"Show_RestEnzymes" \
	"Show_RestEnzymesHits" \
	"Show_RareCodon" \
	"" \
	"Browse_Oligos" \
	"Browse_PPCR" \
	]]
    switch $Choix {
	"Show_OligosTogether"  {AffichePof "AllPs"}
	"Show_Oligos"          {AffichePof}
	"Show_VirtualPPCR"     {AfficheVirtualPPCR}
	"Show_AllRec1"         {AfficheLesRec1}
	"Show_AllRec2"         {AfficheLesRec2}
	"Show_VEDidier"        {ShowVEDidier}
	"Show_Localisation"    {LocalisationDesVirtualPPCRs}
	"Show_Matrices"        {InventaireDesMatrices}
	"Show_pDONR_pDEST"     {InventaireDesVecteurs "pDONR_pDEST"}
	"Show_pDONR"           {InventaireDesVecteurs "pDONR"}
	"Show_pDEST"           {InventaireDesVecteurs "pDEST"}
	"Show_Signals"         {InventaireDesSignaux "Show"}
	"Show_BrocOli"         {InventaireDesBrocOli "Show"}
	"Show_GluOli"          {InventaireDesGluOli  "Show"}
	"Show_pEntr"           {InventaireDesPEntr   "Show"}
	"Show_Signals"         {RestrictionEnzymes}
	"Show_CoOl"            {CoOlPourTous}
	"Show_Spine"           {SpineSummary "Show"}
	"Show_RareCodon"       {AfficheSlidingCodonRarePour}
	"Show_RestEnzymes"     {ShowRestrictionEnzyme}
	"Show_RestEnzymesHits" {RestrictionEnzymesStatistics "ShowHits"}
	"Browse_Oligos"        {InventaireDesOligos}
	"Browse_PPCR"          {InventaireDesPPCR}
	default {} 
    }
    return $Choix
}

proc Canonise Construction {
    
    scan $Construction "%s" Construction

    set MemoCons $Construction

    regsub -all "hCOUP_TFII"    $Construction "hCOUP-TFII"   Construction
    regsub -all "SH1_ITK"       $Construction "SH1-ITK"      Construction
    regsub -all "TOPO_NcoI"     $Construction "TOPONcoI"     Construction
    regsub -all "AttB1_Adapter" $Construction "AttB1Adapter" Construction
    regsub -all "AttB2_Adapter" $Construction "AttB2Adapter" Construction
    if {[regexp -nocase {(EC|Y|H)(TAF|BDF|ASF|NFY[ABC])[0-9]*_[MNWDCHF0-9]+_[MNWDCHF0-9]+} $Construction Match]} {
	regsub -all "_" $Match "-" BonMatch
	regsub $Match $Construction $BonMatch Construction
    }
    if {[regexp -nocase {[a-z0-9]+_[0-9]+[_\-][0-9]+} $Construction Match]} {
	regsub -all "_" $Match "-" BonMatch
	regsub $Match $Construction $BonMatch Construction
    }
    regsub "^>" $Construction "" Construction
    return [list $Construction]
}

proc InventaireDesOligos {{Source ""}} {

    if {$Source==""} { set Source "Oli" }

    set LesPSuj {}
    switch $Source {
	"Oli" {
	    foreach P [Oli "LaListeMerci"] {
		set DesP [Oli $P "Description"]
		regsub "^>" $DesP "" DesP
		lappend LesPSuj $DesP
	    }
	}
    }
    AfficheVariable [join $LesPSuj "\n"] "AvecOli" "InventaireDesOligos"

    return 
}

proc ClonInventoryExists args {
    global ClonCollection

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

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

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

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

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

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

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

proc ClonInventory args {
    global ClonCollection

    set Quoi [join $args ","]

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

#rR set ClonCollection(LesOligos) [InventaireDesFichiersClonage "PAY" "RetournerOligos"] 
#rR set ClonCollection(LesPPCR)   [InventaireDesFichiersClonage "PAY" "RetournerPPCR"] 
    set ClonCollection(LesOligos) [InventaireDesFichiersClonage "ProGS" "RetournerOligos"] 
    set ClonCollection(LesPPCR)   [InventaireDesFichiersClonage "ProGS" "RetournerPPCR"] 
    set ClonCollection(EstCharge) 1
    if {[info exists ClonCollection($Quoi)]} { return [set ClonCollection($Quoi)] }
    return ""
}

proc TestClonage {} {

    set LesOli [ClonInventory LesOligos]


    set LesOli [ClonInventory LesOligos]
    Espionne [OligosFiles [ChoixParmi [ItsOligos [ChoixParmi $LesOli]]]]

}

proc OligosFiles Selection {
    return [ShowOligosFiles $Selection "GetThem"]
}

proc ShowOligosFiles {Selection {GetThem ""}} {
    if {[regexp "\n" $Selection]} {
	foreach TexCoAvAp [split $Selection "\n"] {
	    ShowOligosFiles $TexCoAvAp
	}
	return
    }
    set TexCoAvAp [string trim $Selection]
    if {[regexp "===$" $TexCoAvAp]} { append TexCoAvAp " " }
    set LesFichiers [ClonInventory $TexCoAvAp]
    if {$GetThem=="GetThem"} { return $LesFichiers }
    return [AfficheVariable [join $LesFichiers "\n"] "AvecDecFiOl" "OligosFilesOf$TexCoAvAp"]
}

proc ItsPPCR {Selection {NA ""}} {
    return [ShowItsPPCR $Selection $NA "GetThem"] 
}

proc ShowItsPPCR {Selection {NA ""} {GetThem ""}} {
    if {[regexp "\n" $Selection]} {
	foreach Sujet [split $Selection "\n"] {
	    ShowItsPPCR $Sujet $NA
	}
	return
    }
    set Sujet ""
    scan $Selection "%s" Sujet
    if {$Sujet==""} { return "" }

    set LesCoAvAp {}
    foreach FiCoAvAp [ClonInventory $Sujet PPCR$NA] {
	set Fichier [lindex $FiCoAvAp 0]
	set CoAvAp  [lindex $FiCoAvAp 1]
	set TexCoAvAp [join $CoAvAp " +++ "]
	lappend LesCoAvAp $TexCoAvAp
	ClonInventoryAppend $TexCoAvAp $Fichier
    }
    set LesCoAvAp [lsort -unique $LesCoAvAp]
    if {$GetThem=="GetThem"} { return $LesCoAvAp }
    set Fen [AfficheVariable [join $LesCoAvAp "\n"] "AvecFiPPCR" $Sujet]
    return $Fen
}

proc ItsOligos {Selection {NA ""}} {
    return [ShowItsOligos $Selection $NA "GetThem"] 
}

proc ShowItsOligos {Selection {NA ""} {GetThem ""}} {
    if {[regexp "\n" $Selection]} {
	foreach Sujet [split $Selection "\n"] {
	    ShowItsOligos $Sujet $NA
	}
	return
    }
    set Sujet ""
    scan $Selection "%s" Sujet
    if {$Sujet==""} { return "" }

    set LesCoAvAp {}
    foreach FiCoAvAp [ClonInventory $Sujet Oligos$NA] {
	set Fichier [lindex $FiCoAvAp 0]
	set CoAvAp  [lindex $FiCoAvAp 1]
	set TexCoAvAp [join $CoAvAp " === "]
	lappend LesCoAvAp $TexCoAvAp
	ClonInventoryAppend $TexCoAvAp $Fichier
    }
    set LesCoAvAp [lsort -unique $LesCoAvAp]
    if {$GetThem=="GetThem"} { return $LesCoAvAp }
    set Fen [AfficheVariable [join $LesCoAvAp "\n"] "AvecFiOl" $Sujet]
    return $Fen
}

proc InventaireDesFichiersClonage {{Rep ""} {OnVeut "AfficherTout"}} {
#rR depuis 2007/07/27    if {$Rep==""} { set Rep "PAY" }
    if {$Rep==""} { set Rep "ProGS" }

    if { ! [ClonInventoryExists Listes]} { ClonInventorySet Listes [Debroussaille $Rep] }

    set Listes [ClonInventory Listes]

    set LesFichiersOligos    [lindex $Listes 0]
    set LesFichiersOligos_NA [lindex $Listes 1]
    set LesFichiersPPCR      [lindex $Listes 2]
    set LesFichiersPPCR_NA   [lindex $Listes 3]
    set LesDecomposOligos    [lindex $Listes 4]
    set LesDecomposOligos_NA [lindex $Listes 5]
    set LesDecomposPPCR      [lindex $Listes 6]
    set LesDecomposPPCR_NA   [lindex $Listes 7]
    set LesFichiersSignaux   [lindex $Listes 8]
    set LesCommandesDOligos  [lindex $Listes 9]

    set TousLesAvantsGroupes {}
    set TousLesApresGroupes  {}

    ClonInventorySet Oligos Sujets {}
    foreach Fichier $LesFichiersOligos Decompo $LesDecomposOligos {
	foreach Sujet [lindex $Decompo 0] LesAv [lindex $Decompo 1] LesAp [lindex $Decompo 2] {
	    lappend TousLesAvantsGroupes [join $LesAv "_"]
	    lappend TousLesApresGroupes  [join $LesAp "_"]
	    ClonInventoryAppend $Sujet Oligos [list $Fichier [list $Sujet $LesAv $LesAp]]
	    ClonInventoryAppend Oligos Sujets $Sujet
	    set CoAvAp [list $Sujet [join $LesAv " "] [join $LesAp " "]]
	    set TexCoAvAp [join $CoAvAp " === "]
	    ClonInventoryAppend $TexCoAvAp $Fichier
	}
    }
    ClonInventorySet Oligos Sujets [lsort -unique [ClonInventory Oligos Sujets]]
    if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherOligos"} {
	set Fen [AfficheVariable [join [ClonInventory Oligos Sujets] "\n"] "AvecShowItsOligos" "ConstructionsWithOligos"]
	if {$OnVeut=="AfficherOligos"} { return $Fen }
    }
    if {$OnVeut=="RetournerOligos"} {
	return [ClonInventory Oligos Sujets]
    }

    ClonInventorySet Oligos_NA Sujets {}
    foreach Fichier $LesFichiersOligos_NA Decompo $LesDecomposOligos_NA {
	set Sujet [lindex $Decompo 0]
	set LesAv [lindex $Decompo 1]
	lappend TousLesAvantsGroupes [join $LesAv "_"]
	set LesAp [lindex $Decompo 2]
	lappend TousLesApresGroupes  [join $LesAp "_"]
	ClonInventoryAppend $Sujet Oligos_NA [list $Fichier $Decompo]
	ClonInventoryAppend Oligos_NA Sujets $Sujet
	set CoAvAp [list $Sujet [join $LesAv " "] [join $LesAp " "]]
	set TexCoAvAp [join $CoAvAp " === "]
	ClonInventoryAppend $TexCoAvAp $Fichier
    }
    ClonInventorySet Oligos_NA Sujets [lsort -unique [ClonInventory Oligos_NA Sujets]]
    if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherOligos_NA"} {
	set Fen [AfficheVariable [join [ClonInventory Oligos_NA Sujets] "\n"] "AvecShowItsOligos_NA" "ConstructionsWithOligos_NA"]
	if {$OnVeut=="AfficherOligos_NA"} { return $Fen }
    }
    if {$OnVeut=="RetournerOligos_NA"} {
	return [ClonInventory Oligos_NA Sujets]
    }

    ClonInventorySet PPCR_NA Sujets {}
    foreach Fichier $LesFichiersPPCR_NA Decompo $LesDecomposPPCR_NA {
	set Sujet [lindex $Decompo 0]
	set LesAv [lindex $Decompo 1]
	set LesAp [lindex $Decompo 2]
	ClonInventoryAppend $Sujet PPCR_NA [list $Fichier $Decompo]
	ClonInventoryAppend PPCR_NA Sujets $Sujet
	set CoAvAp [list $Sujet $LesAv $LesAp]
	set TexCoAvAp [join $CoAvAp " +++ "]
	ClonInventoryAppend $TexCoAvAp $Fichier
    }
    ClonInventorySet PPCR_NA Sujets [lsort -unique [ClonInventory PPCR_NA Sujets]]
    if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherPPCR_NA"} {
	set Fen [AfficheVariable [join [ClonInventory PPCR_NA Sujets] "\n"] "AvecShowItsPPCR_NA" "ConstructionsWithPPCR_NA"]
	if {$OnVeut=="AfficherPPCR_NA"} { return $Fen }
    }
    if {$OnVeut=="RetournerPPCR_NA"} {
	return [ClonInventory PPCR_NA Sujets]
    }

    ClonInventorySet PPCR Sujets {}
    foreach Fichier $LesFichiersPPCR Decompo $LesDecomposPPCR {
	set LesSu [lindex $Decompo 0]
	set LesAv [lindex $Decompo 1]
	set LesAp [lindex $Decompo 2]
	foreach Sujet $LesSu Avs $LesAv Aps $LesAp {
	    ClonInventoryAppend $Sujet PPCR [list $Fichier [list $Sujet $Avs $Aps]]
	    ClonInventoryAppend PPCR Sujets $Sujet
	    set CoAvAp [list $Sujet $Avs $Aps]
	    set TexCoAvAp [join $CoAvAp " +++ "]
	    ClonInventoryAppend $TexCoAvAp $Fichier
	}
    }
    ClonInventorySet PPCR Sujets [lsort -unique [ClonInventory PPCR Sujets]]
    if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherPPCR_NA"} {
	set Fen [AfficheVariable [join [ClonInventory PPCR Sujets] "\n"] "AvecShowItsPPCR" "ConstructionsWithPPCR"]
	if {$OnVeut=="AfficherPPCR"} { return $Fen }
    }
    if {$OnVeut=="RetournerPPCR"} {
	return [ClonInventory PPCR Sujets]
    }
    if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherSignaux"} {
	set Fen [AfficheVariable [join $LesFichiersSignaux "\n"] "AvecFetch" Signaux]
	if {$LesFichiersSignaux!={}} {
	    BoutonneLaFenetre $Fen "Signals inventory" "InventaireDesSignaux \[selection get\]"
	}
    }
    if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherLesAvantsGroupes"} {
	set TousLesAvantsGroupes [lsort -unique $TousLesAvantsGroupes]
	set Fen [AfficheVariable [join $TousLesAvantsGroupes "\n"] "SansFetch" AvantsGroupes]
	if {$TousLesAvantsGroupes!={}} {
	    BoutonneLaFenetre $Fen "Groups of 5' Signals inventory" "InventaireDesSignauxGroupes \[selection get\]"
	}
    }
    if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherLesApresGroupes"} {
	set TousLesApresGroupes [lsort -unique $TousLesApresGroupes]
	set Fen [AfficheVariable [join $TousLesApresGroupes "\n"] "SansFetch" ApresGroupes]
	if {$TousLesApresGroupes!={}} {
	    BoutonneLaFenetre $Fen "Groups of 3' Signals inventory" "InventaireDesSignauxGroupes \[selection get\]"
	}
    }
    if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherLesCommandesDOligos"} {
	set Fen [AfficheVariable [join $LesCommandesDOligos "\n"] "AvecOli" CommandesDOligos]
    }
}

proc InventaireDesSignaux {{Selection ""}} {
    global RepertoireDuGenome

    set Action ""
    if {$Selection=="Show"} { set Action "Show" ; set Selection "" }
    if {$Selection==""} { set Selection "[RepertoireDuGenome]/signaux/signaux.tfa" }
    
    set LeShow {}
    foreach Fichier [split $Selection "\n"] {
	if {[info exists SeqSign]} { unset SeqSign ; unset SeqPPCR }
	set LesSignaux [LesSignauxDuFichier $Fichier SeqSign SeqPPCR]

	foreach Signal $LesSignaux {
	    set Actuel [set SeqPPCR($Signal)]
	    set SIGNAL [string toupper $Signal]
	    lappend LesFichiersDuSignal($Signal) $Fichier
	    if {[info exists Sequence($SIGNAL)]} {
		set Autre  [set Sequence($SIGNAL)]
		set Actuel [set SeqPPCR($Signal)]
		if {$Autre!=$Actuel} {
		    FaireLire "$Autre\n$Actuel\n\ndon't correspond for signal $Signal in\n\
			    [join [set LesFichiersDuSignal($Signal)] \n]]"
		}
	    }
	    set Sequence($SIGNAL) $Actuel
	    set Ligne  "[format "%-20s" $Signal] $Actuel"
	    lappend LeShow $Ligne
	}
	if {$Action=="Show"} { return [AfficheVariable [join $LeShow "\n"] "" Signals_Inventory ] }
	while {[OuiOuNon "I would like to save these signals in a file. Can I do it ?"]} {
	    set BonFichierDeSignaux "$RepertoireDuGenome/signaux/bons_signaux.tfa"
	    set BonFichierDeSignaux [FichierPourSaveAs $BonFichierDeSignaux]
	    if {$BonFichierDeSignaux==""} { continue }
	    
	    foreach Signal $LesSignaux {
		set SignalAGarder($Signal) 1
	    }
	    set LeMeilleurOrdrePourLesSignaux [MorceauxChoisis [LeBonOrdrePourLesSignaux] \
		    "Please transfer all signals to the right and reorder them if necessary"]
	    foreach Signal $LeMeilleurOrdrePourLesSignaux {
		if { ! [info exists SignalAGarder($Signal)]} { continue }
		lappend LesSeqs [SequenceFormatTFA [set SeqPPCR($Signal)] "$Signal"]
		set DejaVu($Signal) 1
	    }
	    foreach Signal [array names SignalAGarder] {
		if {[info exists DejaVu($Signal)]} { continue }
		lappend LesSeqs [SequenceFormatTFA [set SeqPPCR($Signal)] "$Signal"]
		set DejaVu($Signal) 1
	    }
	    return [Sauve [join $LesSeqs "\n\n"] dans $BonFichierDeSignaux]
	}
	return [lsort -unique $LesSignaux]
    }
}

proc DecomposeLesLignesDuFichier Fichier {

    set LesSujets {}
    set LesAvants {}
    set LesApres  {}
    set EstNA 0
    foreach Ligne [CorrectionPourThrombin [LesLignesDuFichier $Fichier] $Fichier NF] {
	if {[regexp "!!NA_SEQUENCE" $Ligne]} { set EstNA 1 ; continue }
	if {$EstNA} { regsub "" $Ligne ">" Ligne }
	if { ! [regexp ">" $Ligne]} { if {$EstNA} { break } else {continue } }
	set DecTi [DecomposeLaLigne $Ligne "" $Fichier]
	set LesAv [lindex $DecTi 1]
	set LesAp [lindex $DecTi 2]
	foreach Sujet [lindex $DecTi 0] {
	    lappend LesSujets $Sujet
	    lappend LesAvants $LesAv
	    lappend LesApres  $LesAp
	}
	if {$EstNA} { break }
    }
    return [list $LesSujets $LesAvants $LesApres]
}

proc DecomposeLesLignesDuFichierOligos Fichier {

    return [DecomposeLesLignesDuFichier $Fichier]
    set LesSujets {}
    set LesAvants {}
    set LesApres  {}
    set LaSortie  {}
    foreach Ligne [CorrectionPourThrombin [LesLignesDuFichier $Fichier] $Fichier NF] {
	if { ! [regexp ">" $Ligne]} { continue }
	set DecTi [DecomposeLaLigne $Ligne "" $Fichier]
	if {[lindex $DecTi 0]=={}} { return [list {} {} {}] }
	set LesSuj [lindex $DecTi 0]
	set LesAva [lindex $DecTi 1]
	set LesApr [lindex $DecTi 2]
	if {$LesAva=={} && $LesApr=={}} {
	    FaireLire "Decomposition of oligos \n$Fichier\nsomething is wrong at line \n$Ligne"
	}
	foreach Suj $LesSuj {
	    lappend LesSujets $Suj
	    lappend LesAvants $LesAva
	    lappend LesApres  $LesApr
	}
    }
    return [list $LesSujets $LesAvants $LesApres]
}

proc DecomposeLaLigne {Ligne {AvecOuSansErreur ""} {Fichier ""}} {
    if {[regexp "SeqOli|MutOli" $Ligne]} { return [list {} {} {}] }

    while {[regexp -nocase "BrocOli" $Ligne]} {
	regsub -nocase { BrocOli.*} $Ligne "" Ligne
	set Sujets [StringSuivant " for " dans $Ligne]
	if {$Sujets==""} { break }
	set LesSujets [split $Sujets " "]
	if {[regexp "5' oligo" $Ligne]} {
	    set LesAvants [split [StringApres " with signal " dans $Ligne]] ; set LesApres {}
	} else {
	    set LesAvants {} ; set LesApres [split [StringApres " with signal " dans $Ligne]] 
	}
	return [list $LesSujets $LesAvants $LesApres]
    }
    if {[regexp -nocase "RebuildedBrockenOli " $Ligne]} { regsub -nocase {RebuildedBrockenOli .*} $Ligne "" Ligne }

    Wup "returns a list of 3 lists LesSujets LesAvants LesApres" 
    Wup "If Ligne is like  S1 Av1_Av2_Av3 Ap1_Ap2 + S2 Av1_Av2_Av3 Ap1_Ap2 + S2 Av1_Av2_Av3 Ap1_Ap2"
    Wup "it returns (S1 S2 S3) (Av1 Av2 Av3) (Ap1 Ap2)"
    Wup "(Av1 Av2 Av3) and (Ap1 Ap2) are common to S1 S2 and S3"

    if {$AvecOuSansErreur=="AvecErreur"} {
	set AvecErreur 1
    } else {
	set AvecErreur 0
    }

    set Titre [string trim $Ligne]
    if {[regexp {\+} $Titre]} {
	set LesSujets {}
	set OldAvants "bidon" 
	set OldApres  "bidon" 
	foreach Ti [split $Titre "+"] {
	    scan $Ti "%s" Ti
	    set DecTi [DecomposeLaLigne $Ti $AvecOuSansErreur $Fichier]
	    lappend LesSujets [lindex $DecTi 0] 
	    set LesAvants [lindex $DecTi 1]
	    set LesApres  [lindex $DecTi 2]
	    set Avants [join $LesAvants "_"]
	    set Apres  [join $LesApres  "_"]
	    if {$OldAvants!="bidon" && $OldAvants!=$Avants} { FaireLire "Av signals incoherent in $Ligne" }
	    if {$OldApres !="bidon" && $OldApres !=$Apres } { FaireLire "Ap signals incoherent in $Ligne" }
	}
	Wup "Une liste de sujets et les listes LesAvants et LesApres qui doivent etre identiques pour chaque sujet"
	return [list $LesSujets $LesAvants $LesApres]
    }
    set Titre [lindex [Canonise $Titre] 0]
    set LesMots [split $Titre "_"]
    if {[regexp -nocase "Produit" [lindex $LesMots 0]]} {
	set LesMots [lrange $LesMots 1 end]
    }
    set LesAvants {}
    set LesApres  {}
    set Avant 1
    foreach Mot $LesMots {
	if {[EstUnSignal $Mot]} {
	    if {$Avant} {
		lappend LesAvants $Mot
	    } else {
		lappend LesApres $Mot
	    }
	} else {
	    if {$Avant} {
		set Avant 0
		set Sujet $Mot
	    } else {
		if {$AvecErreur || [OuiOuNonMemo "I found more than 2 subjects.\nDo I stop all verifications ?"]} {
		    return [list {} {} {}]
		}
		if { ! $AvecErreur } {
		    FaireLire "$Ligne\n $Sujet and $Mot are 2 detected subjects\n\
			    May be one of them should be declared as signal.\n\
			    In that case : Please exit, create the signal and restart the program."
		}
		if {$AvecErreur || [regexp -nocase { [a-z0-9]+ } $Ligne] || \
			[regexp {^[0-9]+$} $Mot] || \
			[OuiOuNon "$Ligne\n $Sujet and $Mot are 2 detected subjects\nDo I skip $Ligne ?"]} {
		    return [list {} {} {}]
		} else {
		    append Sujet "-$Mot"
		}
	    }
	}
    }
    if {$Avant} {
	if { ! $AvecErreur} {
	    FaireLire "$Ligne\nno subject detected ...\n in $Fichier"
	    Espionne  "$Ligne\nno subject detected ...\n in $Fichier"
	}
	return [list {} $LesAvants $LesApres]
    }
    return [list $Sujet $LesAvants $LesApres]
}

proc EstUnP P {
    return [regexp {^P[0-9]+$} $P]
}

proc EstUnSignal Mot {
    global LesSignauxConnus
    global RepertoireDuGenome

    if { ! [info exists LesSignauxConnus]} {
	set LesSignauxConnus [LesSignauxDuFichier "$RepertoireDuGenome/signaux/signaux.tfa" Si Se]
	lappend LesSignauxConnus "TOPONcoI"
	lappend LesSignauxConnus "AttB1Adapter"
	lappend LesSignauxConnus "AttB2Adapter"
    }
    if {[lsearch -exact $LesSignauxConnus $Mot]<0} {
	return 0
    } else {
	return 1
    }
}

proc Debroussaille {{LesRepRestants ""}} {
    if {$LesRepRestants=="PAY"} {
	set LesRepRestants [list \
		"/genomics/link/ProGS/signaux" \
		"/genomics/link/ProGS/atelier" \
		"/home/halter/oligos" \
		"/home/arnaud/Seqdir" \
		"/home/renouf/Donnees" \
		]
    }
    if {$LesRepRestants=="ProGS"} {
	set LesRepRestants [list \
		"/genomics/link/ProGS/signaux" \
		"/genomics/link/ProGS/atelier" \
		]
    }
    set LesRapportsPPCR {} 
    set LesRapportsPPCR_NA {} 
    set LesRapportsOligos {} 
    set LesRapportsOligos_NA {} 
    set LesFichiersPPCR {} 
    set LesFichiersPPCR_NA {} 
    set LesFichiersOligos {} 
    set LesFichiersOligos_NA {} 
    set LesDecomposPPCR {} 
    set LesDecomposPPCR_NA {} 
    set LesDecomposOligos {} 
    set LesDecomposOligos_NA {} 
    set LesRapportsSequence {} 
    set LesFichiersSignaux {}
    set LesCommandesDOligos {}

    if {$LesRepRestants==""} { set LesRepRestants [list "."] }
    while {1} {
	if {[llength $LesRepRestants]==0} { break }
	set RepCourant [lindex $LesRepRestants 0]
	set LesRepRestants [lreplace $LesRepRestants 0 0]
	foreach D [glob -nocomplain -type d "$RepCourant/*"] {
	    if {[regexp -nocase "Poubelle" $D]} { continue }
	    lappend LesRepRestants $D
	}
	foreach F [glob -nocomplain -type f "$RepCourant/*"] {
	    set YaD1 0
	    set Queue [file tail $F]
	    if { ! [regexp -nocase {\.(seq|nuctfa|tfa|pep|na|txt|list)$} $Queue]} { continue }
	    if { ! ([regexp {^(olimut_|oliseq_|oligos_|ppcr_)} $Queue] \
		    || [regexp "obsolete" $Queue] \
		    || [regexp "commande" $Queue] \
		    || [regexp "existing" $Queue] \
		    || [regexp "^signaux" $Queue] )} { continue }
	    if {[regexp {commande.*\.txt$} $F]} {
		set Fournis "Invitrogen"
		lappend LesCommandesDOligos "\n$F"
		set FournisseurDejaCite 0
		foreach Ligne [LesLignesDuFichier $F] {
		    if {[regexp -nocase {SYNTHESE.+IGBMC} $Ligne]} { set Fournis "IGBMC"}
		    if {[regexp "^D1" $Ligne]} {
			set YaD1 1
			if { ! $FournisseurDejaCite} {
			    set FournisseurDejaCite 1
			    lappend LesCommandesDOligos "  $Fournis"
			}
			set Description [StringSuivant "D1: " dans $Ligne]
			if {[regexp {^P[0-9]+} $Description P]} {
			    set Fournisseur($P) "$Fournis $F"
			}
			lappend LesCommandesDOligos "$Description"
		    }
		    if {! $YaD1 && $Fournis=="IGBMC" && \
			    [regexp {^ *([0-9]+) +P[0-9]+ +} $Ligne Match Numero]} {
			if { ! $FournisseurDejaCite} {
			    set FournisseurDejaCite 1
			    lappend LesCommandesDOligos "  $Fournis"
			}
			set Description [StringSuivant "$Numero " dans $Ligne]
			set Description [string trim $Description]
			if {[regexp {^P[0-9]+} $Description P]} {
			    set Fournisseur($P) "$Fournis $F"
			}
			lappend LesCommandesDOligos "$Description"
		    }
		}
	    }
	    if {[regexp {existing.*\.list$} $F]} {
		lappend LesCommandesDOligos "\n$F"
		foreach Ligne [LesLignesDuFichier $F] {
		    if {  ! [regexp {^([^ ]+) please use (P[0-9]+)} $Ligne Match SS P]} { continue }
		    lappend LesCommandesDOligos "$P $SS"
		}
	    }
	    set NASeq 0
	    set NbLignes 0
	    if {[catch {set LesLignes [LesLignesDuFichier $F]} Message]} {
		WarneReading "Problem reading $F. I got following error message :\n$Message\nI skipp this file.\n"
		continue
	    }
	    set LesLignes [CorrectionPourThrombin $LesLignes $F NouveauNomPourF]
	    foreach Ligne $LesLignes {
		set Decompo ""
		if { ! [regexp -nocase {[0-9a-z]} $Ligne]} { continue }
		incr NbLignes
		if {$NbLignes>2 \
			|| [regexp "!!AA_SEQUENCE" $Ligne] \
			|| [regexp "ID   " $Ligne] | [regexp ">>" $Ligne] \
			|| [regexp -nocase "Reformat of" $Ligne] \
			|| [regexp {[\:\|]} $Ligne]} {
			lappend LesRapportsSequence $F
			break
		}
		if {$NASeq} {
		    if {[regexp "^ProduitPCR" $Ligne]} {
			scan $Ligne "%s" Titre
			set Decompo [DecomposeLaLigne $Titre "" $F]
			if {[lindex $Decompo 0]!={}} {
			    lappend LesRapportsPPCR_NA "$F $Decompo"
			    lappend LesFichiersPPCR_NA $F
			    lappend LesDecomposPPCR_NA $Decompo
			    break
			}
		    } elseif {[regexp -nocase {_[a-z]+} $Ligne]} {
			scan $Ligne "%s" Titre
			set Decompo [DecomposeLaLigne $Titre "" $F]
			if {[lindex $Decompo 0]!={}} {
			    lappend LesRapportsOligos_NA "$F $Decompo"
			    lappend LesFichiersOligos_NA $F
			    lappend LesDecomposOligos_NA $Decompo
			    break
			}
		    }
		    lappend LesRapportsSequence "$F $Decompo"
		    break
		}
		if {[regexp "!!NA_SEQUENCE" $Ligne]} {
		    set NASeq 1
		    continue
		}
		if {[regexp "^>ProduitPCR" $Ligne]} {
		    set Decompo [DecomposeLesLignesDuFichier $F]
		    if {[lindex $Decompo 0]!={}} {
			lappend LesRapportsPPCR "$F $Decompo"
			lappend LesFichiersPPCR $F
			lappend LesDecomposPPCR $Decompo
			break
		    }
		    lappend LesRapportsSequence "$F $Decompo"
		    break
		}
 		regsub -all {[0-9]+} $Ligne "" SansChiffre
		regsub -all -- "-" $SansChiffre "" SansChiffre
		while {[regexp "__" $SansChiffre] } {regsub -all "__" $SansChiffre "_" SansChiffre}
		if {[regexp -nocase {>[^_]+_[a-z]+} $SansChiffre]} {
		    set Decompo [DecomposeLesLignesDuFichierOligos $F]
Espionne $Decompo
		    if {[lindex $Decompo 0]!={}} {
			lappend LesRapportsOligos "$F $Decompo"
			lappend LesFichiersOligos $F
			lappend LesDecomposOligos $Decompo
			continue
		    }
		    lappend LesRapportsSequence $F
		    continue
		}
		if {[regexp -nocase {>([a-z0-9]+)} $Ligne Match Signal] && [EstUnSignal $Signal]} {
		    lappend LesFichiersSignaux $F 
		    break
		}
	    }
	}
    }
    if {0} {
	AfficheVariable [join $LesRapportsOligos    "\n"] "AvecFetch" Oligos
	AfficheVariable [join $LesRapportsOligos_NA "\n"] "AvecFetch" Oligos_NA
	AfficheVariable [join $LesRapportsPPCR      "\n"] "AvecFetch" ProduitPCR
	AfficheVariable [join $LesRapportsPPCR_NA   "\n"] "AvecFetch" ProduitPCR_NA
	AfficheVariable [join $LesRapportsSequence  "\n"] "AvecFetch" Sequences
	set Fen [AfficheVariable [join $LesFichiersSignaux "\n"] "AvecFetch" Signaux]
	if {$LesFichiersSignaux!={}} {
	    BoutonneLaFenetre $Fen "Signals inventory" "InventaireDesSignaux \[selection get\]"
	}
    }
    if {[info exists Fournisseur] && [OuiOuNon "Do I save Fournisseur of Oligos"]} {
	SauveLesLignes [array get Fournisseur] dans "[RepertoireDuGenome]/fiches/fournisseur"
    }
    return [list \
	    $LesFichiersOligos \
	    $LesFichiersOligos_NA \
	    $LesFichiersPPCR \
	    $LesFichiersPPCR_NA \
	    $LesDecomposOligos \
	    $LesDecomposOligos_NA \
	    $LesDecomposPPCR \
	    $LesDecomposPPCR_NA \
	    $LesFichiersSignaux \
	    $LesCommandesDOligos \
	    ]
}

proc LesFichiersDeType {{Type ""} {Rep ""} {GetAll ""}} {

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

#   set TypeBeton(Oligo)   1
    set TypeBeton(Signaux) 1
    set TypeBeton(pDONR) 1
    set TypeBeton(pDEST) 1

    set SpecifDesTypes(All)            ""
    set SpecifDesTypes(Fusion)         ""
    set SpecifDesTypes(Rec2)           ""
    set SpecifDesTypes(Rec1)           ""
    set SpecifDesTypes(Ppcr)           ""
    set SpecifDesTypes(Oligo)          ".tfa"
    set SpecifDesTypes(Header)         "header*"
    set SpecifDesTypes(Signaux)        "signaux"
    set SpecifDesTypes(Matrice)        ""
    set SpecifDesTypes(Construction)   "*.tfa"
    set SpecifDesTypes(pDONR)          "p*.tfa"
    set SpecifDesTypes(pDEST)          "p*.tfa"

    set RepertoireDesTypes(All)            "./"
    set RepertoireDesTypes(Fusion)         "[RepertoireDuGenome]/fusion"
    set RepertoireDesTypes(Rec2)           "[RepertoireDuGenome]/rec2"
    set RepertoireDesTypes(Rec1)           "[RepertoireDuGenome]/rec1"
    set RepertoireDesTypes(Ppcr)           "[RepertoireDuGenome]/ppcr_virtuels"
    set RepertoireDesTypes(Oligo)          "[RepertoireDuGenome]/oligos"
    set RepertoireDesTypes(Header)         "[GscopeEtc]"
    set RepertoireDesTypes(Signaux)        "[RepertoireDuGenome]/signaux"
    set RepertoireDesTypes(Matrice)        "[RepertoireDuGenome]/matrices"
    set RepertoireDesTypes(Construction)   "[RepertoireDuGenome]/constructions"
    set RepertoireDesTypes(pDONR)          "[RepertoireDuGenome]/vecteurs/pDONR"
    set RepertoireDesTypes(pDEST)          "[RepertoireDuGenome]/vecteurs/pDEST"
    
    if {[info exists SpecifDesTypes($Type)]} {
	set Specif [set SpecifDesTypes($Type)]
    } else {
	set Specif $Type
    }
    if {$Rep==""} {
	if {[info exists RepertoireDesTypes($Type)]} {
	    set Rep [set RepertoireDesTypes($Type)]
	} else {
	    set Rep $Type
	}
    }

    set LesPossibles {}
    if { ! [info exists TypeBeton($Type)] && $SpecifDesTypes($Type)!=""} {
	set Ici [pwd]
	set LesLocaux   [glob -nocomplain -type {f l} "$Ici/*$Specif*"]
	set LesLocaux2  [glob -nocomplain -type {f l} "$Ici/*/*$Specif*"]
	LConcat LesPossibles $LesLocaux
	LConcat LesPossibles $LesLocaux2
    }
    set LesCommuns  [glob -nocomplain -type {f l} "$Rep/*$Specif*"]
    set LesCommuns2 [glob -nocomplain -type {f l} "$Rep/*/*$Specif*"]
    LConcat LesPossibles $LesCommuns
    LConcat LesPossibles $LesCommuns2
    set LesPossiblesTmp [lsort -unique $LesPossibles]
    set LesPossibles {}
    foreach Possi $LesPossiblesTmp {
	if {[regexp "~$" $Possi]} { continue }
	lappend LesPossibles $Possi
    }

    if {$GetAll} { return $LesPossibles }

    set LesBons {}
    while {1} {
	set TexteType $Type
	if {$Type=="All"} { set TexteType "file" }
	set LesBons [MorceauxChoisisAndMore $LesPossibles $LesBons \
		"Please select a $TexteType in the left window and press '--->'\n\
		Reorder with 'Up' and 'Down' if necessary.\n\
		Press 'More' if you want to add your own file."]
	if {$LesBons=={} && [OuiOuNon "Do You want an empty list ?"]} { return {} }
	if {$LesBons=={} && [OuiOuNon "Do You want to select your own files ?"] \
		|| [lindex $LesBons end]=="MorePlease"} {
	    set Perso [ButineArborescence "All" "."]
	    if {$Perso!=""} { lappend LesPossibles $Perso }
	    continue 
	} elseif {[lindex $LesBons end]=="Selection"} {
	    FaireLire "Enter a regular expression to select some of these files"
	    set ExpReg [Entre "YOURTEXT"]
	    set LesNouveauxPossibles {}
	    foreach Possi $LesPossibles {
		if { ! [regexp $ExpReg $Possi]} { continue }
		lappend LesNouveauxPossibles $Possi
	    }
	    set LesPossibles $LesNouveauxPossibles
	    continue 
	} else {
	    break
	}
    }
    set LesBonsBons {}
    foreach Bon $LesBons {
	set Mot ""
	scan $Bon "%s" Mot
	if {$Mot==""} { continue }
	lappend LesBonsBons $Mot
    }
    return $LesBonsBons
}

proc GenereOligos {{Construction ""} {SavSapFavFap ""}} {

    Wup "Construction is the name of a TFAs file"
    Wup "SavSapFavFap a list of LesAvants LesApres FichierDesAvants FichierDesApres"

    while {$SavSapFavFap==""} {
	set SavSapFavFap [ChoisisFichierSignauxEtSignaux]
	if {$SavSapFavFap=={} && [OuiOuNon "Do You want an empty list of signals ?"]} { break }
	if {$SavSapFavFap=={} && [OuiOuNon "Do I cancel GenereOligos ?"]} { return {} }
    }

    if {$Construction==""} {
	FaireLire "Please choose only ONE construction file" 
	set Construction [lindex [LesFichiersDeType "Construction"] 0]
	if {$Construction=="" && [OuiOuNon "Do I cancel GenereOligos ?"]} { return {} }
    }
    set Sortie [OligosEtProduitsPCR $Construction $SavSapFavFap]
    return $Sortie
}

proc GestionDesClones {} {
    set LesEtapes [MorceauxChoisis [list \
	    10_MutateSequence \
	    11_CreateOligosForMutation \
	    13_CreateOligosForSequencing \
	    15_GenereFragments \
	    16_GenereOligos \
	    22_CommandeOligos \
	    23_StockeOligos \
	    31_RecombinaisonPremiere \
	    32_DepartSequencage \
	    33_VerificationSequencage \
	    41_RecombinaisonSeconde \
	    42_Extension5Prime \
	    51_AfficheFusionEtCoupure \
	    52_CoupureDesADNCirculaires \
	    55_OligAuto \
	    60_WebOrder \
	    70_AnalyseDesSequences] \
	    "" "Please select one or more steps to perform."]

    set SortieMutateSequence ""
    set SortieCreateOligosForMutation ""
    set SortieGenereFragments ""
    set SortieGenereOligos ""
    set FichierOligos ""
    set FichierProduitsPCR ""
    set FichierStockeOligos ""
    set SortieCommandeOligos ""
    set SortieStockeOligos ""
    set SortieRecombinaisonPremiere ""
    set SortieRecombinaisonSeconde ""
    set SortieExtension5Prime ""
    set SortieDepartSequencage ""
    set SortieVerificationSequencage ""
    set SortieCoupureDesADNCirculaires ""
    set OldEtape ""
    foreach Etape [lsort $LesEtapes] {
	regsub {[0-9A-Z]+_} $Etape "" Etape
	if {$Etape=="StockeOligos" && $OldEtape=="CommandeOligos"} { continue }
	if {$Etape=="GenereFragments" && $OldEtape=="CreateOligosForMutation"} { continue }
	if {$Etape=="GenereOligos"    && $OldEtape=="CreateOligosForMutation"} { continue }
	if {$Etape=="GenereFragments" && $OldEtape=="CreateOligosForSequencing"} { continue }
	if {$Etape=="GenereOligos"    && $OldEtape=="CreateOligosForSequencing"} { continue }
	set OldEtape $Etape
	switch -regexp $Etape {
	    "MutateSequence" {
		while 1 {
		    set FichierDesMutations ""
		    if {[OuiOuNon "Can You browse for a file with lines containing\n\
			    PGS018 PGS518 S379R -M1              ( creates PGS518 alias hRAR-M1 )\n\
			    PGS018 PGS618 S379R E245A -M2        ( creates PGS618 alias hRAR-M2 )\n\
			    PGS025 PGS525 S379R E245A =MutedRARg ( creates PGS525 alias MutedRARg )"]} {
			set FichierDesMutations [ButineArborescence "All"]
			if {$FichierDesMutations==""} { continue }
			break
		    } else {
			if {[OuiOuNon "Do You want to enter [PreFixe] and mutation code ?"]} { break }
			if {[OuiOuNon "Do we cancel MutateSequence ?"]} { continue }
			if {[OuiOuNon "Do we cancel the whole process ?"]} { return "" }
		    }
		}
		if {$FichierDesMutations==""} {
		    set SortieMutateSequence [MutateSequence]
		} else {
		    set SortieMutateSequence [MutateSequencesListedIn $FichierDesMutations]
		}
		while {[OuiOuNon "Do I save the description file of these mutations ?"]} {
		    regsub {\.codemut.*$} $FichierDesMutations "" FichierDesMutationsFaites
		    set FichierDesMutationsFaites "$FichierDesMutationsFaites.mutedone"
		    set FichierDesMutationsFaites [FichierPourSaveAs $FichierDesMutationsFaites]
		    if {$FichierDesMutationsFaites==""} { continue }
		    Sauve $SortieMutateSequence dans $FichierDesMutationsFaites
		    break
		}
	    }
	    "CreateOligosForMutation" {
		set FichierOuTexteOliMut ""
		if {$SortieMutateSequence!=""} {
		    set FichierOuTexteOliMut $SortieMutateSequence
		} else {
		    if {[OuiOuNon "can You browse for a file with lines containing\n\
			    PGS018 PGS518 S379R\n\
			    PGS018 PGS618 S379R E245A\n\
			    PGS025 PGS525 Q334T I289W P345LL"]} {
			set FichierOuTexteOliMut [ButineArborescence All]
		    }
		}
		set SortieCreateOligosForMutation [CreateOligosForMutation $FichierOuTexteOliMut]
		set FichierOligos $SortieCreateOligosForMutation
	    }
	    "CreateOligosForSequencing" {
		set FichierOuTexteOliSeq ""
		while 1 {
		    if {[OuiOuNon "Do You have a file with [PreFixe]s or fragments to sequence ?"]} {
			set FichierOuTexteOliSeq [ButineArborescence All]
		    } elseif {[OuiOuNon "Do You want to enter it ?"]} {
			FaireLire "Remember that you can add lines with (AA count)\n\
				PGS160 SeqCheck\n\
				PGS161 120 989"
			set CancelOFOFS 0
			while { $FichierOuTexteOliSeq==""} {
			    set  FichierOuTexteOliSeq [string trim [EntreTexte] "\n"]
			    Espionne $FichierOuTexteOliSeq
			    if {$FichierOuTexteOliSeq==""} {
				if {[OuiOuNon "May be You forgot to Validate\nTry again ?"]} {
				    continue
				}
				if {[OuiOuNon "Do You want to cancel CreationOfOligosForSequencing ?"]} {
				    set CancelOFOFS 1
				    break
				}			
			    }
			}
			if {$CancelOFOFS} { break }
		    }
		    if {$FichierOuTexteOliSeq!=""} { break }
		    if {[OuiOuNon "Do You want to cancel CreationOfOligosForSequencing ?"]} { break }
		}
		if {$FichierOuTexteOliSeq==""} {
		    set SortieCreateOligosForSequencing ""
		} else {
		    set SortieCreateOligosForSequencing [CreateOligosForSequencing $FichierOuTexteOliSeq]
		}
		set FichierOligos $SortieCreateOligosForSequencing
	    }
	    "GenereFragments" {
		set SortieGenereFragments [GenereFragments]
	    }
	    "GenereOligos" {
		set SortieGenereOligos [GenereOligos $SortieGenereFragments]
		set FichierOligos      [lindex $SortieGenereOligos 0]
		set FichierProduitsPCR [lindex $SortieGenereOligos 1]
	    }
	    "CommandeOligos|StockeOligos" {
		if {$FichierOligos==""} {
		    set LesFichiersOligos [LesFichiersDeType "Oligo"]
		} else {
		    set LesFichiersOligos [list $FichierOligos]
		}
		set StockeOnly ""
		if {[regexp "StockeOligos" $Etape]} {
		    set StockeOnly "StockeOnly"
		}
		set SortieCommandeOligos [CommandeOligos $LesFichiersOligos $StockeOnly]
	    }
	    "RecombinaisonPremiere" {
		set RepPPCR "[RepertoireDuGenome]/ppcr"
		if {$FichierProduitsPCR==""} {
		    set LesFichiersUnProduitPCR {}
		    foreach FichierProduitsPCR [LesFichiersDeType "Ppcr"] {
			if {[regexp "ppcr_virtuels" $FichierProduitsPCR]} {
			    set LesNouveauxFichiersUnProduitPCR [list $FichierProduitsPCR]
			} else {
			    if {[OuiOuNonMemo "Do I keep the filenames for single TFA file instead of Use_access"]} {
				if {[string first ">" [ContenuDuFichier $FichierProduitsPCR] 2]>-1} {
				    FaireLire "Attention there are more than 1 sequence in $FichierProduitsPCR\n\
					    I'll split it, using the access as filename"
				    set LesNouveauxFichiersUnProduitPCR [LesFichiersUnAUnDuTFAs $FichierProduitsPCR \
					    $RepPPCR "Use_access_but_remove_signals"]
				} else {
				    set LesNouveauxFichiersUnProduitPCR $FichierProduitsPCR
				}
			    } else {
				set LesNouveauxFichiersUnProduitPCR [LesFichiersUnAUnDuTFAs $FichierProduitsPCR \
					$RepPPCR "Use_access_but_remove_signals"]
			    }
			}
			LConcat LesFichiersUnProduitPCR $LesNouveauxFichiersUnProduitPCR
		    }
		} else {
		    set LesFichiersUnProduitPCR [LesFichiersUnAUnDuTFAs $FichierProduitsPCR \
			    $RepPPCR "Use_access_but_remove_signals"]
		}
		set FichierVecteur [LesFichiersDeType "pDONR"]
		set NomVec [file tail $FichierVecteur]
		regsub ".tfa$" $NomVec "" NomVec
		set LesFichiersRecombinaisonPremiere {}
		foreach FichierUnPPCR $LesFichiersUnProduitPCR {
		    set Queue [file tail $FichierUnPPCR]
		    regsub "\.tfa$" $Queue "" Queue
		    set FichierRecombinaison "[RepertoireDuGenome]/rec1/${Queue}_$NomVec"
		    lappend LesFichiersRecombinaisonPremiere [Recombinaison \
			    $FichierUnPPCR $FichierVecteur $FichierRecombinaison "" "Premiere"]
		}
		set SortieRecombinaisonPremiere $LesFichiersRecombinaisonPremiere
		Rec1 ReLoad
	    }
	    "DepartSequencage" {
		if {$SortieRecombinaisonPremiere!=""} {
		    set Source $SortieRecombinaisonPremiere
		} else {
		    set Source ""
		}
		set SortieDepartSequencage [DepartSequencage $Source]
	    }
	    "VerificationSequencage" {
		set Source [ChoixParmi [list "GATC" "GetMacSeq" "AskForSequence"]]
		set BanqueSpecif ""
		while {[OuiOuNon "Do I use a [PreFixe] specific \
			blast database for all sequences You'll choose" 0]} {
		    while 1 {
			set SpecifPGS [Entre [PreFixe]]
			if {[EstUnPAB $SpecifPGS]} { break }
			set SpecifPGS [NomDuAlias $SpecifPGS]
			if {[EstUnPAB $SpecifPGS]} { break }
		    }
		    if {$SpecifPGS==""} { continue }
		    set BanqueSpecif "Specif_$SpecifPGS"
		    set BanqueSpecif [CreeLaBanqueBlastClonage $BanqueSpecif $SpecifPGS]
		    break
		}
		set SortieVerificationSequencage [VerificationSequencage $Source $BanqueSpecif]
	    }
	    "RecombinaisonSeconde" {
		if {$SortieRecombinaisonPremiere!=""} {
		    set LesFichiersRecombinaisonPremiere $SortieRecombinaisonPremiere
		} else {
		    set LesFichiersRecombinaisonPremiere [LesFichiersDeType "Rec1"]
		}		    
		set LesFichierVecteur [LesFichiersDeType "pDEST"]
		set LesFichiersRecombinaisonSeconde {}
		foreach FichierRec1 $LesFichiersRecombinaisonPremiere {
		    foreach FichierVecteur $LesFichierVecteur { 
			set NomVecteur [file tail $FichierVecteur]
			regsub ".tfa$" $NomVecteur "" NomVecteur

			regsub "/rec1/" $FichierRec1 "/rec2/" FichierRec2
			regsub ".tfa$"  $FichierRec2 ""       FichierRec2
			append FichierRec2 "_$NomVecteur"
			lappend LesFichiersRecombinaisonSeconde [Recombinaison \
				$FichierRec1 $FichierVecteur $FichierRec2 "" "Seconde"]
		    }
		}
		set SortieRecombinaisonSeconde $LesFichiersRecombinaisonSeconde
		Rec2 ReLoad
	    }
	    "Extension5Prime" {
		if {$SortieRecombinaisonSeconde!=""} {
		    set LesFichiersRecombinaisonSeconde $SortieRecombinaisonSeconde
		} else {
		    set LesFichiersRecombinaisonSeconde [LesFichiersDeType "Rec2"]
		}
		set LesFiFuN {}
		foreach FichierRec2 $LesFichiersRecombinaisonSeconde {
		    set FiFuNP [CreeLesFichiersExtension5PrimeDeRec2 $FichierRec2]
		    if {$FiFuNP!=""} {
			scan $FiFuNP "%s" FiFuN
			lappend LesFiFuN $FiFuN
		    }
		}
		set SortieExtension5Prime $LesFiFuN
	    }
	    "AfficheFusionEtCoupure" {
		if {$SortieExtension5Prime!=""} {
		    set LesFiFuN $SortieExtension5Prime
		} else {
		    set LesFiFuN [LesFichiersDeType "Fusion"]
		}
		if {$LesFiFuN!=""} {
		    set LesPep [AffichePeptideSortPourLesFusions $LesFiFuN "Ask"]
		}
	    }
	    "CoupureDesADNCirculaires" {
		set SortieCoupureDesADNCirculaires [CoupureDesADNCirculaires]
	    }
	    "OligAuto" {
		set SortieOligAuto [OligAuto]
	    }
	    "WebOrder" {
		set SortieWebOrder [WebOrder]
	    }
	}
    }
}

proc VerificationSequencage {{LesFichiersDeSequences ""} {FichierOuBanqueCible ""} {FastaOuBlast ""}} {

    JeMeSignale
    Wup "LesFichiersDeSequences can be a list of TFA files, a TFAs file or GetMacSeq or AskForsequence"

    set LesFichiersCibles {}
    if {$FichierOuBanqueCible==""} { set FichierOuBanqueCible "All" }
    if {$FichierOuBanqueCible=="All"}              { set CibleEstAll  1 } else { set CibleEstAll  0 } 
    if {$FichierOuBanqueCible=="Rec1OfQuery"}      { set CibleEstRec1 1 } else { set CibleEstRec1 0 } 
    if {[regexp "/Specif_" $FichierOuBanqueCible]} { set CibleEstNom  1 } else { set CibleEstNom  0 } 

    if {$FastaOuBlast==""} {
	if {$CibleEstAll || $CibleEstNom} {
	    set FastaOuBlast "Blast"
	} else {
	    set FastaOuBlast "Fasta"
	}
    }

    if {$LesFichiersDeSequences=="AskForSequence"} {
	set LesFichiersDeSequences [LesFichiersDeType "All"]
    }

    if {$LesFichiersDeSequences=="GATC"} {
	set LesFichiersDeSequences [GetFromGATC]
    }

    if {$LesFichiersDeSequences=="GetMacSeq" || [regexp "^User_" $LesFichiersDeSequences]} {
	if {[regexp "^User_" $LesFichiersDeSequences]} {
	    set User [StringSuivant "User_" dans $LesFichiersDeSequences]
	} else {
	    set User ""
	}
	set LesFichiersDeSequences [GetMacSeq $User]
    }
    if {[llength $LesFichiersDeSequences]==0} { return {} }
    if {[llength $LesFichiersDeSequences] >1} {
	set LesBons {}
	set LesDout {}
	set UniqueBC [lindex $FichierOuBanqueCible 0]
	foreach FS $LesFichiersDeSequences BC $FichierOuBanqueCible {
	    if {$BC==""} { set BC $UniqueBC }
	    set LeRetour [VerificationSequencage $FS $BC $FastaOuBlast]
	    foreach Bon [lindex $LeRetour 0] Dou [lindex $LeRetour 1] {
		lappend LesBons $Bon
		lappend LesDout $Dou
	    } 
	}
	return [list $LesBons $LesDout]
    }

    if {[llength $LesFichiersDeSequences]==1 && [file exists $LesFichiersDeSequences]} {
	set LesFicTFA {}
	set LesCiblesAll  {}
	set LesCiblesNom  {}
	set LesCiblesRec1 {}
	foreach Access [LaSequenceDuTFAs $LesFichiersDeSequences "LaListeDesAccess"] {
	    Espionne $Access
	    set BelAccess $Access
#	    regsub -nocase {_A[12]$} $Access "" BelAccess
#	    set BelAccess "${BelAccess}_Sequenced"
	    set TFA [LaSequenceDuTFAs $LesFichiersDeSequences $Access]
	    if {[regexp -nocase {_A[12](_|$)} $Access Match]} {
		if {0 && [regexp -nocase "A2" $Match]} {
#		    set BelAccess "${BelAccess}RaC"
		    set BelAccess $Access
		    set RacSeq [NucToReverseAndComplementNuc [QueLaSequenceDuTexteTFA $TFA]]
		    set TFA [SequenceFormatTFA $RacSeq "$Access RaC by Gscope" "nucbrut"]
		}
	    }
	    set Rep "[RepertoireDuGenome]/retoursequencage"
	    set FicTFA [Sauve $TFA dans "$Rep/$BelAccess.tfa"]
	    if {$CibleEstAll} {
		lappend LesCiblesAll "[RepertoireDuGenome]/banques/AllProGS"
	    } 
	    if {$CibleEstNom} {
		lappend LesCiblesNom $FichierOuBanqueCible
	    } 
	    if {$CibleEstRec1} {
		set Queue [file tail $FicTFA]
		regsub ".tfa$" $Queue "" Queue
		regsub -nocase {_A[12](_.*|$)} $Queue "" Queue
		
		set LesCibles [LesFichiersQuiCommencentPar "${Queue}_" "[RepertoireDuGenome]/rec1/" ".tfa"]
		Espionne "$Queue $LesCibles"
		while {[llength $LesCibles]==0} {
		    if { ! [OuiOuNon "I cannot find the rec1 for $Queue. Can You help me ?" 0]} { break }
		    set UneCible [ButineArborescence "All" "[RepertoireDuGenome]/rec1/"]
		    if {$UneCible!=""} { set LesCibles [list $UneCible] ; break }
		}
		if {[llength $LesCibles]==0} { continue }
		if {[llength $LesCibles]>1} {
		    FaireLire "Please help me to choose te rec1 file"
		}
		set Cible [ChoixParmi $LesCibles]
		lappend LesCiblesRec1 $Cible
	    }
	    lappend LesFicTFA $FicTFA
	}
	if {$LesFicTFA    !={}} { set LesFichiersDeSequences $LesFicTFA }
	if {$LesCiblesAll !={}} { set LesFichiersCibles      $LesCiblesAll }
	if {$LesCiblesNom !={}} { set LesFichiersCibles      $LesCiblesNom }
	if {$LesCiblesRec1!={}} { set LesFichiersCibles      $LesCiblesRec1 }
    } else {
	if {[OuiOuNon "You submited a list of TFA files. Does it concern the same Rec1 sequence ?"]} {
	}
    }

    set LesBonsFicQuery {}
    set LesDouteuxFicQuery {}
    foreach FicQuery $LesFichiersDeSequences FicCible $LesFichiersCibles {
	Espionne "FicQuery $FicCible"
	set NomQuery [file tail $FicQuery]
	set SeqQuery [QueLaSequenceDuFichierTFA $FicQuery]
	
	Wup "if FichierOuBanqueCible is the same for all then LesFichiersCibles is empty"
	if {$FicCible==""} { set FicCible $FichierOuBanqueCible }

	set FichierTFACible $FicCible
	set SeqCible [QueLaSequenceDuFichierTFA $FichierTFACible]
	if {[regexp -nocase -indices $SeqQuery $SeqCible]} {
	    lappend LesBonsFicQuery $FicQuery
	    continue
	}

	regsub {\.[^\.]*$} $FicCible "" NomCible
	set Banque "$NomCible"
	if { $FastaOuBlast=="Blast" && (! [file exists $FichierTFACible] || ! [file exists "$Banque.nhr"])} {
	    set Banque [CreeBanqueBlastDuFichier $FicCible $NomCible]
	}
	set FichierTFACible $Banque

	set FichierBlast "[RepertoireDuGenome]/retoursequencage/blast/$NomQuery"
	regsub ".tfa$" $FichierBlast "" FichierBlast
	append FichierBlast ".blast"
	if {$FastaOuBlast=="Blast"} {
	    if {[catch { exec blastall -p blastn -d $Banque -i $FicQuery -F F -v 2000 -b 2000 -o $FichierBlast } Message]} {
		FaireLire "I got an error from exec blastall with message\n$Message"
		continue
	    }	    
	} else {
	    regsub ".blast$" $FichierBlast ".fasta" FichierFasta
	    Espionne "Je vais faire FastaN $FicQuery $Banque $FichierBlast"
	    BlastNAvecFastaN $FicQuery $Banque.tfa $FichierBlast $FichierFasta
	}
	set OnTeste 1
	set OnRange 0
	if {$OnTeste} {
	    set Val [VerificationSequencageApprofondie $FicQuery $FichierBlast "Show" "AvecRetour"]
	    if {$Val==""} { set Val 0 } else { set Val 1 }
	    if {$Val} {
		lappend LesBonsFicQuery $FicQuery
	    } else {
		lappend LesDouteuxFicQuery $FicQuery
	    }
	}
	if {$OnRange} {
	    DecortiqueBlast $FichierBlast "SansSeuilExpect" "SansLimiteDeNombre" \
		    Query lBanqueId lAccess lDE lProfil lPN]
	    
	}
    }
    return [list $LesBonsFicQuery $LesDouteuxFicQuery]
}

proc GetFromGATC {{SourceDir ""} {LocalDir ""}} {

    if {$LocalDir==""} {
	FaireLire "Please browse for the local directory to store the .tfa files"
	set LocalDir [tk_chooseDirectory -mustexist 1 -initialdir "./"]
	if {$LocalDir==""} { return "" }
    }

    if {$SourceDir==""} {
	FaireLire "Please browse for the directory containing the .seq sequences"
	set Rep [tk_chooseDirectory -mustexist 1 -initialdir "[pwd]"]
	if {$Rep==""} { return "" }
	set SourceDir $Rep
    }
    set LesDispos [lsort [glob -nocomplain -type f "$SourceDir/*.seq"]]

    set LesChoix [MorceauxChoisis $LesDispos]

    set LesFichiersTFA {}
    set LesSeq {}
    foreach Choix $LesChoix {
	set Queue [file tail $Choix]
	regsub ".seq$" $Queue "" NomDeBapteme
	set Destin "$LocalDir/$NomDeBapteme.tfa"
	if {[file exists $Destin]} {
	    if { ! [OuiOuNon "$Destin already exists.\n Do I overwrite ?"]} { continue }
	}
	set Seq [ContenuDuFichier $Choix]
	if {[regexp "edited with PhredPhrap" $Seq]} {
	    set ID [StringApres "ID: " dans $Seq]
	    if {$ID==$NomDeBapteme} {
		regsub ">" $Seq ">$ID " Seq
	    } else {
		FaireLire "$Choix contains no ID with $ID\n$Seq"
	    }
	    set FichierTFA [Sauve $Seq dans $Destin]
	} else {
	    FaireLire "I didn't find 'edited with PhredPhrap' in $Choix\nI'll continue expecting fastaformat,  gcgformat or raw sequence"
	    if {[regexp {^>} $Seq]} {
		set TFA $Seq
	    } elseif {[regexp {\.\. *\n} $Seq]} {
		set TFA [SequenceFormatTFA $Seq $NomDeBapteme "gcgmaybe"]
	    } else {
		regsub -all {[ \n\t0-9]} $Seq "" Seq
		if {[regexp -nocase {[^ATGCN]} $Seq]} {
		    FaireLire "The sequence file $Choix contains illegal characters\n$Seq"
		}
		set TFA [SequenceFormatTFA $Seq $NomDeBapteme "nucbrut"]
	    }
	    set FichierTFA [Sauve $TFA dans $Destin]
	}
	lappend LesFichiersTFA $FichierTFA
    }
    return $LesFichiersTFA
}

proc GetMacSeq {{SourceDir ""} {LocalDir ""} {User ""}} {

    set RepDe(huet)     "titus:/us1/user/SEQUENCEUR/HUET_Tiphaine"
    set RepDe(eiler)    "titus:/us1/user/SEQUENCEUR/EILER_Sylvia"
    set RepDe(dock)     "titus:/us1/user/SEQUENCEUR/Dock-Bregeon"
    set RepDe(wassim)   "titus:/us1/user/SEQUENCEUR/ABDULRAHMAN_Wassim"
    set RepDe(fmichel)  "titus:/us1/user/SEQUENCEUR/MICHEL_Fabrice"
    set RepDe(djbusso)  "titus:/us1/user/SEQUENCEUR/BUSSO_Didier"
    set RepDe(arnaud)   "titus:/us1/user/SEQUENCEUR/POTERSZMAN_Arnaud"
    set RepDe(flatter)  "titus:/us1/user/SEQUENCEUR/FLATTER_Eric"
    set RepDe(desseric) "titus:/us1/user/SEQUENCEUR/DESSERICH_Vincent"
    set RepDe(brelivet) "titus:/us1/user/SEQUENCEUR/BRELIVET_Yann"
    set RepDe(bey)      "titus:/us1/user/SEQUENCEUR/BEY_Gilbert"
    set RepDe(iwema)    "titus:/us1/user/SEQUENCEUR/IWEMA_Thomas"
    set RepDe(billas)   "titus:/us1/user/SEQUENCEUR/BILLAS_Isabelle"
    set RepDe(flatter)  "titus:/us1/user/SEQUENCEUR/FLATTER_Eric"
    set RepDe(ruff)     "titus:/us1/user/SEQUENCEUR/RUFF_Marc"
    set RepDe(eddy)     "titus:/us1/user/SEQUENCEUR/TROESCH_Edouard"
    set RepDe(troffer)  "titus:/us1/user/SEQUENCEUR/TROFFER-Nathalie"
    set RepDe(uhring)   "titus:/us1/user/SEQUENCEUR/UHRING_Muriel"
    set RepDe(ripp)     "titus:[HomeRipp]/SEQUENCAGE"
    foreach U [lsort [array names RepDe]] {
	lappend LesRepDe [set RepDe($U)]
    }
    lappend LesRepDe "Other"

    if {$LocalDir==""} {
	FaireLire "Please browse for the local directory to store the tfa files"
	set LocalDir [tk_chooseDirectory -mustexist 1 -initialdir "./"]
	if {$LocalDir==""} { return "" }
    }

    if {[regexp "titus\:" $SourceDir] || \
	    ($SourceDir=="" && \
	    [OuiOuNon "Do I connect to titus to search for sequences ?"])} {
	global env
	if {$User==""} { set User [set env(USER)] }
	while { ! [OuiOuNon "Do I use User $User to connect to Titus ?"]} {
	    set User [Entre $User]
	    if {$User=="" && [OuiOuNon "Do I cancel GetMacSeq ?"]} { return "" }
	}
	set SourceDir "titus:/us1/user/SEQUENCEUR/[string totitle $User]"
	if {[info exists RepDe($User)]} { set SourceDir [set RepDe($User)] }
	while { ! [OuiOuNon "Do I search in \n$SourceDir directory ?"]} {
	    set SourceDir [ChoixParmi $LesRepDe]
	    if {$SourceDir!="Other" && $SourceDir!=""} { break } 
	    set SourceDir [Entre $SourceDir]
	    if {$SourceDir=="" && [OuiOuNon "Do I cancel GetMacSeq ?" ]} { return "" } 
	}
	regsub "^titus\:" $SourceDir "" UserDir
	set Dispos [exec rsh titus -l $User ls $UserDir/*.seq]
	if {$Dispos==""} { return "" }
    } elseif { $SourceDir!="" || [OuiOuNon "Do I browse for raw DNA files ?"]} {
	    set Rep [tk_chooseDirectory -mustexist 1 -initialdir "[pwd]"]
	    if {$Rep==""} { return "" }
	    set Dispos [join [lsort [glob -nocomplain -type f "$Rep/*.seq"]] "\n"]
    }

    set LesChoix [MorceauxChoisis [split $Dispos "\n"]]

    set LesFichiersTFA {}
    set LesSeq {}
    foreach Choix $LesChoix {
	set Queue [file tail $Choix]
	regsub ".seq$" $Queue "" NomDeBapteme
	set Destin "$LocalDir/$NomDeBapteme.tfa"
	if {[file exists $Destin]} {
	    if { ! [OuiOuNon "$Destin already exists.\n Do I overwrite ?"]} { continue }
	}
	set ChromaSurTitus ""
	if {[regexp "^titus\:" $SourceDir]} {
	    set FichierSurTitus "$SourceDir/$Queue"
	    Espionne $FichierSurTitus
	    regsub ".seq$" $FichierSurTitus ".ab1" ChromaSurTitus
	    set FiSeq [TmpFile].seq
	    exec rcp $FichierSurTitus $FiSeq
	    if { ! [file exists $FiSeq]} {
		FaireLire "Problem executing\nrcp $FichierSurTitus [TmpFile].seq"
		continue
	    }
	    set Seq [ContenuDuFichier $FiSeq]
	    File delete -force $FiSeq
	} else {
	    set Seq [ContenuDuFichier $Choix]
	}
	if {[regexp {\.\. *\n} $Seq]} {
	    set TFA [SequenceFormatTFA $Seq $NomDeBapteme "gcgmaybe"]
	} else {
	    regsub -all {[ \n\t0-9]} $Seq "" Seq
	    if {[regexp -nocase {[^ATGCN]} $Seq]} {
		FaireLire "The sequence file $Choix contains illegal characters\n$Seq"
	    }
	    set TFA [SequenceFormatTFA $Seq $NomDeBapteme "nucbrut"]
	}
	set FichierTFA [Sauve $TFA dans $Destin]
	if {$ChromaSurTitus!=""} {
	    regsub ".tfa$" $FichierTFA "" ChromaIci
	    append ChromaIci ".ab1"
	    if {[catch { exec rcp $ChromaSurTitus $ChromaIci } Message]} {	    
		FaireLire "I tried \nexec rcp $ChromaSurTitus $ChromaIci\and got the message\n$Message"
	    }
	}
	lappend LesFichiersTFA $FichierTFA
    }
    return $LesFichiersTFA
}

proc TestRecombinaisonEtFusion {} {
    set LespD [list \
	    "[RepertoireDuGenome]/vecteurs/pet15b-FLAG-gcassette-frameA.tfa" \
	    "[RepertoireDuGenome]/vecteurs/pETG60A.tfa" \
	    "[RepertoireDuGenome]/vecteurs/pETG28c2.tfa" \
	    "[RepertoireDuGenome]/vecteurs/pDEST10.tfa" ]
    set LespD [ChoixDesPresents $LespD]
    set LesR1 [ChoixDesPresents [glob -nocomplain "[RepertoireDuGenome]/rec1/*.tfa"]]

    set LesFiFuN {}
    foreach R1 $LesR1 {
	set QR1 [file tail $R1]
	regsub ".tfa$" $QR1 "" QR1
	foreach pD $LespD {
	    Espionne "[file tail $R1] [file tail $pD]"
	    set QpD [file tail $pD]
	    regsub ".tfa$" $QpD "" QpD
	    set D  "[RepertoireDuGenome]/rec2/${QR1}_$QpD.tfa" 
	    if { ! [file exists $D]} {
		Espionne [Recombinaison $R1 $pD $D "" "Seconde"]
	    }
	    if { ! [file exists $D]} { Warne "$D\nwas not created. I'll skipp." ; continue }

	    set FiFuNP [CreeLesFichiersExtension5PrimeDeRec2 $D]
	    if {$FiFuNP==""} { continue }
	    scan $FiFuNP "%s" $FiFuN
	    lappend LesFiFuN $FiFuN
	}
    }
    return $LesFiFuN
}

proc Recombinaison {FichierSiteB FichierSiteP FichierSiteL {FichierSiteR ""} {PremSec ""}} {

    JeMeSignale

    set Premiere 0 ; set Seconde 0
    if {$PremSec=="Premiere"} { set Premiere 1 }
    if {$PremSec=="Seconde"}  { set Seconde 1 }

    Wup "FichierSiteB must be tfa file."
    Wup "FichierSiteP can be with extension .txt or .tfa ..."
    Wup " NomSiteP, BanqueDuSiteP, FichierTFASiteP are equivalent (to FichierSiteP without extension)"

    if { ! [file exists $FichierSiteB] } {
	FaireLire "$FichierSiteB\n doesn't exist.\nI cancel Recombinaison."
	return ""
    }

    if { ! [file exists $FichierSiteP]} {
	FaireLire "$FichierSiteP\n doesn't exist.\nI cancel Recombinaison."
	return ""
    }

    if {[regexp ">" [string range [ContenuDuFichier $FichierSiteB] 1 end]]} {
	FaireLire "$FichierSiteB\ncontains more then one sequence. I cancel Recombinaison."
	return ""
    }	

    set OriFichierSiteB $FichierSiteB
    set FichierSiteB [FichierPpcrSansAttBAdapter $FichierSiteB]    

    set OriFichierSiteP $FichierSiteP
    regsub {\.[^\.]*$} $FichierSiteP "" NomSiteP
    set BanqueDuSiteP "$NomSiteP"
    set FichierTFASiteP $OriFichierSiteP

    if {[regexp ">" [string range [ContenuDuFichier $FichierTFASiteP] 1 end]]} {
	FaireLire "$FichierSiteP\ncontains more then one sequence. I cancel Recombinaison."
	return ""
    }	

    set UseLambdaIntegrase 0
    if {$Premiere} {
	set SeqPPCR [QueLaSequenceDuFichierTFA $FichierSiteB]
	if {[regexp -nocase [SEQAttB1] $SeqPPCR] && [regexp -nocase [SEQAttB2] $SeqPPCR]} {
	    if {[OuiOuNonMemo "Do I use the 'Phage Lambda integrase' to do recombination ?"]} {
		set UseLambdaIntegrase 1
	    }
	}
    }
    if {$Seconde} {
	set SeqPPCR [QueLaSequenceDuFichierTFA $FichierSiteB]
	Espionne "[SEQAttL1] $SeqPPCR"
	if {[regexp -nocase [SEQAttL1] $SeqPPCR] && [regexp -nocase [SEQAttL2] $SeqPPCR]} {
	    if {[OuiOuNonMemo "Do I use the 'Phage Lambda integrase' to do recombination ?"]} {
		set UseLambdaIntegrase 1
	    }
	} 
    }
    Espionne "UseLambdaIntegrase is $UseLambdaIntegrase"
    if {$UseLambdaIntegrase} {
	set SeqSiteP [QueLaSequenceDuFichierTFA $FichierTFASiteP]
	if {$Premiere} { set Att1 [SEQAttB1] ; set Att2 [SEQAttB2] }
	if {$Seconde } { set Att1 [SEQAttL1] ; set Att2 [SEQAttL2] }
	set LesBornes [LesBornesParLambdaIntegrase $SeqPPCR $SeqSiteP $Att1 $Att2]
	if {$LesBornes==""} {
	    set UseLambdaIntegrase 0
	} else {
	    ScanLaListe $LesBornes BN BC PN PC
	}
    }
    if { ! $UseLambdaIntegrase } {
	if {[OuiOuNonMemo "Do I skip all recombination WITHOUT LambdaIntegrase ?"]} { return "" }
	if { ! [file exists $FichierTFASiteP] || ! [file exists "$BanqueDuSiteP.nhr"]} {
	    set BanqueDuSiteP [CreeBanqueBlastDuFichier $FichierSiteP $NomSiteP]
	}
	set FichierTFASiteP $BanqueDuSiteP
	
	set FichierBlast "[TmpFile].blastn"
	exec blastall -p blastn -d $BanqueDuSiteP -i $FichierSiteB -F F -o $FichierBlast
	
	if {[OuiOuNonMemo "Do You want to see the blast file ?" 0]} {
	    AfficheFichier $FichierBlast "AvecEtudeBlastAvecSegAlignement"
	}
	global SansOffsetEtOrganisme ; set SansOffsetEtOrganisme 1
	set LesHomologues [ChaqueSegmentDuBlastN $FichierBlast 0.98989 "" "AvecLaSeq"]
	set LesBornesTrouvees {}
	foreach Homologie $LesHomologues {
	    ScanLaListe [split $Homologie "\t"] ChroContigTroncon nCops nCopsDansCetteSequence Orga \
		    PourcentageIdentiteCacheDansScore Expect \
		    DebutQuery FinQuery DebutSbjct FinSbjct Sequence
	    if {[expr ($FinSbjct-$DebutSbjct)<=0]} {
		Warne "Reverse sequence in the blast. I'll skipp it"
		continue
	    }
	    lappend LesBornesTrouvees "$DebutQuery $FinQuery $DebutSbjct $FinSbjct $Sequence"
	}
	
	set LesBornesTrouvees [lsort -integer -index 0 $LesBornesTrouvees]
	if {[llength $LesBornesTrouvees]<2} {
	    FaireLire "I found less than 2 hits for \n[PremiereLigneDuFichier $FichierSiteB]\nI cancel"
	    return ""
	}
	if {[llength $LesBornesTrouvees]>2} {
	    Warne "I found more than 2 hits. I'll eliminate those larger than 40."
	    set LesBornesGardees {}
	    foreach Bo $LesBornesTrouvees {
		scan $Bo "%d %d %d %d %s" DQ FQ DS FS Sq
		if {[expr ($FQ-$DQ) > 40]} { continue }
		lappend LesBornesGardees $Bo
	    }
	    if {[llength $LesBornesGardees]!=2} {
		FaireLire "I found more than 2 hits. Please select two of them."
		AfficheFichier $FichierBlast "AvecEtudeBlastAvecSegAlignement"
		set LesBons [MorceauxChoisis $LesBornesTrouvees]
	    } else {
		set LesBons $LesBornesGardees
	    }
	} else {
	    set LesBons $LesBornesTrouvees
	}
	if {[llength $LesBons]!=2} {
	    FaireLire "I found less than 2 hits for \n[PremiereLigneDuFichier $FichierSiteB]\nI cancel"
	    return ""
	}
	
	foreach Essai {1 2} {
	    scan [lindex $LesBons 0] "%d %d %d %d" dBN fBN dPN fPN
	    scan [lindex $LesBons 1] "%d %d %d %d" dBC fBC dPC fPC
	    
	    if {($dBN < $dBC && $dPN < $dPC)} { break }
	    Warne "There is a problem with the order of the recombination site. I'll change order."
	    set LesMeilleurs {}
	    lappend LesMeilleurs [lindex $LesBons 1]
	    lappend LesMeilleurs [lindex $LesBons 0]
	    set LesBons $LesMeilleurs
	}
	if {[expr ! ($dBN < $dBC && $dPN < $dPC)]} {
	    Warne "I'll cancel creation of rec for \n $FichierSiteB"
	    return ""	    
	}

	set MiN [expr ($fBN-$dBN)/2]
	set BN  [expr $dBN+$MiN]
	set PN  [expr $dPN+$MiN]
	
	set MiC [expr ($fBC-$dBC)/2]
	set BC  [expr $dBC+$MiC]
	set PC  [expr $dPC+$MiC]
    }

    set SeqB [QueLaSequenceDuFichierTFA $FichierSiteB]
    set SeqP [QueLaSequenceDuFichierTFA $FichierTFASiteP]
    set SeqL ""
    append SeqL [string range $SeqP       0     [expr $PN-1]]
    append SeqL [string range $SeqB       $BN         $BC]
    append SeqL [string range $SeqP [expr $PC+1]      end]
    set SeqR ""
    append SeqR [string range $SeqB       0     [expr $BN-1]]
    append SeqR [string range $SeqP       $PN         $PC]
    append SeqR [string range $SeqB [expr $BC+1]      end]


    set NomB [file tail $OriFichierSiteB]
    regsub ".tfa$" $NomB "" NomB
    set NomP [file tail $OriFichierSiteP]
    regsub ".tfa$" $NomP "" NomP

    set BonTitre ""
    while {$BonTitre==""} {
	set EnteteB [EnteteDuFichierTFA $FichierSiteB]
	set EnteteL ""
	if {$Seconde && [file exists $FichierSiteL]} {
	    set EnteteL [EnteteDuFichierTFA $FichierSiteL]
	}
	set Vecteur [EnteteDuFichierTFA $FichierSiteP "access"]
	if {[regexp " Rec2 in " $EnteteB]} {
	    if {[OuiOuNon "$EnteteB is a Rec2 file.\n\Do I cancel recombinaison ?"]} {
		return ""
	    }
	}
	if {$Premiere && [regexp " Rec1 in " $EnteteB]} {
	    if {[OuiOuNon "$EnteteB is a Rec1 file and You want to do a rec1.\n\ Do I cancel recombinaison ?"]} {
		return ""
	    }
	}
	if {[regexp " Rec1 in " $EnteteB]} {
	    regsub ">" $EnteteB "" TitreDuRec1
	    set BonTitre "Rec2 in $Vecteur of $TitreDuRec1"
	    break
	}
	if {[regexp " Ppcr for " $EnteteB]} {
	    regsub ">" $EnteteB "" TitreDuPpcr
	    set BonTitre "Rec1 in $Vecteur of $TitreDuPpcr"
	    break
	}
	if {[OuiOuNonMemo "You use uses old notation of Ppcr. Do I cancel recombinaison ?"]} { return "" }
	#   set EnteteL "RecombinaisonL [file tail $OriFichierSiteB] in [file tail $FichierSiteP]"
	#   set EnteteL "Rec1_${NomB}__$NomP"
	set EnteteB [EnteteDuFichierTFA $FichierSiteB "access"]
	set Titre ""
	if {[regexp "^ProduitPCR_" $EnteteB]} {
	    regsub -nocase "ProduitPCR_" $EnteteB "" EnteteB
	    set Titre "Rec1_"
	}
	if {[regexp "^PPCR_" $EnteteB]} {
	    regsub -nocase "PPCR_" $EnteteB "" EnteteB
	    set Titre "Rec1_"
	}
	if {[regexp "^Rec1_" $EnteteB]} {
	    regsub -nocase "Rec1_" $EnteteB "" EnteteB
	    set Titre "Rec2_"
	}
	set EnteteP [EnteteDuFichierTFA $FichierSiteP "access"]
	set pDONR $EnteteP
	set EnteteL "${Titre}${EnteteB}_$EnteteP"
	
	set BonTitre ""
	set AllEnteteB [EnteteDuFichierTFA $FichierSiteB "all"]
	set SonTitre [StringSuivant "Rec1 in " dans $AllEnteteB]
	if {$SonTitre==""} {
	    set SonTitre [StringSuivant "Rec1 with " dans $AllEnteteB]
	}
	if {$SonTitre!=""} {
	    set BonTitre "Rec2 with $SonTitre"
	} else {
	    set SonNom ""
	    scan $AllEnteteB "%s" SonNom
	    regsub ">" $SonNom "" SonNom
	    set SonTitre [StringSuivant "Ppcr for " dans $AllEnteteB]
	    set BonTitre "Rec1 in $pDONR of $SonNom ppcr $SonTitre"
	}
    }

    if {$Premiere} {
	if {$EnteteL==""} {
	    scan $EnteteB "%s" AccessDuEnteteB
	    set EnteteP [EnteteDuFichierTFA $FichierSiteP "access"]
	    scan $EnteteP "%s" AccessDuEnteteP
	    set EnteteL "${AccessDuEnteteB}_$AccessDuEnteteP"
	}
    }
    if {$Seconde} {
	if {$EnteteL==""} {
	    scan $EnteteB "%s" AccessDuEnteteB
	    set EnteteP [EnteteDuFichierTFA $FichierSiteP "access"]
	    scan $EnteteP "%s" AccessDuEnteteP
	    set EnteteL "${AccessDuEnteteB}_$AccessDuEnteteP"
	}
    }
    set TfaL [SequenceFormatTFA $SeqL "$EnteteL $BonTitre" "nucbrut"]
    set FSL [Sauve $TfaL dans $FichierSiteL]
    if {$FichierSiteR!=""} {
	if {[regexp "Rec1" $EnteteL]} {
	    regsub "" $EnteteL "Rec1R_" EnteteR
	}
	if {[regexp "Rec2" $EnteteL]} {
	    regsub "" $EnteteL "Rec1R_" EnteteR
	}
	set TfaR [SequenceFormatTFA $SeqR $EnteteR "nucbrut"]
	set FSR [Sauve $TfaR dans $FichierSiteR]
    }
    if {[OuiOuNonMemo "Do You want to see the tfa files ?" 0]} {
	if {$OriFichierSiteB!=$FichierSiteB} {
	    AfficheFichier $OriFichierSiteB "AvecFormateAvecBlaste"
	}
	AfficheFichier $FichierSiteB    "AvecFormateAvecBlaste"
	AfficheFichier $FichierSiteP    "AvecFormateAvecBlaste"
	AfficheFichier $FichierTFASiteP "AvecFormateAvecBlaste"
	AfficheFichier $FichierSiteL    "AvecFormateAvecBlaste"
	AfficheFichier $FichierSiteR    "AvecFormateAvecBlaste"
    }
    return $FSL
}

proc CreeAdnDesProduitsPCR Fichier {
    set Adn [string repeat "n" 99]
    set Numero 0
    foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess"] {
	set TFA [LaSequenceDuTFAs $Fichier $Access]
	set Entete [lindex [split $TFA "\n"] 0]
	scan $Entete "%s %s %s %s" TexteNom TexteLong TexteDebut TexteFin
	set DebutProteine [StringApres "debut_" dans $TexteDebut]
	set FinProteine   [StringApres "fin_"   dans $TexteFin]

	incr Numero
	set D [FormatDesNumerosPourCollection]
	set BeauNumero [format "%$D" $Numero]
	set Debut [expr [string length $Adn] + $DebutProteine]
	set Fin   [expr [string length $Adn] + $FinProteine]
	set Orient "F"

	set Seq [QueLaSequenceDuTexteTFA $TFA]
	set lSeq [string length $Seq]
	set L [expr (($lSeq + 99)/3)*3 + 1]
	set NN [expr $L-$lSeq]
	append Adn $Seq
	append Adn [string repeat "n" $NN]
	set Nom "[PreFixe]$BeauNumero"
	lappend LesBornes "$Nom $Debut $Fin $Orient"
    }
    set AdnTFA [SequenceFormatTFA $Adn "adn create by Gscope" "nucbrut"]
    Sauve $AdnTFA dans "adn_des_produits_pcr.tfa"
    SauveLesLignes $LesBornes dans "bornes_des_produits_pcr.txt"
    return
}

proc CommandeOligos {LesFichiersOligos {NomPresumeDuFichierCommande ""}} {

    Wup "LesFichiersOligos can be a list. "

    OligoEnStock "Reload"
    StockeCetOligo "Reset" ""
    if {$NomPresumeDuFichierCommande=="StockeOnly"} { set StockeOnly 1 } else { set StockeOnly 0 }


    if {$NomPresumeDuFichierCommande=="" \
	    || $NomPresumeDuFichierCommande=="StockeOnly" \
	    || [regexp -nocase "^usethisname_" $NomPresumeDuFichierCommande] } {
	if {[regexp -nocase "^usethisname_" $NomPresumeDuFichierCommande]} {
	    regsub "^usethisname_" $NomPresumeDuFichierCommande "" NomPresumeDuFichierCommande
	    regsub {\.txt} $NomPresumeDuFichierCommande "" NomPresumeDuFichierCommande
	} else {
	    set NomPresumeDuFichierCommande [lindex $LesFichiersOligos 0]
	}
	regsub {\.(nuc|prot|)tfa$} $NomPresumeDuFichierCommande "" NomPresumeDuFichierCommande
	append NomPresumeDuFichierCommande "_commande[Date Nice_H].txt"
    }

    set LesTFAs {}
    set D4 "50N"
    set D7 "DSL"
    foreach FichierOligos $LesFichiersOligos {
	foreach Access [LaSequenceDuTFAs $FichierOligos "LaListeDesAccess"] {
	    set TFA [LaSequenceDuTFAs $FichierOligos $Access]
	    set Seq [QueLaSequenceDuTexteTFA $TFA]
	    if {[info exists SeqDuAccess($Access)]} {
		FaireLire "DejaVu $Access !"
		continue
	    }
	    #rR Attention BrocOli 
	    set TfaBrocOli [BrocOli $TFA]
	    if {[WithBrocOli] && $TfaBrocOli!=""} {
		set AccBroc [EnteteDuTexteTFA $TfaBrocOli "access"]
		Espionne "AccBroc $AccBroc"
		lappend TFADuAccessNonBrocOli($AccBroc) $TFA
		lappend SeqDuAccessNonBrocOli($AccBroc) $Seq
		set TFA $TfaBrocOli
		set Seq [QueLaSequenceDuTexteTFA $TFA]
	    }
	    #rR Attention BrocOli 

	    set TFADuAccess($Access) $TFA
	    set SeqDuAccess($Access) $Seq
	    lappend LesAccessDeSeq($Seq) $Access
	    lappend LesAccess $Access
	}
    }
    set LeTFADeLaCommande {}
    set LaCommande {}
    set EnteteDeLaCommande ""
    set Fournisseur "Inconnu"

    FaireLire "Please select the Scale in Micro Mol to order at Sigma (default is 0.05)"
    set  SigmaScaleMicroMol [ChoixParmi [list 0.05 0.025 0.05 0.2, 1. 10. 15. "OtherValue"]]
    if {$SigmaScaleMicroMol=="OtherValue"} { set SigmaScaleMicroMol [Enter 0.05] }
    FaireLire "Please select the Purification to order at Sigma (default is RP1)"
    set  SigmaPurification [ChoixParmi [list "RP1" "DST" "PAGE" "HPLC" "OtherValue"]]
    if {$SigmaPurification=="OtherValue"} { set SigmaPurification [Enter "RP1"] }
    set  SigmaComment ""

    set ListeSigma {}

    if { ! $StockeOnly} {
	
	set EnteteDeLaCommande {}
	lappend EnteteDeLaCommande "                    SYNTHESE D'OLIGONUCLEOTIDES - IGBMC"
	lappend EnteteDeLaCommande ""
	lappend EnteteDeLaCommande " Date de commande : [Date Nice]"
	lappend EnteteDeLaCommande ""
	lappend EnteteDeLaCommande " Equipe           :            "
	lappend EnteteDeLaCommande " Nom du demandeur :            "
	lappend EnteteDeLaCommande " Telephone        :            "
	lappend EnteteDeLaCommande ""
	lappend EnteteDeLaCommande ""
	lappend EnteteDeLaCommande " Sequence 5' -> 3'"
	lappend EnteteDeLaCommande ""
	set EnteteDeLaCommande [join $EnteteDeLaCommande "\n"]

	set Fournisseur "IGBMC"
	
	set NumeroPrimer 1
#	if { 0 && ! [OuiOuNon "Do I start Primer numbering with 1 ?"]} {
#	    set NumeroPrimer [Entre 1]
#	}
    }
    set nPrimer 0
    set TotalBases 0
    set TotalBasesSansAttB 0
    set nAttB1 0
    set nAttB2 0
    set CompteAttB ""
    set LesFichiersOligosStockes {}
    set LesNonCreesCarEnStock {}
    foreach Access $LesAccess {
	set Seq [set SeqDuAccess($Access)]
	if {[info exists DejaVu($Seq)]} { continue }
	set DejaVu($Seq) 1
	if {[set OliEnSto [OligoEnStock $Seq]]!=""} {
	    set LesAutres [join [set LesAccessDeSeq($Seq)] "\n"]
	    if {[OuiOuNon "I found an existing oligo $OliEnSto\nfor $LesAutres\n\nDo You use it ?"]} {
		foreach A $LesAutres {
		    set WarningBrocOli ""
		    if {[Oli $OliEnSto "IsBrocOli"]} {
			set GenericOligo [Oli $OliEnSto "ItsGenericOligo"]
			set WarningBrocOli " BrocOli with $GenericOligo"
		    }
		    lappend LesNonCreesCarEnStock "$A please use $OliEnSto$WarningBrocOli"
		}
		continue
	    }
	}
	set LesEntetes {}
	set AppendTexteBrocOli {}
	set LesB {}
	set LesS {}
	foreach Autre [set LesAccessDeSeq($Seq)] {
	    set TFA [set TFADuAccess($Autre)]
	    set Entete [EnteteDuTexteTFA $TFA]
	    Espionne "$Autre pour seq =$Seq="
	    if {[regexp { BrocOli.+$} $Entete TexteBrocOli]} {
		if {$AppendTexteBrocOli!="" && $AppendTexteBrocOli!=$TexteBrocOli} {
		    FaireLire "Different BrocOli for the same sequence\
			    \n$Seq\n$AppendTexteBrocOli\n$TexteBrocOli"
		}
		scan $$TexteBrocOli "%s %s %s %s %s %s" A b w B r S
		lappend LesB $B ; set LesB [ListeSansDoublon $LesB]
		lappend LesS $S ; set LesS [ListeSansDoublon $LesS]
		regsub "$TexteBrocOli" $Entete "" Entete
		set AppendTexteBrocOli " BrocOli with [join $LesB "+"] replaces [join $LesS "+"]"
	    }
	    regsub -all ">" $Entete "" Entete
	    lappend LesEntetes $Entete
	}
	set LesEntetes [ListeSansDoublon $LesEntetes]
	set Entete [join $LesEntetes "+"]
	if {$AppendTexteBrocOli!=""} { append Entete $AppendTexteBrocOli }

    	incr nPrimer
	incr TotalBases [string length $Seq]
	incr TotalBasesSansAttB [string length $Seq]

	set PStocke ""
	set EntetePourFiStockOl [FormatageEntete $Entete PourOligo "Pxxxx"]

	set FichierOligoStocke  [StockeCetOligo $EntetePourFiStockOl $Seq "AutoNumbering"]
	lappend LesFichiersOligosStockes $FichierOligoStocke
	set PStocke [file tail $FichierOligoStocke]
	regsub ".tfa$" $PStocke "" PStocke
	if {[WithBrocOli]} {
	    set EnteteBroc [EnteteDuFichierTFA $FichierOligoStocke]
	    scan $EnteteBroc "%s %s %s %s %s %s %s %s" P X o w s S f A
	    if {$X=="5'"} { set AccBroc "${S}_$A" } else { set AccBroc "${A}_$S" }
	    if {[info exists TFADuAccessNonBrocOli($AccBroc)]} {
		foreach TFANB $TFADuAccessNonBrocOli($AccBroc) SeqNB $SeqDuAccessNonBrocOli($AccBroc) B $LesB S $LesS {
		    regsub "BrocOli with .*" $EnteteBroc "BrocOli with $B replaces $S" OneEnteteBroc
		    Espionne "TFANB de $AccBroc $TFANB"
		    set EntetePourFiStockOlNB [FormatageEntete $OneEnteteBroc "PourOligoNonBrocOli" "Pxxxx"]
		    append EntetePourFiStockOlNB " seeBrocken $PStocke"
		    set FichierOligoStockeNB  [StockeCetOligo $EntetePourFiStockOlNB $SeqNB "AutoNumbering"]
		    lappend LesFichiersOligosStockes $FichierOligoStockeNB
		    set PStockeNB [file tail $FichierOligoStockeNB]
		    regsub ".tfa$" $PStockeNB "" PStockeNB
		    set Monbroc [ContenuDuFichier $FichierOligoStocke]
		    if {[regexp "seeFull AfterMe" $Monbroc]} {
			regsub "seeFull AfterMe" $Monbroc "seeFull $PStockeNB" MonBonBroc
			Sauve $MonBonBroc dans $FichierOligoStocke
		    } else {
			if {[regexp {seeFull ([P0-9\+]+)} $Monbroc Match]} {
			    regsub -all {\+} $Match "\\+" MatchX
			    regsub $MatchX $Monbroc "$Match+$PStockeNB" MonBonBroc
			    Sauve $MonBonBroc dans $FichierOligoStocke
			}
		    }
		}
	    }
	}
	if {$StockeOnly} { continue }

	set TFA [SequenceFormatTFA $Seq ">$Entete" "brut"]
	lappend LeTFADeLaCommande $TFA
	set PduTFA($TFA) $PStocke
	
	set EnteteCourte [FormatageEntete $Entete PourCommande $PStocke]
	scan $EnteteCourte "%s %s" P SigSuj
	set LS [list $P:$SigSuj $Seq $SigmaScaleMicroMol $SigmaPurification $SigmaComment]
	lappend ListeSigma [join $LS ","]
	if {$Fournisseur=="Invitrogen" || $Fournisseur=="IGBMC"} {
	    if {$Fournisseur=="IGBMC"} {
		lappend LaCommande [string repeat "-" 66]
		lappend LaCommande "$NumeroPrimer  $EnteteCourte"
		lappend LaCommande ""
		set LesTriplets {}
		set nTriplets 0
		set LesBases [split $Seq ""]
		set LesSuivantes [lrange [concat $LesBases [list X X X X X]] 3 end]
		set FiveP " 5'"
		foreach {a b c} $LesBases {d e f} $LesSuivantes {
		    lappend LesTriplets "$a$b$c"
		    set ThatsAllFolks [string equal "$d$e$f" "XXX"]
		    if {[incr nTriplets]==15 || $ThatsAllFolks} {
			set nTriplets 0
			set LigneDeTriplets [string toupper [join $LesTriplets " "]]
			if {$ThatsAllFolks} {
			    lappend LaCommande " $FiveP $LigneDeTriplets  3'"
			    break
			} else {
			    lappend LaCommande " $FiveP $LigneDeTriplets"
			}			    
			set LesTriplets {}
			set FiveP "   "
		    }
		}
		lappend LaCommande ""
	    } else {
		lappend LaCommande "*"
		lappend LaCommande "D1: $EnteteCourte"
		lappend LaCommande "D2: $NumeroPrimer"
		set SeqACommander [string toupper $Seq]
		set LigneD5 ""
		if {[CaCommenceParAttB $SeqACommander] && [NePasMettreAttB]} {
		    set LongOriginale [string length $SeqACommander]
		    set SeqACommander [RetireAttB    $SeqACommander]
		    set LongCommandee [string length $SeqACommander]
		    set LongEconomie [expr $LongOriginale-$LongCommandee]
		    set TotalBasesSansAttB [expr $TotalBasesSansAttB-$LongEconomie]
		    if {$LongEconomie>0 && [regexp "AttB1" $Entete]} { set LigneD5 "D5: GWF" ; incr nAttB1 }
		    if {$LongEconomie>0 && [regexp "AttB2" $Entete]} { set LigneD5 "D5: GWR" ; incr nAttB2 }
		    set CompteAttB "= $TotalBasesSansAttB without AttB + $nAttB1 AttB1 + $nAttB2 AttB2" 
		}
		lappend LaCommande "D3: $SeqACommander"
		lappend LaCommande "D4: $D4"
		if {$LigneD5!=""} { lappend LaCommande $LigneD5 }
		lappend LaCommande "D7: $D7"
	    }
	} else {
	    lappend LaCommande "\n>$Entete"
	    lappend LaCommande $Seq
	}
	incr NumeroPrimer
	continue
    }
    if {$StockeOnly} { return $LesFichiersOligosStockes }
    if {$Fournisseur=="IGBMC"} {
	lappend LaCommande ""
	lappend LaCommande "------------------------ FIN DE COMMANDE -------------------------"
    } else {
	lappend LaCommande " + "
    }
    lappend LaCommande "Total bases $TotalBases $CompteAttB for $nPrimer primers"
    lappend LaCommande "End of text automatically created by Gscope (33)388653305"
    set LEnteteDeLaCommande [list $EnteteDeLaCommande "HZ: $nPrimer" ""]
    set LaCommande [concat $LEnteteDeLaCommande $LaCommande]
    set Commande ""
    while {$Commande==""} {
	set Commande [join $LaCommande "\n"]
	set Commande [EntreTexte $Commande]
	if {$Commande==""} {
	    if {[OuiOuNon "Do You want to cancel CommandeOligos ?"]} {
		if {[OuiOuNon "Sorry, but I already created the files\n\
			[join $LesFichiersOligosStockes "\n"]\n\nCan I delete them ?"]} {
		    foreach FOS $LesFichiersOligosStockes {
			if {[file exists $FOS]} { file delete $FOS }
		    }
		}
		return ""
	    } else {
		continue
	    }
	}
    }

    set WebOrder [OuiOuNon "Do I order these oligos through the [UrlCommandeOligo] Webserver ?"]

    while {1} {
	FaireLire "Please, tell me name for the TEXT file for oligos_commande (and oligos_weborder)"
	set FichierTXTCommandeOligos $NomPresumeDuFichierCommande
	set FichierTXTCommandeOligos [FichierPourSaveAs $FichierTXTCommandeOligos]
	if {$FichierTXTCommandeOligos==""} {
	    if {[OuiOuNon "Ok to continue WITHOUT saving the text of the oligos_commande ?"]} { break } else { continue }
	}
	regsub "_commande" $FichierTXTCommandeOligos "_weborder" FichierTXTWebOrderOligos
	regsub "_commande" $FichierTXTCommandeOligos "_sigma"    FichierTXTSigmaOligos
	regsub ".txt"      $FichierTXTSigmaOligos    ""          FichierTXTSigmaOligos
	append FichierTXTSigmaOligos ".csv"
 
	append Commande "\n $FichierTXTCommandeOligos"
	append Commande "\n $FichierTXTWebOrderOligos"
	append Commande "\n $FichierTXTSigmaOligos"
	set TFADeLaCommande [join $LeTFADeLaCommande "\n"]
	set FichierTXTCommandeOligos [Sauve $Commande dans $FichierTXTCommandeOligos]
	set FichierTXTWebOrderOligos [Sauve $TFADeLaCommande dans $FichierTXTWebOrderOligos]
	set FichierTXTSigmaOligos    [SauveLesLignes $ListeSigma dans $FichierTXTSigmaOligos]
	break
    }
    if {$LesNonCreesCarEnStock!={}} {
	FaireLire "Some oligos where not created because they exist in oligobase\n\
		Please browse for a file name to store the list"
	regsub "_commande" $FichierTXTCommandeOligos "_existing" FichierDesNonCreesCarEnStock
	regsub ".txt$" $FichierDesNonCreesCarEnStock "" FichierDesNonCreesCarEnStock
	append FichierDesNonCreesCarEnStock ".list"
	set FichierDesNonCreesCarEnStock [FichierPourSaveAs $FichierDesNonCreesCarEnStock]
	if {$FichierDesNonCreesCarEnStock!=""} {
	    SauveLesLignes $LesNonCreesCarEnStock dans $FichierDesNonCreesCarEnStock
	}
    }

    if {$FichierTXTCommandeOligos!=""} {
	while {$WebOrder} {
	    foreach Access [LaSequenceDuTFAs $FichierTXTWebOrderOligos "LaListeDesAccess"] {
		set TFA [LaSequenceDuTFAs $FichierTXTWebOrderOligos $Access]
		set Nom $Access
		set Not [EnteteDuTexteTFA $TFA]
		set Seq [QueLaSequenceDuTexteTFA $TFA]
		if {[info exists PduTFA($TFA)]} { set Nom $PduTFA($TFA) }
		lappend LesNom $Nom
		lappend LesNot $Not
		lappend LesSeq $Seq
	    }
	    set Retour [WebOrder $LesSeq $LesNom $LesNot]
	    if {$Retour!=""} { break }
	    if {[OuiOuNon "Do I really cancel WebOrder ?"]} { break } 
	}
	if {[OuiOuNon "Do I print the order ?" 0]} {
	    ImprimeLeFichier $FichierTXTCommandeOligos "renoir -l "
	}
	if {[OuiOuNon "Do I mail the order ?" 0]} {
	    MailAuxDestinataires $FichierTXTCommandeOligos "" "Commande oligos"
	}
    }
    return $FichierTXTCommandeOligos
}

proc NePasMettreAttB {} {
    global NePasMettreAttB
    if { ! [info exists NePasMettreAttB]} {
	set NePasMettreAttB [expr ! [OuiOuNon "Do I include the AttB signals ?\n
	Don't forget to add a CC signal at 5' end if you order at Invitrogen."]]
    }
    return $NePasMettreAttB
}

proc OligosEtProduitsPCR {FichierSeq SavSapFavFap args} {

    set LesOptions $args
    
    set LesAvants [lindex $SavSapFavFap 0]
    set LesApres  [lindex $SavSapFavFap 1]
    set FichierDesSignauxAvant  [lindex $SavSapFavFap 2]
    set FichierDesSignauxApres  [lindex $SavSapFavFap 3]
    LesSignauxDuFichier $FichierDesSignauxAvant SequenceDuSignal SequenceDuSignalPourPPCR
    LesSignauxDuFichier $FichierDesSignauxApres SequenceDuSignal SequenceDuSignalPourPPCR

    set Retourne "LesNomsDesFichiers"
    if {[OuiOuNon "Do you want (as usual) a MeltingTemp of 62 ( and 60 if it end with G or C) ?"]} {
	set AvecMeltingTemp 1
	set Melting "62 60"
    } else {
	set AvecMeltingTemp [OuiOuNon "Do you want to define a MeltingTemp a new couple of temperatures?"]
	if {$AvecMeltingTemp} {
	    FaireLire "Please give a couple of temperatures"
	    set Melting [Entre "62 60 (second value if it ends with G or C)"]
	    set tGC ""
	    scan $Melting "%f %f" tAT tGC
	    set Melting "$tAT $tGC" 
	} else {
	    FaireLire "Please enter the length of the priming sequence"
	    set LongAvant [Entre 20]
	    set LongApres [Entre 20]
	}
    }
    foreach A $LesOptions {
	if {[regexp "^Retourne" $A]} {
	    regsub "^Retourne" $A Retourne
	    continue
	}
	if {[regexp {^L[0-9]+$} $A]} {
	    regsub "L" $A "" A
	    set LongAvant $A
	    set LongApres $A
	    set AvecMeltingTemp 0
	    continue
	}
	if {[regexp {^T[0-9\.](_([0-9]+))?$} $A]} {
	    regsub -all {[^0-9\.]} $A " " A
	    regsub -all { +} $A " " A
	    set Melting [string trim $A]
	    set AvecMeltingTemp 1
	    continue
	}
    }

    foreach Ligne [CorrectionPourThrombin [LesLignesDuFichier $FichierSeq] $FichierSeq NF] {
	if {[regexp " *>" $Ligne]} {
	    regsub -all ">" $Ligne " " Ligne
	    scan $Ligne "%s" NomSeq
	    lappend LesNomSeq $NomSeq
	    set Entetes($NomSeq) $Ligne
	    set Sequences($NomSeq) ""
	    continue
	}
	regsub -nocase -all {[^a-z]} $Ligne "" Seq
	append Sequences($NomSeq) $Seq
    }

    set LesTFAsSans {}
    foreach NomSeq $LesNomSeq {
	set ProduitPCR ""
	set LesAvantsEtMoi $NomSeq
	set TM5P ""
	if {$LesAvants!={} || $LesAvants=={} && $LesApres=={}} {
	    if {$LesAvants=={}} {
		set LesAvantsEtMoi No5pSignal 
	    } else {
		set LesAvantsEtMoi $LesAvants
	    }
	    lappend LesAvantsEtMoi $NomSeq
	    set Nom [join $LesAvantsEtMoi "_"]
	    set SeqAvant ""
	    foreach Signal $LesAvants {
		set SeqSignal [string totitle [set SequenceDuSignal($Signal)]]
		append SeqAvant $SeqSignal
		set SeqSignalPourPPCR [string totitle [set SequenceDuSignalPourPPCR($Signal)]]
		append ProduitPCR $SeqSignalPourPPCR
 	    }
	    if {$AvecMeltingTemp} {
		set SeqAdd [EntammePourMeltingTemp [set Sequences($NomSeq)] $Melting]
	    } else {
		set SeqAdd [string range [set Sequences($NomSeq)] 0 [expr $LongAvant-1]]
	    }
	    set TM5P [TMDeLaSequence $SeqAdd]
	    append SeqAvant $SeqAdd
	    set TFA         [SequenceFormatTFA $SeqAvant         "$Nom tm5p_$TM5P" "brut"]

	    if {[DontCreateAllOligos] && ! [OuiOuNon "$TFA\n\n OK to create it ?"]} {
	    } else {
		lappend LesTFAs $TFA
	    }
	}

	set LeNomDuProduitPCR $LesAvantsEtMoi

	set DebutProteine [expr [string length $ProduitPCR] +1]
	append ProduitPCR [set Sequences($NomSeq)]
	set FinProteine   [expr [string length $ProduitPCR]]
	set TM3P ""
	if {$LesApres!={} || $LesAvants=={} && $LesApres=={}} {
	    set LeNomDuProduitPCR [concat $LeNomDuProduitPCR $LesApres] 
	    if {$LesApres=={}} {
		set LesMoiEtApres [concat [list $NomSeq] "No3pSignal"] 
	    } else {
		set LesMoiEtApres [concat [list $NomSeq] $LesApres] 
	    }
	    set Nom [join $LesMoiEtApres "_"]
	    set SeqTotaleRaC [NucToReverseAndComplementNuc [set Sequences($NomSeq)]]
	    if {$AvecMeltingTemp} {
		set SeqRaC [EntammePourMeltingTemp $SeqTotaleRaC $Melting]
	    } else {
		set SeqRaC [string range $SeqTotaleRaC 0 [expr $LongApres-1]]
	    }
	    set TM3P [TMDeLaSequence $SeqRaC]
	    set Signaux ""
	    foreach Signal $LesApres {
		set SeqSignal [string totitle [set SequenceDuSignal($Signal)]]
		append Signaux $SeqSignal
		set SeqSignalPourPPCR [string totitle [set SequenceDuSignalPourPPCR($Signal)]]
		append ProduitPCR $SeqSignalPourPPCR
 	    }
	    set SignauxRaC         [NucToReverseAndComplementNuc $Signaux]
	    set RaC "$SignauxRaC$SeqRaC"
	    set TFA [SequenceFormatTFA $RaC "$Nom tm3p_$TM3P" "brut"]
	    if {[DontCreateAllOligos] && ! [OuiOuNon "$TFA\n\n OK to create it ?"]} {
	    } else {
		lappend LesTFAs $TFA
	    }
	}
	set SeqProduitPCR [join $ProduitPCR ""]
	set L [string length $SeqProduitPCR]
	set CodonsRares [CodonsRares [set Sequences($NomSeq)]]
	set NomDuProduitPCR [join $LeNomDuProduitPCR "_"]
	set ProduitPCRTFA [SequenceFormatTFA $SeqProduitPCR \
		"ProduitPCR_$NomDuProduitPCR bases_$L debut_$DebutProteine fin_$FinProteine tm5p_$TM5P tm3p_$TM3P $CodonsRares" "brut"]
	lappend LesProduitsPCRTFA $ProduitPCRTFA
	Espionne $ProduitPCRTFA
    }
    EspionneL $LesTFAs

    while 1 {
	FaireLire "Please, help me to choose the file name for oligos"
	set Queue [file tail $FichierSeq]
	if {[regexp "^cons_" $Queue]} { regsub "cons_" $Queue "" Queue }
	set  FichierOligos "./oligos_$Queue"
	set  FichierOligos [FichierPourSaveAs $FichierOligos]
	if {$FichierOligos==""} {
	    if {[OuiOuNon "Do You really want to skipp saving of oligo ?"]} { break }
	    continue
	}
	set FichierOligos [SauveLesLignes $LesTFAs dans $FichierOligos]
	break
    }

    while 1 {
	set D [file dirname $FichierOligos]
	set Q [file tail $FichierOligos]
	regsub "^oligos_" $Q "" Q
	set Q "ppcr_$Q"
	set  FichierProduitsPCR "$D/$Q"
	if {[file exists $FichierProduitsPCR]} {
	    FaireLire "Please, help me to choose the file name for produits_pcr"
	    set  FichierProduitsPCR [FichierPourSaveAs $FichierProduitsPCR]
	}
	if {$FichierProduitsPCR==""} {
	    if { [OuiOuNon "Do You really want to skipp saving of PPCR ?"]} { break }
	    continue
	}
	set  FichierProduitsPCR [SauveLesLignes $LesProduitsPCRTFA dans $FichierProduitsPCR]
	break
    }

    if {$Retourne=="LesNomsDesFichiers"} { return [list $FichierOligos $FichierProduitsPCR] }
    if {$Retourne=="LesTFAsDesOligos"}   { return $LesTFAs }
}