anchor.diff:              (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: ... INLINEST"
               let prevNew = hd::prev
               procAssembly dp errorName prevNew (incPrev prev sliceOut) (GAP::primersOut) tl
           | hd::tl ->
  +            if verbose then
  +                printfn "procAssembly: ... catchall case"
               procAssembly dp errorName (hd::prev) (incPrev prev sliceOut)  (GAP::primersOut) tl
   
       // --- end procAssembly ------------------------------------------------------------------------
  
positive.code:                     ((match sandwichF with | None -> [] | Some(t) -> [t])@[(cutLeft d offsetF)]@e)
          // technically shouldn't end on a non linker (unless non ryse design) but..
          | [last] when (last.sliceType = LINKER || last.sliceType = INLINEST) ->
              // We are about to design a primer back into the previous sequence if it exists.
              // There is a catch if the previous sequence was a short inline sequence.
              // We should treat that as a sandwich sequence, built it into the primer but not
  
negative.code:                 not (hd.pragmas.ContainsKey("rabitend") || hd.pragmas.ContainsKey("rabitstart"))) &&
                  prev <> []
              ->
              if verbose then
                  printfn "procAssembly: LINKER or inline not rabitstart/end"
              if hd.sliceType = INLINEST && hd.dna.Length < 12 then
                  if verbose then
                      printfn "procAssembly: ... shortcase"
                  // SHORTINLINE Case
                  //
                  // Special case for short inline sequences.  We can sort of do a seamless design
  