diff --git a/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddBase.cc b/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddBase.cc
index f6680dc2055658b4d57f6374a6e24974f180f8b0..3d236b21cd104822bd92b3ebcf5dd9072fc7acf3 100644
--- a/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddBase.cc
+++ b/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddBase.cc
@@ -4,6 +4,9 @@
 
 #include "fastnlotk/fastNLOCoeffAddBase.h"
 #include "fastnlotk/fastNLOTools.h"
+#include "fastnlotk/fastNLOEvent.h"
+#include "fastnlotk/fastNLOInterpolBase.h"
+#include "fastnlotk/fastNLOTools.h"
 
 using namespace std;
 using namespace fastNLO;
@@ -844,3 +847,37 @@ void fastNLOCoeffAddBase::CatBin(const fastNLOCoeffAddBase& other, unsigned int
    }
    fastNLOCoeffBase::CatBin(other, iObsIdx);
 }
+
+
+//________________________________________________________________________________________________________________ //
+void fastNLOCoeffAddBase::ExtendX(int ObsBin, std::vector<fastNLOInterpolBase*>& KernX1, std::vector<fastNLOInterpolBase*>& KernX2) {
+   unsigned int oldXSize1 = GetNxtot1(ObsBin);
+   unsigned int oldXSize2 = GetNxtot2(ObsBin);
+   bool x1Extended = fastNLOTools::ExtendHead(XNode1[ObsBin], KernX1[ObsBin]->fgrid);
+   if (NPDFDim > 1) {
+      bool x2Extended = fastNLOTools::ExtendHead(XNode2[ObsBin], KernX2[ObsBin]->fgrid);
+      if (!x1Extended && !x2Extended) {
+         return;
+      }
+   } else {
+      if (!x1Extended) {
+         return;
+      }
+   }
+   ExtendSigmaTildeX(ObsBin, oldXSize1, oldXSize2);
+}
+
+
+//________________________________________________________________________________________________________________ //
+void fastNLOCoeffAddBase::ExtendSigmaTildeX(int ObsBin, unsigned int OldXSize1, unsigned int OldXSize2) {
+   error["ExtendSigmaTildeX"] << "Method not implemented for fastNLOCoeffAddBase subclass. Exiting." << endl;
+   exit(1);
+}
+
+
+//________________________________________________________________________________________________________________ //
+void fastNLOCoeffAddBase::Fill(fnloEvent& Event, int ObsBin, int X, int scalevar,
+      const std::vector<std::pair<int, double>>& nmu1, const std::vector<std::pair<int, double>>& nmu2, int SubProcess, double w) {
+   error["Fill"] << "Method not implemented for fastNLOCoeffAddBase subclass. Exiting." << endl;
+   exit(1);
+}
diff --git a/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddFix.cc b/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddFix.cc
index 705198640a9e2d1823deb4b26e8d5f0820899df0..7347157e0ca3ea40f6b187c6945df315750a1ac1 100644
--- a/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddFix.cc
+++ b/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddFix.cc
@@ -1,4 +1,5 @@
 #include <cstdlib>
+#include <fastnlotk/fastNLOEvent.h>
 #include <iostream>
 #include <cmath>
 #include <algorithm>
@@ -598,3 +599,28 @@ void fastNLOCoeffAddFix::CatBin(const fastNLOCoeffAddFix& other, unsigned int iO
    }
    fastNLOCoeffAddBase::CatBin(other, iObsIdx, ITabVersionRead);
 }
