anchor.diff:                          if state.bestFwdDelta < 0.0<C> && state.ft < fwdTailLenMin && state.fb>dp.pp.minLength
                               then yield CHOP_F_AMP
                           elif state.fb < fwd.body.Length then yield EXT_F_AMP
  -                        if state.bestAnnealDelta < 0.0<C> && state.ft > fwdTailLenMin
  -                            then yield CHOP_F_ANNEAL
  +                        if state.bestAnnealDelta < 0.0<C> && state.ft > fwdTailLenMin then 
  +                            yield CHOP_F_ANNEAL
                           elif state.ft < fwdTailLenMax then yield EXT_F_ANNEAL
   
                           match sign state.bestAnnealDelta, sign state.bestFwdDelta with
  
positive.code:             | None -> assert(primerR.Primer.Length=0)
              | Some(ds) -> primerCheck primerR.Primer.arr (ds.dna.RevComp().[offsetR..].arr)
  
  <<<<<<< HEAD
          if verbose then
                  printfn "sliceOut'=%s" (String.Join(";",[for s in sliceOut' -> s.description]))
          let finalOutput = (DPP({fwd = {body=Dna(""); tail =Dna(""); annotation = []}; rev = primerR; name = last.description})::primersOut |> List.rev,
                               sliceOut') // Last linker
          let finalDPPs,finalSlices = finalOutput
          let outputParity = finalDPPs.Length = finalSlices.Length
          if verbose || (not outputParity) then
                  
              let y = (String.Join(";",(finalDPPs |> Seq.map(prettyPrintPrimer))))
              let x = (String.Join(";",(finalSlices |> Seq.map(nameFromSlice))))
              printfn "procAssembly: finalOutput(slices n=%d): %s" (finalSlices.Length) x
              printfn "procAssembly: finalOutput(primer n=%d): %s" (finalDPPs.Length) y
              if not outputParity then
                  failwithf "These lists should have same length :( - error in procAssembly"
              ()
          finalOutput // RETURN POINT *****
      | hd::tl when 
          hd.sliceType = INLINEST && 
          (not (hd.pragmas.ContainsKey("rabitend") || hd.pragmas.ContainsKey("amp"))) ->
          if verbose then
              printfn "procAssembly: ... (GAP) INLINEST"
          let prevNew = hd::prev
          procAssembly verbose dp errorName prevNew (incPrev prev sliceOut) (GAP::primersOut) tl
      // This cases catches inline sequences just before a linker marked rabitend
      | hd::tl when hd.sliceType = INLINEST && hd.pragmas.ContainsKey("rabitend") ->
          if verbose then
              printfn "procAssembly: ... (GAP) INLINEST rabitend case hd=%s" hd.description
              printfn "procAssembly: ... new sliceOut = %s" (String.Join(";",[for x in hd::sliceOut -> x.description]))
          // push the slice onto the prev stack
          let prevNew = hd::prev
          procAssembly verbose dp errorName prevNew (hd::sliceOut) (SANDWICHGAP::primersOut) tl
          // procAssembly verbose dp errorName prevNew (incPrev prev sliceOut) (GAP::primersOut) tl
      | hd::tl ->
          if verbose then
              printfn "procAssembly: ... (GAP) catchall case"
          // Check if this slice should have been fused with previous slice?
          match prev with
          | pHd::_ when 
              (pHd.dna.Length>100 || hd.pragmas.ContainsKey("amp")) &&  
              (hd.dna.Length > 100 || hd.pragmas.ContainsKey("amp")) ->
  
              if verbose then
                  printfn "procAssembly: ... generate seamless junction between prev=%s and this=%s" pHd.description hd.description
  
              let primerPos = parsePrimerPos pHd.pragmas
  
              let fwdTailLenMax,revTailLenMax =
                  match primerPos with
                  | FWD(offset) ->
                      let x = -offset // Convert to tail length
                      x, 999999
                  | REV(offset) ->
                      let x = offset 
                      999999,x
                  | NONE -> 999999,999999 // no primerpos
              if verbose then
                  printfn "procAssembly: ... (GAP) INLINEST"
              let prevNew = hd::prev
  
negative.code:                 match fwdLen with
                  | OligoOver(_) -> // cut something off
                      if state.fb>dp.pp.minLength then  yield CHOP_F_AMP
                      // Put guard on this to stop best anneal data running away to zero kelvin ;(
                      if fwdTailLenFixed.IsNone && state.ft > fwdTailLenMin && state.bestAnnealDelta < maxAnnealSearchDeviation 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
  