anchor.diff:      let X = rev.body.Length+middleDNA.Length-1
       /// First base of inline region
       let Y = rev.body.Length
  -
  +    if verbose then
  +        printfn "tuneTailOpt: X=%d Y=%d\n template=%s" X Y fullTemplate.str
  +
  +    /// Maximum amount by which we can stray from ideal annealing term during tune tails search
  +    let maxAnnealSearchDeviation = 10.0<C>
       /// Recursive optimization of the primer ends, adjusting lengths to get the amp / anneal and primer lengths optimized
       let rec tuneTailsOpt itersRemaining (state:TuneState) (seen':Set<TuneVector>) =
   
  
positive.code:                 match fwdLen with
                  | OligoOver(_) -> // cut something off
                      if state.fb>dp.pp.minLength then  yield CHOP_F_AMP
                      if fwdTailLenFixed.IsNone && state.ft > fwdTailLenMin then yield CHOP_F_ANNEAL
                  | OligoMax(_) -> // could slide or cut
                      if state.bestFwdDelta < 0.0<C> && state.fb>dp.pp.minLength then yield CHOP_F_AMP
                      if fwdTailLenFixed.IsNone then
                          if  state.bestAnnealDelta < 0.0<C> && state.ft > fwdTailLenMin then yield CHOP_F_ANNEAL
                          if state.fb < fwd.body.Length && state.ft > fwdTailLenMin then yield SLIDE_F_RIGHT
                          if state.rt > revTailLenMin && state.ft < fwdTailLenMax then
                              yield SLIDE_F_LEFT
  
negative.code:             | None -> assert(primerR.Primer.Length=0)
              | Some(ds) -> primerCheck primerR.Primer.arr (ds.dna.RevComp().[offsetR..].arr)
  
              let sliceOut' =
                  match prev with
                  | [] ->
                      // We are on the last element and there are no precending elements.  This could
                      // be a stand-alone, single DNA slice.  Process it as such.  This is going to create
                      // trouble if the user intended a RYSE design but they might not be headed there so we have
                      // to handle this case.
                      // Assume it's a stand-alone inline sequence that could be made with a pair of primers
                      if sliceOut = [] then // Assume it's a stand-alone inline sequence that could be made with a pair of primers
                          (* type DNASlice = { id : int option ; extId : string option ; dna : char array ;  sourceChr : string ; sourceFr : int<ZeroOffset> ; sourceTo : int<ZeroOffset>
                              ; sourceFwd : bool ;
                              sourceFrApprox: bool; sourceToApprox : bool;
                               destFr : int<ZeroOffset> ; destTo : int<ZeroOffset> ; destFwd : bool
                              ; sliceName : string ; description : string ; sliceType : SliceType ; pragmas:Map<string,string>;
                              dnaSource : string}      *)
                              (*
                              let slice = { id = None ; extId = None ; dna = last.dna ; sourceChr = "inline" ;
                                              sourceFr = 0<ZeroOffset> ; (sourceTo = last.dna.Length-1)*1<ZeroOffset> ;
                                              sourceFwd = true ; sourceFrApprox = false; sourceToApprox = false ;
                                              destFr = 0<ZeroOffset> ; destTo = 0<ZeroOffset> (*fixed later *) ;
                                              description = "inline dna" ; sliceType = INLINEST ; pragmas = last.pragmas
  
                              *)
                          [last] // Fake slice for now.. TODO TODO
                      else failwith "expected preceding linker adjacent to terminal inline sequence"
                  | p::_ -> last::(cutRight p offsetR)::sliceOut  |> List.rev
  
              (DPP({fwd = {body=Dna(""); tail =Dna(""); annotation = []}; rev = primerR; name = errorName})::primersOut |> List.rev,
               sliceOut') // Last linker
          | hd::tl when hd.sliceType = INLINEST ->
              if verbose then
                  printfn "procAssembly: ... (GAP) INLINEST"
              let prevNew = hd::prev
  