+
+
+//________________________________________________________________________________________________________________ //
+void fastNLOCoeffAddFix::ExtendSigmaTildeX(int ObsBin, unsigned int OldXSize1, unsigned int OldXSize2) {
+   int nScalevar = GetNScalevar();
+   int nScaleNode = GetNScaleNode();
+   int newXSize1 = GetNxtot1(ObsBin);
+   int newXSize2 = GetNxtot2(ObsBin);
+   for (int scaleVar = 0; scaleVar < nScalevar; scaleVar++) {
+      for (int scaleNode = 0; scaleNode < nScaleNode; scaleNode++) {
+         fastNLOTools::ExtendSigmaTildeX(
+            SigmaTilde[ObsBin][scaleVar][scaleNode], OldXSize1, newXSize1, OldXSize2, newXSize2,
+            NPDFDim, fastNLO::v1d(NSubproc));
+      }
+   }
+}
+
+
+//________________________________________________________________________________________________________________ //
+void fastNLOCoeffAddFix::Fill(fnloEvent& Event, int ObsBin, int X, int scalevar, const vector<pair<int, double>>& nmu1,
+      const vector<pair<int, double>>& nmu2, int SubProcess, double w) {
+   for (unsigned int m1 = 0 ; m1<nmu1.size() ; m1++) {
+      SigmaTilde[ObsBin][scalevar][nmu1[m1].first][X][SubProcess] += Event._w * nmu1[m1].second * w;
+   }
+}
diff --git a/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddFlex.cc b/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddFlex.cc
index 7c4717d57656d832d204a6cc78789a3ce3fe52d9..0f24af1c451884bc611155648596e7a375a8b876 100644
--- a/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddFlex.cc
+++ b/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddFlex.cc
@@ -5,6 +5,7 @@
 #include "fastnlotk/fastNLOTable.h"
 #include "fastnlotk/fastNLOTools.h"
 #include "fastnlotk/fastNLOCoeffAddFlex.h"
+#include "fastnlotk/fastNLOEvent.h"
 
 using namespace std;
 
@@ -688,3 +689,45 @@ bool fastNLOCoeffAddFlex::IsSigmaTildeEquivalent(const fastNLOCoeffAddFlex* op,
    }
    return true;
 }
