diff --git a/L1Trigger/TrackFindingTracklet/interface/CircularBuffer.h b/L1Trigger/TrackFindingTracklet/interface/CircularBuffer.h
index 50ed9aeae58f9..3d0832f56dc5e 100644
--- a/L1Trigger/TrackFindingTracklet/interface/CircularBuffer.h
+++ b/L1Trigger/TrackFindingTracklet/interface/CircularBuffer.h
@@ -31,14 +31,14 @@ namespace trklet {
     //Empty buffer is write ptr is same as read ptr
     bool empty() const { return wptr_ == rptr_; }
 
-    T read() {
+    const T& read() {
       assert(!empty());
       unsigned int oldrptr = rptr_;
       rptr_ = (rptr_ + 1) % size_;
       return buffer_[oldrptr];
     }
 
-    T peek() const {
+    const T& peek() const {
       assert(!empty());
       return buffer_[rptr_];
     }
diff --git a/L1Trigger/TrackFindingTracklet/interface/Sector.h b/L1Trigger/TrackFindingTracklet/interface/Sector.h
index 431fff4e30534..b48f582fe5354 100644
--- a/L1Trigger/TrackFindingTracklet/interface/Sector.h
+++ b/L1Trigger/TrackFindingTracklet/interface/Sector.h
@@ -115,17 +115,17 @@ namespace trklet {
     double phimin() const { return phimin_; }
     double phimax() const { return phimax_; }
 
-    template <typename TV>
-    void addMemToVec(std::vector<TV*>& memvec, TV* mem, const std::string& memName) {
-      memvec.push_back(mem);
-      Memories_[memName].reset(mem);
-      MemoriesV_.push_back(mem);
+    template <typename TV, typename... Args>
+      void addMemToVec(std::vector<std::unique_ptr<TV> >& memvec, const std::string& memName, Args&... args) {
+      memvec.push_back(std::make_unique<TV>(memName, std::forward<Args>(args)...));
+      Memories_[memName] = memvec.back().get();
+      MemoriesV_.push_back(memvec.back().get());
     }
 
-    template <typename TV>
-    void addProcToVec(std::vector<TV*>& procvec, TV* proc, const std::string& procName) {
-      procvec.push_back(proc);
-      Processes_[procName].reset(proc);
+    template <typename TV, typename... Args>
+      void addProcToVec(std::vector<std::unique_ptr<TV> >& procvec, const std::string& procName, Args&... args) {
+      procvec.push_back(std::make_unique<TV>(procName, std::forward<Args>(args)...));
+      Processes_[procName] = procvec.back().get();
     }
 
   private:
@@ -135,38 +135,38 @@ namespace trklet {
     double phimin_;
     double phimax_;
 
-    std::map<std::string, std::unique_ptr<MemoryBase> > Memories_;
+    std::map<std::string, MemoryBase* > Memories_;
     std::vector<MemoryBase*> MemoriesV_;
-    std::vector<InputLinkMemory*> IL_;
-    std::vector<AllStubsMemory*> AS_;
-    std::vector<VMStubsTEMemory*> VMSTE_;
-    std::vector<VMStubsMEMemory*> VMSME_;
-    std::vector<StubPairsMemory*> SP_;
-    std::vector<StubTripletsMemory*> ST_;
-    std::vector<TrackletParametersMemory*> TPAR_;
-    std::vector<TrackletProjectionsMemory*> TPROJ_;
-    std::vector<AllProjectionsMemory*> AP_;
-    std::vector<VMProjectionsMemory*> VMPROJ_;
-    std::vector<CandidateMatchMemory*> CM_;
-    std::vector<FullMatchMemory*> FM_;
-    std::vector<TrackFitMemory*> TF_;
-    std::vector<CleanTrackMemory*> CT_;
-
-    std::map<std::string, std::unique_ptr<ProcessBase> > Processes_;
-    std::vector<VMRouter*> VMR_;
-    std::vector<VMRouterCM*> VMRCM_;
-    std::vector<TrackletEngine*> TE_;
-    std::vector<TrackletEngineDisplaced*> TED_;
-    std::vector<TripletEngine*> TRE_;
-    std::vector<TrackletProcessor*> TP_;
-    std::vector<TrackletCalculator*> TC_;
-    std::vector<TrackletCalculatorDisplaced*> TCD_;
-    std::vector<ProjectionRouter*> PR_;
-    std::vector<MatchEngine*> ME_;
-    std::vector<MatchCalculator*> MC_;
-    std::vector<MatchProcessor*> MP_;
-    std::vector<FitTrack*> FT_;
-    std::vector<PurgeDuplicate*> PD_;
+    std::vector<std::unique_ptr<InputLinkMemory> > IL_;
+    std::vector<std::unique_ptr<AllStubsMemory> > AS_;
+    std::vector<std::unique_ptr<VMStubsTEMemory> > VMSTE_;
+    std::vector<std::unique_ptr<VMStubsMEMemory> > VMSME_;
+    std::vector<std::unique_ptr<StubPairsMemory> > SP_;
+    std::vector<std::unique_ptr<StubTripletsMemory> > ST_;
+    std::vector<std::unique_ptr<TrackletParametersMemory> > TPAR_;
+    std::vector<std::unique_ptr<TrackletProjectionsMemory> > TPROJ_;
+    std::vector<std::unique_ptr<AllProjectionsMemory> > AP_;
+    std::vector<std::unique_ptr<VMProjectionsMemory> > VMPROJ_;
+    std::vector<std::unique_ptr<CandidateMatchMemory> > CM_;
+    std::vector<std::unique_ptr<FullMatchMemory> > FM_;
+    std::vector<std::unique_ptr<TrackFitMemory> > TF_;
+    std::vector<std::unique_ptr<CleanTrackMemory> > CT_;
+
+    std::map<std::string, ProcessBase* > Processes_;
+    std::vector<std::unique_ptr<VMRouter> > VMR_;
+    std::vector<std::unique_ptr<VMRouterCM> > VMRCM_;
+    std::vector<std::unique_ptr<TrackletEngine> > TE_;
+    std::vector<std::unique_ptr<TrackletEngineDisplaced> > TED_;
+    std::vector<std::unique_ptr<TripletEngine> > TRE_;
+    std::vector<std::unique_ptr<TrackletProcessor> > TP_;
+    std::vector<std::unique_ptr<TrackletCalculator> > TC_;
+    std::vector<std::unique_ptr<TrackletCalculatorDisplaced> > TCD_;
+    std::vector<std::unique_ptr<ProjectionRouter> > PR_;
+    std::vector<std::unique_ptr<MatchEngine> > ME_;
+    std::vector<std::unique_ptr<MatchCalculator> > MC_;
+    std::vector<std::unique_ptr<MatchProcessor> > MP_;
+    std::vector<std::unique_ptr<FitTrack> > FT_;
+    std::vector<std::unique_ptr<PurgeDuplicate> > PD_;
   };
 };  // namespace trklet
 #endif
diff --git a/L1Trigger/TrackFindingTracklet/interface/Settings.h b/L1Trigger/TrackFindingTracklet/interface/Settings.h
index c2400bfe4cad2..7c8078ec2de4a 100644
--- a/L1Trigger/TrackFindingTracklet/interface/Settings.h
+++ b/L1Trigger/TrackFindingTracklet/interface/Settings.h
@@ -23,6 +23,11 @@ namespace trklet {
 
   constexpr unsigned int N_DSS_MOD = 5;  // # of rings with 2S modules per disk
 
+  constexpr unsigned int NRINVBITS = 5;  //number of bit for rinv in bend match table 
+  constexpr unsigned int NFINERZBITS = 3; //number of bit for r or z within a r/z bin 
+
+  constexpr double sixth = 1.0/6.0;     //Commonly used factor
+
   class Settings {
   public:
     Settings() {
diff --git a/L1Trigger/TrackFindingTracklet/interface/TrackletEngineUnit.h b/L1Trigger/TrackFindingTracklet/interface/TrackletEngineUnit.h
index 3161454cf148d..120e8891e9c2e 100644
--- a/L1Trigger/TrackFindingTracklet/interface/TrackletEngineUnit.h
+++ b/L1Trigger/TrackFindingTracklet/interface/TrackletEngineUnit.h
@@ -42,9 +42,9 @@ namespace trklet {
 
     bool empty() const { return candpairs_.empty(); }
 
-    std::pair<const Stub*, const Stub*> read() { return candpairs_.read(); }
+    const std::pair<const Stub*, const Stub*>& read() { return candpairs_.read(); }
 
-    std::pair<const Stub*, const Stub*> peek() const { return candpairs_.peek(); }
+    const std::pair<const Stub*, const Stub*>& peek() const { return candpairs_.peek(); }
 
     bool idle() const { return idle_; }
 
diff --git a/L1Trigger/TrackFindingTracklet/interface/TrackletProcessor.h b/L1Trigger/TrackFindingTracklet/interface/TrackletProcessor.h
index 8d76ad68487f6..6a227e6ffea12 100644
--- a/L1Trigger/TrackFindingTracklet/interface/TrackletProcessor.h
+++ b/L1Trigger/TrackFindingTracklet/interface/TrackletProcessor.h
@@ -44,6 +44,9 @@ namespace trklet {
 
     VMStubsTEMemory* outervmstubs_;
 
+    // The use of a std::tuple here is awkward and should be fixed. This code is slotted for a significant
+    // overhaul to allign with the HLS implementation. At that point the use fo the tuple should be 
+    // eliminated
     //                                               istub          imem        start imem    end imem
     std::vector<std::tuple<CircularBuffer<TEData>, unsigned int, unsigned int, unsigned int, unsigned int> >
         tedatabuffers_;
diff --git a/L1Trigger/TrackFindingTracklet/src/MatchEngineUnit.cc b/L1Trigger/TrackFindingTracklet/src/MatchEngineUnit.cc
index 506f1f89fd242..65c917ab486d6 100644
--- a/L1Trigger/TrackFindingTracklet/src/MatchEngineUnit.cc
+++ b/L1Trigger/TrackFindingTracklet/src/MatchEngineUnit.cc
@@ -81,7 +81,7 @@ void MatchEngineUnit::step() {
       usesecond_ = false;
       istub_ = 0;
       slot_++;
-      projfinerz_ -= 8;
+      projfinerz_ -= (1<<NFINERZBITS);
     } else {
       idle_ = true;
     }
diff --git a/L1Trigger/TrackFindingTracklet/src/MatchProcessor.cc b/L1Trigger/TrackFindingTracklet/src/MatchProcessor.cc
index d736200b6c6bf..412a847537be9 100644
--- a/L1Trigger/TrackFindingTracklet/src/MatchProcessor.cc
+++ b/L1Trigger/TrackFindingTracklet/src/MatchProcessor.cc
@@ -302,7 +302,7 @@ void MatchProcessor::execute() {
 
             int projrinv = -1;
             if (barrel_) {
-              projrinv = 16 + (proj->fpgarinv().value() >> (proj->fpgarinv().nbits() - 5));
+              projrinv = (1<<(NRINVBITS-1)) + (proj->fpgarinv().value() >> (proj->fpgarinv().nbits() - NRINVBITS));
             } else {
               //The next lines looks up the predicted bend based on:
               // 1 - r projections
@@ -327,8 +327,9 @@ void MatchProcessor::execute() {
 
             unsigned int slot = barrel_ ? proj->zbin1projvm(layer_) : proj->rbin1projvm(disk_);
             bool second = (barrel_ ? proj->zbin2projvm(layer_) : proj->rbin2projvm(disk_));
-
-            unsigned int projfinephi = (fpgaphi.value() >> (fpgaphi.nbits() - (nvmbits_ + 3))) & 7;
+	    
+	    int nfinephi=3;
+            unsigned int projfinephi = (fpgaphi.value() >> (fpgaphi.nbits() - (nvmbits_ + nfinephi))) & ((1<<nfinephi)-1);
             int projfinerz = barrel_ ? proj->finezvm(layer_) : proj->finervm(disk_);
 
             bool isPSseed = proj->PSseed() == 1;
@@ -416,7 +417,7 @@ void MatchProcessor::execute() {
       }
 
       if (iMEbest != nMatchEngines_ && (!bestInPipeline)) {
-        std::pair<Tracklet*, const Stub*> candmatch = matchengines_[iMEbest].read();
+        const std::pair<Tracklet*, const Stub*>& candmatch = matchengines_[iMEbest].read();
 
         const Stub* fpgastub = candmatch.second;
         Tracklet* tracklet = candmatch.first;
diff --git a/L1Trigger/TrackFindingTracklet/src/Sector.cc b/L1Trigger/TrackFindingTracklet/src/Sector.cc
index eb55110e39175..9ecef0c857f3e 100644
--- a/L1Trigger/TrackFindingTracklet/src/Sector.cc
+++ b/L1Trigger/TrackFindingTracklet/src/Sector.cc
@@ -93,33 +93,33 @@ bool Sector::addStub(L1TStub stub, string dtc) {
 
 void Sector::addMem(string memType, string memName) {
   if (memType == "InputLink:") {
-    addMemToVec(IL_, new InputLinkMemory(memName, settings_, isector_, phimin_, phimax_), memName);
+    addMemToVec(IL_, memName, settings_, isector_, phimin_, phimax_);
   } else if (memType == "AllStubs:") {
-    addMemToVec(AS_, new AllStubsMemory(memName, settings_, isector_), memName);
+    addMemToVec(AS_, memName, settings_, isector_);
   } else if (memType == "VMStubsTE:") {
-    addMemToVec(VMSTE_, new VMStubsTEMemory(memName, settings_, isector_), memName);
+    addMemToVec(VMSTE_, memName, settings_, isector_);
   } else if (memType == "VMStubsME:") {
-    addMemToVec(VMSME_, new VMStubsMEMemory(memName, settings_, isector_), memName);
+    addMemToVec(VMSME_, memName, settings_, isector_);
   } else if (memType == "StubPairs:" || memType == "StubPairsDisplaced:") {
-    addMemToVec(SP_, new StubPairsMemory(memName, settings_, isector_), memName);
+    addMemToVec(SP_, memName, settings_, isector_);
   } else if (memType == "StubTriplets:") {
-    addMemToVec(ST_, new StubTripletsMemory(memName, settings_, isector_), memName);
+    addMemToVec(ST_, memName, settings_, isector_);
   } else if (memType == "TrackletParameters:") {
-    addMemToVec(TPAR_, new TrackletParametersMemory(memName, settings_, isector_), memName);
+    addMemToVec(TPAR_, memName, settings_, isector_);
   } else if (memType == "TrackletProjections:") {
-    addMemToVec(TPROJ_, new TrackletProjectionsMemory(memName, settings_, isector_), memName);
+    addMemToVec(TPROJ_, memName, settings_, isector_);
   } else if (memType == "AllProj:") {
-    addMemToVec(AP_, new AllProjectionsMemory(memName, settings_, isector_), memName);
+    addMemToVec(AP_, memName, settings_, isector_);
   } else if (memType == "VMProjections:") {
-    addMemToVec(VMPROJ_, new VMProjectionsMemory(memName, settings_, isector_), memName);
+    addMemToVec(VMPROJ_, memName, settings_, isector_);
   } else if (memType == "CandidateMatch:") {
-    addMemToVec(CM_, new CandidateMatchMemory(memName, settings_, isector_), memName);
+    addMemToVec(CM_, memName, settings_, isector_);
   } else if (memType == "FullMatch:") {
-    addMemToVec(FM_, new FullMatchMemory(memName, settings_, isector_), memName);
+    addMemToVec(FM_, memName, settings_, isector_);
   } else if (memType == "TrackFit:") {
-    addMemToVec(TF_, new TrackFitMemory(memName, settings_, isector_, phimin_, phimax_), memName);
+    addMemToVec(TF_, memName, settings_, isector_, phimin_, phimax_);
   } else if (memType == "CleanTrack:") {
-    addMemToVec(CT_, new CleanTrackMemory(memName, settings_, isector_, phimin_, phimax_), memName);
+    addMemToVec(CT_, memName, settings_, isector_, phimin_, phimax_);
   } else {
     edm::LogPrint("Tracklet") << "Don't know of memory type: " << memType;
     exit(0);
@@ -128,34 +128,34 @@ void Sector::addMem(string memType, string memName) {
 
 void Sector::addProc(string procType, string procName) {
   if (procType == "VMRouter:") {
-    addProcToVec(VMR_, new VMRouter(procName, settings_, globals_, isector_), procName);
+    addProcToVec(VMR_, procName, settings_, globals_, isector_);
   } else if (procType == "VMRouterCM:") {
-    addProcToVec(VMRCM_, new VMRouterCM(procName, settings_, globals_, isector_), procName);
+    addProcToVec(VMRCM_, procName, settings_, globals_, isector_);
   } else if (procType == "TrackletEngine:") {
-    addProcToVec(TE_, new TrackletEngine(procName, settings_, globals_, isector_), procName);
+    addProcToVec(TE_, procName, settings_, globals_, isector_);
   } else if (procType == "TrackletEngineDisplaced:") {
-    addProcToVec(TED_, new TrackletEngineDisplaced(procName, settings_, globals_, isector_), procName);
+    addProcToVec(TED_, procName, settings_, globals_, isector_);
   } else if (procType == "TripletEngine:") {
-    addProcToVec(TRE_, new TripletEngine(procName, settings_, globals_, isector_), procName);
+    addProcToVec(TRE_, procName, settings_, globals_, isector_);
   } else if (procType == "TrackletCalculator:") {
-    addProcToVec(TC_, new TrackletCalculator(procName, settings_, globals_, isector_), procName);
+    addProcToVec(TC_, procName, settings_, globals_, isector_);
   } else if (procType == "TrackletProcessor:") {
-    addProcToVec(TP_, new TrackletProcessor(procName, settings_, globals_, isector_), procName);
+    addProcToVec(TP_, procName, settings_, globals_, isector_);
   } else if (procType == "TrackletCalculatorDisplaced:") {
-    addProcToVec(TCD_, new TrackletCalculatorDisplaced(procName, settings_, globals_, isector_), procName);
+    addProcToVec(TCD_, procName, settings_, globals_, isector_);
   } else if (procType == "ProjectionRouter:") {
-    addProcToVec(PR_, new ProjectionRouter(procName, settings_, globals_, isector_), procName);
+    addProcToVec(PR_, procName, settings_, globals_, isector_);
   } else if (procType == "MatchEngine:") {
-    addProcToVec(ME_, new MatchEngine(procName, settings_, globals_, isector_), procName);
+    addProcToVec(ME_, procName, settings_, globals_, isector_);
   } else if (procType == "MatchCalculator:" ||
              procType == "DiskMatchCalculator:") {  //TODO should not be used in configurations
-    addProcToVec(MC_, new MatchCalculator(procName, settings_, globals_, isector_), procName);
+    addProcToVec(MC_, procName, settings_, globals_, isector_);
   } else if (procType == "MatchProcessor:") {
-    addProcToVec(MP_, new MatchProcessor(procName, settings_, globals_, isector_), procName);
+    addProcToVec(MP_, procName, settings_, globals_, isector_);
   } else if (procType == "FitTrack:") {
-    addProcToVec(FT_, new FitTrack(procName, settings_, globals_, isector_), procName);
+    addProcToVec(FT_, procName, settings_, globals_, isector_);
   } else if (procType == "PurgeDuplicate:") {
-    addProcToVec(PD_, new PurgeDuplicate(procName, settings_, globals_, isector_), procName);
+    addProcToVec(PD_, procName, settings_, globals_, isector_);
   } else {
     edm::LogPrint("Tracklet") << "Don't know of processing type: " << procType;
     exit(0);
@@ -190,7 +190,7 @@ ProcessBase* Sector::getProc(string procName) {
   auto it = Processes_.find(procName);
 
   if (it != Processes_.end()) {
-    return it->second.get();
+    return it->second;
   }
   throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " Could not find process : " << procName << endl;
   return nullptr;
@@ -200,7 +200,7 @@ MemoryBase* Sector::getMem(string memName) {
   auto it = Memories_.find(memName);
 
   if (it != Memories_.end()) {
-    return it->second.get();
+    return it->second;
   }
   throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " Could not find memory : " << memName;
   return nullptr;
@@ -402,7 +402,7 @@ void Sector::executePD(std::vector<Track*>& tracks) {
 
 std::vector<Tracklet*> Sector::getAllTracklets() const {
   std::vector<Tracklet*> tmp;
-  for (auto tpar : TPAR_) {
+  for (auto& tpar : TPAR_) {
     for (unsigned int j = 0; j < tpar->nTracklets(); j++) {
       tmp.push_back(tpar->getTracklet(j));
     }
@@ -413,7 +413,7 @@ std::vector<Tracklet*> Sector::getAllTracklets() const {
 std::vector<const Stub*> Sector::getStubs() const {
   std::vector<const Stub*> tmp;
 
-  for (auto imem : IL_) {
+  for (auto& imem : IL_) {
     for (unsigned int istub = 0; istub < imem->nStubs(); istub++) {
       tmp.push_back(imem->getStub(istub));
     }
@@ -424,7 +424,7 @@ std::vector<const Stub*> Sector::getStubs() const {
 
 std::unordered_set<int> Sector::seedMatch(int itp) const {
   std::unordered_set<int> tmpSeeds;
-  for (auto i : TPAR_) {
+  for (auto& i : TPAR_) {
     unsigned int nTracklet = i->nTracklets();
     for (unsigned int j = 0; j < nTracklet; j++) {
       if (i->getTracklet(j)->tpseed() == itp) {
diff --git a/L1Trigger/TrackFindingTracklet/src/TrackDerTable.cc b/L1Trigger/TrackFindingTracklet/src/TrackDerTable.cc
index c8788cc70b149..ab41c5207f885 100644
--- a/L1Trigger/TrackFindingTracklet/src/TrackDerTable.cc
+++ b/L1Trigger/TrackFindingTracklet/src/TrackDerTable.cc
@@ -371,12 +371,13 @@ void TrackDerTable::fillTable() {
     if (outL.fail())
       throw cms::Exception("BadFile") << __FILE__ << " " << __LINE__ << " could not create file " << fnameL;
 
+    int nbits=6;
     for (unsigned int i = 0; i < LayerMem_.size(); i++) {
       FPGAWord tmp;
       int tmp1 = LayerMem_[i];
       if (tmp1 < 0)
-        tmp1 = (1 << 6) - 1;
-      tmp.set(tmp1, 6, true, __LINE__, __FILE__);
+        tmp1 = (1 << nbits) - 1;
+      tmp.set(tmp1, nbits, true, __LINE__, __FILE__);
       outL << tmp.str() << endl;
     }
     outL.close();
@@ -386,11 +387,12 @@ void TrackDerTable::fillTable() {
     if (outD.fail())
       throw cms::Exception("BadFile") << __FILE__ << " " << __LINE__ << " could not create file " << fnameD;
 
+    nbits=7;
     for (int tmp1 : DiskMem_) {
       if (tmp1 < 0)
-        tmp1 = (1 << 7) - 1;
+        tmp1 = (1 << nbits) - 1;
       FPGAWord tmp;
-      tmp.set(tmp1, 7, true, __LINE__, __FILE__);
+      tmp.set(tmp1, nbits, true, __LINE__, __FILE__);
       outD << tmp.str() << endl;
     }
     outD.close();
@@ -400,11 +402,12 @@ void TrackDerTable::fillTable() {
     if (outLD.fail())
       throw cms::Exception("BadFile") << __FILE__ << " " << __LINE__ << " could not create file " << fnameLD;
 
+    nbits=15;
     for (int tmp1 : LayerDiskMem_) {
       if (tmp1 < 0)
-        tmp1 = (1 << 15) - 1;
+        tmp1 = (1 << nbits) - 1;
       FPGAWord tmp;
-      tmp.set(tmp1, 15, true, __LINE__, __FILE__);
+      tmp.set(tmp1, nbits, true, __LINE__, __FILE__);
       outLD << tmp.str() << endl;
     }
     outLD.close();
@@ -628,71 +631,79 @@ void TrackDerTable::fillTable() {
         }    // if (goodseed)
 
         FPGAWord tmprinvdphi[N_PROJ];
+	int nbits=16;
         for (unsigned int j = 0; j < N_PROJ; ++j) {
-          if (itmprinvdphi[j] > (1 << 16))
-            itmprinvdphi[j] = (1 << 16) - 1;
-          tmprinvdphi[j].set(itmprinvdphi[j], 17, false, __LINE__, __FILE__);
+          if (itmprinvdphi[j] > (1 << nbits))
+            itmprinvdphi[j] = (1 << nbits) - 1;
+          tmprinvdphi[j].set(itmprinvdphi[j], nbits+1, false, __LINE__, __FILE__);
         }
         outrinvdphi[i] << tmprinvdphi[0].str() << tmprinvdphi[1].str() << tmprinvdphi[2].str() << tmprinvdphi[3].str()
                        << endl;
 
         FPGAWord tmprinvdzordr[N_PROJ];
+	nbits=15;
         for (unsigned int j = 0; j < N_PROJ; ++j) {
-          if (itmprinvdzordr[j] > (1 << 15))
-            itmprinvdzordr[j] = (1 << 15) - 1;
-          tmprinvdzordr[j].set(itmprinvdzordr[j], 16, false, __LINE__, __FILE__);
+          if (itmprinvdzordr[j] > (1 << nbits))
+            itmprinvdzordr[j] = (1 << nbits) - 1;
+          tmprinvdzordr[j].set(itmprinvdzordr[j], nbits+1, false, __LINE__, __FILE__);
         }
         outrinvdzordr[i] << tmprinvdzordr[0].str() << tmprinvdzordr[1].str() << tmprinvdzordr[2].str()
                          << tmprinvdzordr[3].str() << endl;
 
         FPGAWord tmpphi0dphi[N_PROJ];
+	nbits=13;
         for (unsigned int j = 0; j < N_PROJ; ++j) {
-          if (itmpphi0dphi[j] > (1 << 13))
-            itmpphi0dphi[j] = (1 << 13) - 1;
-          tmpphi0dphi[j].set(itmpphi0dphi[j], 14, false, __LINE__, __FILE__);
+          if (itmpphi0dphi[j] > (1 << nbits))
+            itmpphi0dphi[j] = (1 << nbits) - 1;
+          tmpphi0dphi[j].set(itmpphi0dphi[j], nbits+1, false, __LINE__, __FILE__);
         }
         outphi0dphi[i] << tmpphi0dphi[0].str() << tmpphi0dphi[1].str() << tmpphi0dphi[2].str() << tmpphi0dphi[3].str()
                        << endl;
 
         FPGAWord tmpphi0dzordr[N_PROJ];
+	nbits=15;
         for (unsigned int j = 0; j < N_PROJ; ++j) {
-          if (itmpphi0dzordr[j] > (1 << 15))
-            itmpphi0dzordr[j] = (1 << 15) - 1;
-          tmpphi0dzordr[j].set(itmpphi0dzordr[j], 16, false, __LINE__, __FILE__);
+          if (itmpphi0dzordr[j] > (1 << nbits))
+            itmpphi0dzordr[j] = (1 << nbits) - 1;
+          tmpphi0dzordr[j].set(itmpphi0dzordr[j], nbits+1, false, __LINE__, __FILE__);
         }
         outphi0dzordr[i] << tmpphi0dzordr[0].str() << tmpphi0dzordr[1].str() << tmpphi0dzordr[2].str()
                          << tmpphi0dzordr[3].str() << endl;
 
         FPGAWord tmptdphi[N_PROJ];
+	nbits=14;
         for (unsigned int j = 0; j < N_PROJ; ++j) {
-          if (itmptdphi[j] > (1 << 14))
-            itmptdphi[j] = (1 << 14) - 1;
-          tmptdphi[j].set(itmptdphi[j], 15, false, __LINE__, __FILE__);
+          if (itmptdphi[j] > (1 << nbits))
+            itmptdphi[j] = (1 << nbits) - 1;
+          tmptdphi[j].set(itmptdphi[j], nbits+1, false, __LINE__, __FILE__);
         }
         outtdphi[i] << tmptdphi[0].str() << tmptdphi[1].str() << tmptdphi[2].str() << tmptdphi[3].str() << endl;
 
         FPGAWord tmptdzordr[N_PROJ];
+	nbits=15;
         for (unsigned int j = 0; j < N_PROJ; ++j) {
-          if (itmptdzordr[j] > (1 << 15))
-            itmptdzordr[j] = (1 << 15) - 1;
-          tmptdzordr[j].set(itmptdzordr[j], 16, false, __LINE__, __FILE__);
+          if (itmptdzordr[j] > (1 << nbits))
+            itmptdzordr[j] = (1 << nbits) - 1;
+          tmptdzordr[j].set(itmptdzordr[j], nbits+1, false, __LINE__, __FILE__);
         }
         outtdzordr[i] << tmptdzordr[0].str() << tmptdzordr[1].str() << tmptdzordr[2].str() << tmptdzordr[3].str()
                       << endl;
 
         FPGAWord tmpz0dphi[N_PROJ];
+	nbits=13;
         for (unsigned int j = 0; j < N_PROJ; ++j) {
-          if (itmpz0dphi[j] > (1 << 13))
-            itmpz0dphi[j] = (1 << 13) - 1;
-          tmpz0dphi[j].set(itmpz0dphi[j], 14, false, __LINE__, __FILE__);
+          if (itmpz0dphi[j] > (1 << nbits))
+            itmpz0dphi[j] = (1 << nbits) - 1;
+          tmpz0dphi[j].set(itmpz0dphi[j], nbits+1, false, __LINE__, __FILE__);
         }
         outz0dphi[i] << tmpz0dphi[0].str() << tmpz0dphi[1].str() << tmpz0dphi[2].str() << tmpz0dphi[3].str() << endl;
 
         FPGAWord tmpz0dzordr[N_PROJ];
+	nbits=15;
         for (unsigned int j = 0; j < N_PROJ; ++j) {
-          if (itmpz0dzordr[j] > (1 << 15))
-            itmpz0dzordr[j] = (1 << 15) - 1;
-          tmpz0dzordr[j].set(itmpz0dzordr[j], 16, false, __LINE__, __FILE__);
+          if (itmpz0dzordr[j] > (1 << nbits))
+            itmpz0dzordr[j] = (1 << nbits) - 1;
+          tmpz0dzordr[j].set(itmpz0dzordr[j], nbits+1, false, __LINE__, __FILE__);
         }
         outz0dzordr[i] << tmpz0dzordr[0].str() << tmpz0dzordr[1].str() << tmpz0dzordr[2].str() << tmpz0dzordr[3].str()
                        << endl;
diff --git a/L1Trigger/TrackFindingTracklet/src/TrackletCalculatorDisplaced.cc b/L1Trigger/TrackFindingTracklet/src/TrackletCalculatorDisplaced.cc
index 4bf07f9c8f889..e274119c716d4 100644
--- a/L1Trigger/TrackFindingTracklet/src/TrackletCalculatorDisplaced.cc
+++ b/L1Trigger/TrackFindingTracklet/src/TrackletCalculatorDisplaced.cc
@@ -1767,11 +1767,11 @@ void TrackletCalculatorDisplaced::approxproj(double halfRinv,
   double rmeanInv = 1.0 / rmean;
 
   phiproj = phi0 + rmean * (-halfRinv + 2.0 * d0_0 * halfRinv_0 * halfRinv_0) +
-            rmeanInv * (-d0 + halfRinv_0 * d0_0 * d0_0) + (1.0 / 6.0) * pow(-rmean * halfRinv_0 - rmeanInv * d0_0, 3);
+            rmeanInv * (-d0 + halfRinv_0 * d0_0 * d0_0) + sixth * pow(-rmean * halfRinv_0 - rmeanInv * d0_0, 3);
   phiprojder = -halfRinv + d0 * rmeanInv * rmeanInv;  //removed all high terms
 
   zproj = z0 + t * rmean - 0.5 * rmeanInv * t * d0_0 * d0_0 - t * rmean * halfRinv * d0 +
-          (1.0 / 6.0) * pow(rmean, 3) * t * halfRinv_0 * halfRinv_0;
+          sixth * pow(rmean, 3) * t * halfRinv_0 * halfRinv_0;
   zprojder = t;  // removed all high terms
 
   phiproj = angle0to2pi::make0To2pi(phiproj);
@@ -1803,7 +1803,7 @@ void TrackletCalculatorDisplaced::approxprojdisk(double halfRinv,
 
   double zmeanInv = 1.0 / zmean, rstar = (zmean - z0) / t,
          epsilon = 0.5 * zmeanInv * zmeanInv * d0_0 * d0_0 * t * t + halfRinv * d0 -
-                   (1.0 / 6.0) * rstar * rstar * halfRinv_0 * halfRinv_0;
+                   sixth * rstar * rstar * halfRinv_0 * halfRinv_0;
 
   rproj = rstar * (1 + epsilon);
   rprojder = 1 / t;
@@ -1815,7 +1815,7 @@ void TrackletCalculatorDisplaced::approxprojdisk(double halfRinv,
   double B_0 = -d0_0 * t * zmeanInv * (1 + z0 * zmeanInv) * (1 - epsilon);
   // double C_0 = -d0_0 * halfRinv_0;
 
-  phiproj = phi0 - A + B * (1 + C - 2 * A_0 * A_0) + (1. / 6.) * pow(-A_0 + B_0, 3);
+  phiproj = phi0 - A + B * (1 + C - 2 * A_0 * A_0) + sixth * pow(-A_0 + B_0, 3);
   phiprojder = -halfRinv / t - d0 * t * t * zmeanInv * zmeanInv;
 
   phiproj = angle0to2pi::make0To2pi(phiproj);
@@ -1870,11 +1870,11 @@ void TrackletCalculatorDisplaced::approxtracklet(double r1,
     d0OverR = d0OverR3;
 
   double c1 = d0_0 * halfRinv_0 * d0OverR1 + 2.0 * d0_0 * halfRinv_0 * r1 * halfRinv_0 +
-              (1.0 / 6.0) * pow(-r1 * halfRinv_0 - d0OverR1, 3);
+              sixth * pow(-r1 * halfRinv_0 - d0OverR1, 3);
   double c2 = d0_0 * halfRinv_0 * d0OverR2 + 2.0 * d0_0 * halfRinv_0 * r2 * halfRinv_0 +
-              (1.0 / 6.0) * pow(-r2 * halfRinv_0 - d0OverR2, 3);
+              sixth * pow(-r2 * halfRinv_0 - d0OverR2, 3);
   double c3 = d0_0 * halfRinv_0 * d0OverR3 + 2.0 * d0_0 * halfRinv_0 * r3 * halfRinv_0 +
-              (1.0 / 6.0) * pow(-r3 * halfRinv_0 - d0OverR3, 3);
+              sixth * pow(-r3 * halfRinv_0 - d0OverR3, 3);
 
   double phi1c = phi1 - c1;
   double phi2c = phi2 - c2;
@@ -1886,9 +1886,9 @@ void TrackletCalculatorDisplaced::approxtracklet(double r1,
   d0 = r1 * r2 * r3 * (-phi1c * a + phi2c * b - phi3c * c);
 
   t = ((z - z1) / (r - r1)) * (1. + d0 * halfRinv - 0.5 * d0OverR1 * d0OverR -
-                               (1. / 6.) * (r1 * r1 + r2 * r2 + r1 * r2) * halfRinv_0 * halfRinv_0);
+                               sixth * (r1 * r1 + r2 * r2 + r1 * r2) * halfRinv_0 * halfRinv_0);
   z0 = z1 -
-       t * r1 * (1.0 - d0_0 * halfRinv_0 - 0.5 * d0OverR1 * d0OverR1 + (1.0 / 6.0) * r1 * r1 * halfRinv_0 * halfRinv_0);
+       t * r1 * (1.0 - d0_0 * halfRinv_0 - 0.5 * d0OverR1 * d0OverR1 + sixth * r1 * r1 * halfRinv_0 * halfRinv_0);
 
   rinv = 2.0 * halfRinv;
   phi0 += -phimin_;
diff --git a/L1Trigger/TrackFindingTracklet/src/TrackletEngineUnit.cc b/L1Trigger/TrackFindingTracklet/src/TrackletEngineUnit.cc
index 2fa65339eb932..d51e3c373749b 100644
--- a/L1Trigger/TrackFindingTracklet/src/TrackletEngineUnit.cc
+++ b/L1Trigger/TrackFindingTracklet/src/TrackletEngineUnit.cc
@@ -46,12 +46,12 @@ void TrackletEngineUnit::step() {
 
   int ibin = tedata_.start_ + next_;
 
-  int nbins = 8;  //FIXME
+  int nbins = (1<<NFINERZBITS);
 
   assert(istub_ < outervmstubs_->nVMStubsBinned(ireg_ * nbins + ibin));
 
   const VMStubTE& outervmstub = outervmstubs_->getVMStubTEBinned(ireg_ * nbins + ibin, istub_);
-  int rzbin = (outervmstub.vmbits().value() & 7);
+  int rzbin = (outervmstub.vmbits().value() & (nbins-1));
 
   FPGAWord iphiouterbin = outervmstub.finephi();
 
@@ -65,13 +65,17 @@ void TrackletEngineUnit::step() {
   if (idphi < 0)
     idphi = idphi + (1 << nbitsfinephidiff_);
 
-  if (iSeed_ >= 4) {  //Also use r-position
-    int ir = ((ibin & 3) << 1) + (rzbin >> 2);
-    idphi = (idphi << 3) + ir;
+
+  unsigned int firstDiskSeed=4;
+  if (iSeed_ >= firstDiskSeed) {  //Also use r-position
+    int ibinMask=3; //Get two least sign. bits
+    int ir = ((ibin & ibinMask) << 1) + (rzbin >> (NFINERZBITS-1));
+    int nrbits=3;
+    idphi = (idphi << nrbits) + ir;
   }
 
   if (next_ != 0)
-    rzbin += 8;
+    rzbin += (1<<NFINERZBITS);
   if ((rzbin < tedata_.rzbinfirst_) || (rzbin - tedata_.rzbinfirst_ > tedata_.rzdiffmax_)) {
     if (settings_->debugTracklet()) {
       edm::LogVerbatim("Tracklet") << " layer-disk stub pair rejected because rbin cut : " << rzbin << " "
diff --git a/L1Trigger/TrackFindingTracklet/src/TrackletProcessor.cc b/L1Trigger/TrackFindingTracklet/src/TrackletProcessor.cc
index 845f8dc1b6dbb..2a69f31c4475a 100644
--- a/L1Trigger/TrackFindingTracklet/src/TrackletProcessor.cc
+++ b/L1Trigger/TrackFindingTracklet/src/TrackletProcessor.cc
@@ -39,7 +39,7 @@ TrackletProcessor::TrackletProcessor(string name, Settings const& settings, Glob
 
   vmrtable_.init(layerdisk1_, getName());
 
-  nbitsrzbin_ = 3;
+  nbitsrzbin_ = NFINERZBITS;
   if (iSeed_ == 4 || iSeed_ == 5)
     nbitsrzbin_ = 2;
 
@@ -149,15 +149,13 @@ void TrackletProcessor::addInput(MemoryBase* memory, string input) {
       innerallstubs_.push_back(tmp);
     }
 
-    //FIXEM should be done once after all inputs are added
+    //FIXME should be done once after all inputs are added
     tedatabuffers_.clear();
     CircularBuffer<TEData> tedatabuffertmp(5);
     tedatabuffertmp.reset();
 
-    tedatabuffers_.emplace_back(tuple<CircularBuffer<TEData>, unsigned int, unsigned int, unsigned int, unsigned int>(
-        tedatabuffertmp, 0, 0, 0, (innerallstubs_.size() + 1) / 2));
-    tedatabuffers_.emplace_back(tuple<CircularBuffer<TEData>, unsigned int, unsigned int, unsigned int, unsigned int>(
-        tedatabuffertmp, 0, (innerallstubs_.size() + 1) / 2, (innerallstubs_.size() + 1) / 2, innerallstubs_.size()));
+    tedatabuffers_.emplace_back(tedatabuffertmp, 0, 0, 0, (innerallstubs_.size() + 1) / 2);
+    tedatabuffers_.emplace_back(tedatabuffertmp, 0, (innerallstubs_.size() + 1) / 2, (innerallstubs_.size() + 1) / 2, innerallstubs_.size());
 
     return;
   }
diff --git a/L1Trigger/TrackFindingTracklet/src/VMRouterCM.cc b/L1Trigger/TrackFindingTracklet/src/VMRouterCM.cc
index 70fc79932ac7a..72e9983e8483b 100644
--- a/L1Trigger/TrackFindingTracklet/src/VMRouterCM.cc
+++ b/L1Trigger/TrackFindingTracklet/src/VMRouterCM.cc
@@ -43,7 +43,7 @@ void VMRouterCM::addOutput(MemoryBase* memory, string output) {
     if (output.size() > 10) {
       memtype = output[11];
     }
-    allstubs_.push_back(pair<char, AllStubsMemory*>(memtype, tmp));
+    allstubs_.emplace_back(memtype, tmp);
     return;
   }
 
@@ -193,10 +193,10 @@ void VMRouterCM::execute() {
 
       assert(melut >= 0);
 
-      int vmbin = melut >> 3;
+      int vmbin = melut >> NFINERZBITS;
       if (negdisk)
-        vmbin += 8;
-      int rzfine = melut & 7;
+        vmbin += (1<<NFINERZBITS);
+      int rzfine = melut & ((1<<NFINERZBITS)-1);
 
       // pad disk PS bend word with a '0' in MSB so that all disk bends have 4 bits (for HLS compatibility)
       int nbendbits = stub->bend().nbits();
@@ -204,8 +204,8 @@ void VMRouterCM::execute() {
         nbendbits = settings_.nbendbitsmedisk();
 
       VMStubME vmstub(stub,
-                      stub->iphivmFineBins(settings_.nbitsallstubs(layerdisk_) + settings_.nbitsvmme(layerdisk_), 3),
-                      FPGAWord(rzfine, 3, true, __LINE__, __FILE__),
+                      stub->iphivmFineBins(settings_.nbitsallstubs(layerdisk_) + settings_.nbitsvmme(layerdisk_), NFINERZBITS),
+                      FPGAWord(rzfine, NFINERZBITS, true, __LINE__, __FILE__),
                       FPGAWord(stub->bend().value(), nbendbits, true, __LINE__, __FILE__),
                       allStubIndex);