+
+
+//________________________________________________________________________________________________________________ //
+void fastNLOCoeffAddFlex::ExtendSigmaTildeX(int ObsBin, unsigned int OldXSize1, unsigned int OldXSize2) {
+   fastNLO::v3d insertValue = fastNLO::v3d(
+      GetNScaleNode1(ObsBin), fastNLO::v2d(GetNScaleNode2(ObsBin), fastNLO::v1d(GetNSubproc())));
+   unsigned int newXSize1 = GetNxtot1(ObsBin);
+   unsigned int newXSize2 = GetNxtot2(ObsBin);
+   fastNLOTools::ExtendSigmaTildeX(
+      SigmaTildeMuIndep[ObsBin], OldXSize1, newXSize1, OldXSize2, newXSize2, NPDFDim, insertValue);
+   fastNLOTools::ExtendSigmaTildeX(
+      SigmaTildeMuRDep[ObsBin], OldXSize1, newXSize1, OldXSize2, newXSize2, NPDFDim, insertValue);
+   fastNLOTools::ExtendSigmaTildeX(
+      SigmaTildeMuFDep[ObsBin], OldXSize1, newXSize1, OldXSize2, newXSize2, NPDFDim, insertValue);
+   fastNLOTools::ExtendSigmaTildeX(
+      SigmaTildeMuRRDep[ObsBin], OldXSize1, newXSize1, OldXSize2, newXSize2, NPDFDim, insertValue);
+   fastNLOTools::ExtendSigmaTildeX(
+      SigmaTildeMuFFDep[ObsBin], OldXSize1, newXSize1, OldXSize2, newXSize2, NPDFDim, insertValue);
+   fastNLOTools::ExtendSigmaTildeX(
+      SigmaTildeMuRFDep[ObsBin], OldXSize1, newXSize1, OldXSize2, newXSize2, NPDFDim, insertValue);
+}
+
+
+//________________________________________________________________________________________________________________ //
+void fastNLOCoeffAddFlex::Fill(fnloEvent& Event, int ObsBin, int X, int scalevar, const vector<pair<int, double>>& nmu1,
+      const vector<pair<int, double>>& nmu2, int SubProcess, double w) {
+   for (unsigned int m1 = 0 ; m1<nmu1.size() ; m1++) {
+      for (unsigned int mu2 = 0 ; mu2<nmu2.size() ; mu2++) {
+         double wfnlo = nmu1[m1].second * nmu2[mu2].second * w;
+         SigmaTildeMuIndep[ObsBin][X][nmu1[m1].first][nmu2[mu2].first][SubProcess] += Event._w  * wfnlo;
+         if (Event._wf != 0 || Event._wr != 0) {
+            SigmaTildeMuFDep[ObsBin][X][nmu1[m1].first][nmu2[mu2].first][SubProcess] += Event._wf * wfnlo;
+            SigmaTildeMuRDep[ObsBin][X][nmu1[m1].first][nmu2[mu2].first][SubProcess] += Event._wr * wfnlo;
+         }
+         if (Event._wrr != 0 || Event._wff != 0 || Event._wrf != 0) {
+            SigmaTildeMuRRDep[ObsBin][X][nmu1[m1].first][nmu2[mu2].first][SubProcess] += Event._wrr * wfnlo;
+            SigmaTildeMuFFDep[ObsBin][X][nmu1[m1].first][nmu2[mu2].first][SubProcess] += Event._wff * wfnlo;
+            SigmaTildeMuRFDep[ObsBin][X][nmu1[m1].first][nmu2[mu2].first][SubProcess] += Event._wrf * wfnlo;
+         }
+      }
+   }
+}
diff --git a/v2.5/toolkit/fastnlotoolkit/fastNLOCreate.cc b/v2.5/toolkit/fastnlotoolkit/fastNLOCreate.cc
index 0043383f1586350e45fd93386f19a0ad4fdeed39..44fdb147dc3370d0d57bed42c906923eeef01f3b 100644
--- a/v2.5/toolkit/fastnlotoolkit/fastNLOCreate.cc
+++ b/v2.5/toolkit/fastnlotoolkit/fastNLOCreate.cc
@@ -2448,7 +2448,7 @@ void fastNLOCreate::FillAllSubprocesses(const vector<vector<fnloEvent> >& events
 
    // KR TODO Check to replace wgtfac by _wo
    //   cout << "WWW: wgtfac = " << wgtfac << "_wo = " << scen._wo << endl;
-   const bool bFasterCode = true; // experimental developement: try to make code faster
+   const bool bFasterCode = false; // experimental developement: try to make code faster
    if (bFasterCode && !fIsWarmup && !fIsFlexibleScale) {
       // make filling code a little bit faster ... ~40%
       // if filling step "+=" is commented, then code is a factor ~6 faster
@@ -2928,25 +2928,67 @@ void fastNLOCreate::FillContribution(int scalevar, const double wgtfac) {
 
    //logger.debug["FillContributionFixHHC"]<<"The process Id is p = "<<p<<endl;
 
-   // ---- DIS ---- //
-   if (c->GetNPDF() == 1 && fastNLOCoeffAddFlex::CheckCoeffConstants(c,true)) {
-      // todo
-      FillContributionFlexDIS((fastNLOCoeffAddFlex*)GetTheCoeffTable(), ObsBin, wgtfac);
-      //{logger.error["FillContribution"]<<"Don't know how to fill this table. Exiting."<<endl; exit(1); }
-   } else if (c->GetNPDF() == 1 && fastNLOCoeffAddFix::CheckCoeffConstants(c,true)) {
-      // todo
-      FillContributionFixDIS((fastNLOCoeffAddFix*)GetTheCoeffTable(),  ObsBin, scalevar, wgtfac);
-      //{logger.error["FillContribution"]<<"Don't know how to fill this table (DIS: fix-scale tables!). Exiting."<<endl; exit(1); }
-   }
-   // ---- pp/ppbar ---- //
-   else if (c->GetNPDF() == 2 && fastNLOCoeffAddFlex::CheckCoeffConstants(c,true))
-      FillContributionFlexHHC((fastNLOCoeffAddFlex*)GetTheCoeffTable(),  ObsBin, wgtfac);
-   else if (c->GetNPDF() == 2 && fastNLOCoeffAddFix::CheckCoeffConstants(c,true))
-      FillContributionFixHHC((fastNLOCoeffAddFix*)GetTheCoeffTable(),  ObsBin, scalevar, wgtfac);
-   else {
-      logger.error["FillContribution"]<<"Don't know how to fill this table. Exiting."<<endl;
+   //! read informatio from 'Event' and 'Scenario'
+   //! do the interpolation
+   //! and fill into the tables.
+   //logger.debug["FillContributionFlexHHC"]<<endl;
+
+   if ( wgtfac != 1.0 ) {
+      logger.error["FillContributionFlexHHC"]<<"Additional weight factor wgtfac = " << wgtfac << "not yet implemented for flex-scale tables, aborted!"<<endl;
       exit(1);
    }
+
+   if (fEvent._w == 0 && fEvent._wf==0 && fEvent._wr==0 && fEvent._wrr==0 && fEvent._wff==0 && fEvent._wrf==0) return;   // nothing todo.
+   int NPDFDim = c->GetNPDFDim();
+
+   // do interpolation
+   //cout<<"try to interpol. ObsBin="<<ObsBin<<" ,x1="<<fEvent._x1<<", x2="<<fEvent._x2<<", mu1="<<Scenario._m1<<", mu2="<<Scenario._m2<<endl;
+   double xmin = NPDFDim == 1 ? std::min(fEvent._x1,fEvent._x2) : fEvent._x1;
+   double xmax = NPDFDim == 1 ? std::max(fEvent._x1,fEvent._x2) : fEvent._x2;
+   vector<pair<int,double> > nxlo = fKernX1[ObsBin]->GetNodeValues(xmin);
+   vector<pair<int,double> > nxup;
+   if (c->NPDFDim > 1) {
+      nxup = fKernX2[ObsBin]->GetNodeValues(xmax);
+   } else {
+      nxup = fKernX1[ObsBin]->GetNodeValues(xmax);
+   }
+   c->ExtendX(ObsBin, fKernX1, fKernX2);
+
+   vector<pair<int,double>> nmu1;
+   vector<pair<int,double>> nmu2;
+   if (fIsFlexibleScale) {
+      nmu1 = fKernMu1[ObsBin]->GetNodeValues(fScenario._m1);
+      nmu2 = fKernMu2[ObsBin]->GetNodeValues(fScenario._m2);
+   } else {
+      nmu1  = fKernMuS[ObsBin][scalevar]->GetNodeValues(fScenario._m1 * fScaleFac[scalevar]);
+   }
+
+   if (fApplyPDFReweight) {
+      fKernX1[ObsBin]->CheckX(xmin);
+      fKernX2[ObsBin]->CheckX(xmax);
+      ApplyPDFWeight(nxlo,xmin,fKernX1[ObsBin]->GetGridPtr());
+      if (c->NPDFDim > 1) {
+         ApplyPDFWeight(nxup,xmax,fKernX2[ObsBin]->GetGridPtr());
+      } else {
+         ApplyPDFWeight(nxup,xmax,fKernX1[ObsBin]->GetGridPtr());
+      }
+   }
+
+   // fill grid
+   //if (!CheckWeightIsFinite()) return;
+   for (unsigned int x1 = 0 ; x1<nxlo.size() ; x1++) {
+      for (unsigned int x2 = 0 ; x2<nxup.size() ; x2++) {
+         int xminbin = nxlo[x1].first;
+         int xmaxbin = nxup[x2].first;
+         int p = fEvent._p;
+         HalfMatrixCheck(fEvent._x1,fEvent._x2,xminbin,xmaxbin,p);
+         //HalfMatrixCheck(xminbin,xmaxbin,p);
+         int ixHM = GetXIndex(ObsBin,xminbin,xmaxbin);
+         double wfnlo = wgtfac * nxlo[x1].second * nxup[x2].second / BinSize[ObsBin];
+         c->Fill(fEvent, ObsBin, ixHM, scalevar, nmu1, nmu2, p, wfnlo);
+      }
+   }
+   //cout<<" * wSumW = "<<wsum<<endl;
 }
 
 
@@ -2993,18 +3035,8 @@ void fastNLOCreate::FillContributionFixHHC(fastNLOCoeffAddFix* c, int ObsBin, in
          HalfMatrixCheck(fEvent._x1,fEvent._x2,xminbin,xmaxbin,p);
          //HalfMatrixCheck(xminbin,xmaxbin,p);
          int ixHM = GetXIndex(ObsBin,xminbin,xmaxbin);
-
-         for (unsigned int m1 = 0 ; m1<nmu.size() ; m1++) {
-            double w = wgt * nxlo[x1].second * nxup[x2].second * nmu[m1].second ;
-            if (! std::isfinite(w)) {
-               logger.error["FillContributionFixHHC"]<<"Weight w is not finite, w = " << w << "!"<<endl;
-               logger.error["FillContributionFixHHC"]<<"This should have been captured before, aborting ..."<<endl;
-               exit(1);
-            }
-            //              cout<<"   Fill * : i="<<ObsBin<<" svar="<<scalevar<<" imu="<<m1<<" ix="<<ixHM<<", im1="<<nmu[m1].first<<", p="<<p<<", w="<<nxup[x1].second * nxlo[x2].second * nmu[m1].second / BinSize[ObsBin]
-            //          <<",\tfEvent._w="<<fEvent._w<<",\twx="<<nxup[x1].second * nxlo[x2].second<<",\tws="<<nmu[m1].second<<endl;
-            c->SigmaTilde[ObsBin][scalevar][nmu[m1].first][ixHM][p] += w;
-         }
+         double w = wgt * nxlo[x1].second * nxup[x2].second;
+         c->Fill(fEvent, ObsBin, ixHM, scalevar, nmu, nmu, p, w);
       }
    }
 }
@@ -3069,51 +3101,10 @@ void fastNLOCreate::FillContributionFlexHHC(fastNLOCoeffAddFlex* c, int ObsBin,
          HalfMatrixCheck(fEvent._x1,fEvent._x2,xminbin,xmaxbin,p);
          //HalfMatrixCheck(xminbin,xmaxbin,p);
          int ixHM = GetXIndex(ObsBin,xminbin,xmaxbin);
-
-         for (unsigned int m1 = 0 ; m1<nmu1.size() ; m1++) {
-            for (unsigned int mu2 = 0 ; mu2<nmu2.size() ; mu2++) {
-               double wfnlo = nxlo[x1].second * nxup[x2].second * nmu1[m1].second * nmu2[mu2].second / BinSize[ObsBin];
-               if ( wfnlo == 0 ) continue;
-               if (! std::isfinite(wfnlo)) {
-                  logger.error["FillContributionFlexHHC"]<<"Weight wfnlo is not finite, wfnlo = " << wfnlo << "!"<<endl;
-                  logger.error["FillContributionFlexHHC"]<<"This should have been captured before, aborting ..."<<endl;
-                  fKernX1[ObsBin]->PrintGrid();
-                  fKernX2[ObsBin]->PrintGrid();
-                  fKernMu1[ObsBin]->PrintGrid();
-                  fKernMu2[ObsBin]->PrintGrid();
-                  cout<<"ix1="<<x1<<", ix2="<<x2<<", im1="<<m1<<", im2="<<mu2<<endl;
-                  cout<<"x1="<<nxlo[x1].second<<", x1="<<x1<<", xval="<<xmin<<endl;
-                  cout<<"x2="<<nxup[x2].second<<", x2="<<x2<<", xval="<<xmax<<endl;
-                  cout<<"m1="<< nmu1[m1].second<<", m1="<<m1<<", mu1val="<<fScenario._m1<<endl;
-                  cout<<"m2="<<nmu2[mu2].second<<", m2="<<mu2<<", mu2val="<<fScenario._m2<<endl;
-                  exit(1);
-               }
-               if (fEvent._w  != 0) {
-                  c->SigmaTildeMuIndep[ObsBin][ixHM][nmu1[m1].first][nmu2[mu2].first][p]  += fEvent._w  * wfnlo;
-                  //wsum+= fEvent._w * wfnlo;
-               }
-               if (fEvent._wf != 0) {
-                  //cout<<"   Fill F : ix="<<ixHM<<", im1="<<nmu1[m1].first<<", im2="<<nmu2[mu2].first<<", p="<<p<<", w="<<fEvent._wf  * wfnlo<<endl;
-                  c->SigmaTildeMuFDep [ObsBin][ixHM][nmu1[m1].first][nmu2[mu2].first][p]  += fEvent._wf * wfnlo;
-               }
-               if (fEvent._wr != 0) {
-                  //cout<<"   Fill R : ix="<<ixHM<<", im1="<<nmu1[m1].first<<", im2="<<nmu2[mu2].first<<", p="<<p<<", w="<<fEvent._wr  * wfnlo<<endl;
-                  c->SigmaTildeMuRDep [ObsBin][ixHM][nmu1[m1].first][nmu2[mu2].first][p]  += fEvent._wr * wfnlo;
-               }
-               if (fEvent._wrr != 0) {
-                  c->SigmaTildeMuRRDep [ObsBin][ixHM][nmu1[m1].first][nmu2[mu2].first][p]  += fEvent._wrr * wfnlo;
-               }
-               if (fEvent._wff != 0) {
-                  c->SigmaTildeMuFFDep [ObsBin][ixHM][nmu1[m1].first][nmu2[mu2].first][p]  += fEvent._wff * wfnlo;
-               }
-               if (fEvent._wrf != 0) {
-                  c->SigmaTildeMuRFDep [ObsBin][ixHM][nmu1[m1].first][nmu2[mu2].first][p]  += fEvent._wrf * wfnlo;
-               }
-            }
-         }
+         double wfnlo = nxlo[x1].second * nxup[x2].second / BinSize[ObsBin];
+         c->Fill(fEvent, ObsBin, ixHM, 0, nmu1, nmu2, p, wfnlo);
       }
    }
-
    //cout<<" * wSumW = "<<wsum<<endl;
 }
 
diff --git a/v2.5/toolkit/fastnlotoolkit/fastNLOTools.cc b/v2.5/toolkit/fastnlotoolkit/fastNLOTools.cc
index dae18d978c3191390f77e7a49c47515796fd9adb..ac382d06c839dd6c02ebdd63aee69ab93f9d5121 100644
--- a/v2.5/toolkit/fastnlotoolkit/fastNLOTools.cc
+++ b/v2.5/toolkit/fastnlotoolkit/fastNLOTools.cc
@@ -573,10 +573,12 @@ namespace fastNLOTools {
    }
 
    //______________________________________________________________________________
-   void ExtendHead(fastNLO::v1d& vector1, fastNLO::v1d& vector2) {
+   bool ExtendHead(fastNLO::v1d& vector1, fastNLO::v1d& vector2) {
       if (vector1.size() < vector2.size()) {
          vector1.insert(vector1.begin(), vector2.begin(), vector2.begin() + (vector2.size() - vector1.size()));
+         return true;
       }
+      return false;
    }
 
    //______________________________________________________________________________
diff --git a/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOCoeffAddBase.h b/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOCoeffAddBase.h
index 2746cd464aa8cf1d9e05b45540ad41a7f5c51d25..9023a4089c290d42e6f4ecab8407d669aebecd3f 100644
--- a/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOCoeffAddBase.h
+++ b/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOCoeffAddBase.h
@@ -4,6 +4,8 @@
 
 #include "fastNLOCoeffBase.h"
 #include "fastNLOConstants.h"
+#include "fastNLOInterpolBase.h"
+#include "fastNLOEvent.h"
 
 namespace fastNLO {
    struct WgtStat {
@@ -176,6 +178,11 @@ public:
    fastNLO::WgtStat& AccessWgtStat() { return fWgt;} //!< Get weight and event counts
    double GetMergeWeight(fastNLO::EMerge moption, int proc, int bin) const ; //!< Get merge weight for a given bin and subprocess
 
+   void ExtendX(int ObsBin, std::vector<fastNLOInterpolBase*>& KernX1, std::vector<fastNLOInterpolBase*>& KernX2);
+   virtual void ExtendSigmaTildeX(int ObsBin, unsigned int OldXSize1, unsigned int OldXSize2);
+   virtual void Fill(fnloEvent& Event, int ObsBin, int X, int scalevar, const std::vector<std::pair<int, double>>& nmu1,
+      const std::vector<std::pair<int, double>>& nmu2, int SubProcess, double w);
+
 protected:
    void ReadCoeffAddBase(std::istream& table, int ITabVersionRead);
    int GetScaledimfromvar(int scalevar) const;
diff --git a/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOCoeffAddFix.h b/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOCoeffAddFix.h
index 19bd90c636dcdbd1bd2e2d6639e5816643ec3987..6c97460ec1c0bed1585b5734d447cb95a80c7c60 100644
--- a/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOCoeffAddFix.h
+++ b/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOCoeffAddFix.h
@@ -3,6 +3,7 @@
 
 #include "fastNLOCoeffAddBase.h"
 #include "fastNLOConstants.h"
+#include "fastNLOEvent.h"
 
 
 class fastNLOCoeffAddFix : public fastNLOCoeffAddBase {
@@ -58,6 +59,10 @@ public:
    bool IsCatenable(const fastNLOCoeffAddFix& other) const;        //!< Check for compatibility of two contributions for merging/adding
    bool IsEquivalent(const fastNLOCoeffBase& other, double rtol) const;
 
+   void ExtendSigmaTildeX(int ObsBin, unsigned int OldXSize1, unsigned int OldXSize2);
+   void Fill(fnloEvent& Event, int ObsBin, int X, int scalevar, const std::vector<std::pair<int, double>>& nmu1,
+      const std::vector<std::pair<int, double>>& nmu2, int SubProcess, double w);
+
 protected:
    void ReadCoeffAddFix(std::istream& table, int ITabVersionRead);
 
diff --git a/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOCoeffAddFlex.h b/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOCoeffAddFlex.h
index d3b2e88dc6fa8fa6d483fcc5345871da685e9705..2c463ef48a686d47a7ca9ea43cb6d6a0134730e2 100644
--- a/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOCoeffAddFlex.h
+++ b/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOCoeffAddFlex.h
@@ -51,6 +51,10 @@ public:
    bool IsEquivalent(const fastNLOCoeffBase& other, double rtol) const;
    bool IsSigmaTildeEquivalent(const fastNLOCoeffAddFlex* op, const fastNLO::v5d *tst5, const fastNLO::v5d *ost5, double rtol, std::string name) const;
 
+   void ExtendSigmaTildeX(int ObsBin, unsigned int OldXSize1, unsigned int OldXSize2);
+   void Fill(fnloEvent& Event, int ObsBin, int X, int scalevar, const std::vector<std::pair<int, double>>& nmu1,
+      const std::vector<std::pair<int, double>>& nmu2, int SubProcess, double w);
+
 protected:
 
    void ReadCoeffAddFlex(std::istream& table, int ITabVersionRead);
diff --git a/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOEvent.h b/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOEvent.h
index 0955c84a10a938cc9cfcffda37957d27157bc703..9f4176810923034a7a4229f80de67ed12ae5c089 100644
--- a/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOEvent.h
+++ b/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOEvent.h
@@ -54,6 +54,8 @@ class fnloEvent {
    //! Useful class to keep all process related variables.
    //! e.g x-values, weights, process identifiers, etc.
    friend class fastNLOCreate;
+   friend class fastNLOCoeffAddFix;
+   friend class fastNLOCoeffAddFlex;
 
 public:
    fnloEvent(){Reset();}
diff --git a/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOTools.h b/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOTools.h
index 5ffab5b7dab66930d8f2ac3bd77e13daa199ebcf..434ace17d77446d6ddfc972e34d9196702fb0002 100644
--- a/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOTools.h
+++ b/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOTools.h
@@ -93,7 +93,7 @@ namespace fastNLOTools {
    std::pair<fastNLO::v1d, fastNLO::v1d> GetTails(fastNLO::v1d& vector1, fastNLO::v1d& vector2);
    bool SameTails(fastNLO::v1d vector1, fastNLO::v1d vector2, double rtol=0.0);
    bool SameTails(fastNLO::v2d vector1, fastNLO::v2d vector2, double rtol=0.0);
-   void ExtendHead(fastNLO::v1d& vector1, fastNLO::v1d& vector2);
+   bool ExtendHead(fastNLO::v1d& vector1, fastNLO::v1d& vector2);
    template <typename T> void ExtendSigmaTildeX(
       std::vector<T>& SigmaTildeX, unsigned int OldDimSize1, unsigned int NewDimSize1,
       unsigned int OldDimSize2, unsigned int NewDimSize2, int NPDFDim, T InsertValue);