diff --git a/MatrixElement/Matchbox/External/Makefile.am b/MatrixElement/Matchbox/External/Makefile.am
--- a/MatrixElement/Matchbox/External/Makefile.am
+++ b/MatrixElement/Matchbox/External/Makefile.am
@@ -1,96 +1,100 @@
 SUBDIRS = BLHAGeneric VBFNLO NJet GoSam OpenLoops MadGraph
 
 
 pkglib_LTLIBRARIES =
 
 ##############
 
 if HAVE_GOSAM
 pkglib_LTLIBRARIES += HwMatchboxGoSam.la
 endif
 
 HwMatchboxGoSam_la_LDFLAGS = \
 $(AM_LDFLAGS) -module -version-info 15:0:0
 
 HwMatchboxGoSam_la_CPPFLAGS = $(AM_CPPFLAGS) \
 -DHERWIG_BINDIR="\"$(bindir)\"" \
 -DHERWIG_PKGDATADIR="\"$(pkgdatadir)\"" \
 -DGOSAM_PREFIX="\"$(GOSAMPREFIX)\""
 
 HwMatchboxGoSam_la_SOURCES = \
 GoSam/GoSamAmplitude.cc
 
 
 ###############
 
 if HAVE_VBFNLO
 pkglib_LTLIBRARIES += HwMatchboxVBFNLO.la
 endif
 
 HwMatchboxVBFNLO_la_LDFLAGS = $(AM_LDFLAGS) -module -version-info 6:0:0
 HwMatchboxVBFNLO_la_CPPFLAGS = $(AM_CPPFLAGS)
 HwMatchboxVBFNLO_la_CPPFLAGS += -I$(VBFNLOINCLUDE)
 HwMatchboxVBFNLO_la_CPPFLAGS += -DVBFNLOLIB=$(VBFNLOLIB)
 
+if HAVE_VBFNLO3
+HwMatchboxVBFNLO_la_CPPFLAGS += -DVBFNLO3
+endif
+
 HwMatchboxVBFNLO_la_SOURCES = \
 VBFNLO/VBFNLOAmplitude.cc \
 VBFNLO/VBFNLOPhasespace.cc
 
 
 ###############
 
 if HAVE_OPENLOOPS
 pkglib_LTLIBRARIES += HwMatchboxOpenLoops.la
 endif
 
 HwMatchboxOpenLoops_la_SOURCES = \
 OpenLoops/OpenLoopsAmplitude.cc
 
 HwMatchboxOpenLoops_la_LDFLAGS = $(AM_LDFLAGS) -module -version-info 15:0:0
 
 HwMatchboxOpenLoops_la_CPPFLAGS = $(AM_CPPFLAGS) \
 -DOPENLOOPSLIBS="\"$(OPENLOOPSLIBS)\"" \
 -DOPENLOOPSPREFIX="\"$(OPENLOOPSPREFIX)\""
 
 ##############
 
 
 if HAVE_NJET
 pkglib_LTLIBRARIES += HwMatchboxNJet.la
 endif
 
 HwMatchboxNJet_la_LDFLAGS = $(AM_LDFLAGS) -module -version-info 15:0:0
 
 HwMatchboxNJet_la_CPPFLAGS = $(AM_CPPFLAGS) -I$(NJETINCLUDEPATH) \
 -DNJET_PREFIX="\"$(NJETPREFIX)\"" \
 -DNJET_LIBS="\"$(NJETLIBPATH)\"" \
 -DNJET_VERSION="$(NJET_VERSION)"
 
 HwMatchboxNJet_la_SOURCES = \
 NJet/NJetsAmplitude.cc
 
 
 
 ##############
 
 if HAVE_MADGRAPH
 pkglib_LTLIBRARIES += HwMatchboxMadGraph.la
 endif
 
 HwMatchboxMadGraph_la_LDFLAGS = $(AM_LDFLAGS) -module -version-info 6:0:0
 
 HwMatchboxMadGraph_la_SOURCES = \
 MadGraph/MadGraphAmplitude.cc
 
 HwMatchboxMadGraph_la_CPPFLAGS = $(AM_CPPFLAGS) \
 -DHERWIG_BINDIR="\"$(bindir)\"" \
 -DHERWIG_INCLUDEDIR="\"$(includedir)\"" \
 -DHERWIG_PKGDATADIR="\"$(pkgdatadir)\"" \
 -DMADGRAPH_PREFIX="\"$(MADGRAPHPREFIX)\""
 
 
 
 
 
 
 
diff --git a/MatrixElement/Matchbox/External/VBFNLO/VBFNLOAmplitude.cc b/MatrixElement/Matchbox/External/VBFNLO/VBFNLOAmplitude.cc
--- a/MatrixElement/Matchbox/External/VBFNLO/VBFNLOAmplitude.cc
+++ b/MatrixElement/Matchbox/External/VBFNLO/VBFNLOAmplitude.cc
@@ -1,495 +1,536 @@
 // -*- C++ -*-
 //
 // VBFNLOAmplitude.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
 // Copyright (C) 2002-2019 The Herwig Collaboration
 //
 // Herwig is licenced under version 3 of the GPL, see COPYING for details.
 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
 //
 //
 // This is the implementation of the non-inlined, non-templated member
 // functions of the VBFNLOAmplitude class.
 //
 
 #include "VBFNLOAmplitude.h"
 #include "ThePEG/Interface/ClassDocumentation.h"
 #include "ThePEG/EventRecord/Particle.h"
 #include "ThePEG/Repository/UseRandom.h"
 #include "ThePEG/Repository/EventGenerator.h"
 #include "ThePEG/Utilities/DescribeClass.h"
 #include "ThePEG/Interface/Switch.h"
 
 #include "ThePEG/Persistency/PersistentOStream.h"
 #include "ThePEG/Persistency/PersistentIStream.h"
 
 #include "ThePEG/Utilities/DynamicLoader.h"
 
 #include "Herwig/MatrixElement/Matchbox/MatchboxFactory.h"
 
 #include <cstdlib>
 
 #include "VBFNLO/utilities/BLHAinterface.h"
 
 #define DEFSTR(s) CPPSTR(s)
 #define CPPSTR(s) #s
 
 using namespace Herwig;
 
 VBFNLOAmplitude::VBFNLOAmplitude() 
   : theRanHelSum(false), theAnomCoupl(false), VBFNLOlib_(DEFSTR(VBFNLOLIB))
 {}
 
 VBFNLOAmplitude::~VBFNLOAmplitude() {}
 
 IBPtr VBFNLOAmplitude::clone() const {
   return new_ptr(*this);
 }
 
 IBPtr VBFNLOAmplitude::fullclone() const {
   return new_ptr(*this);
 }
 
 void VBFNLOAmplitude::signOLP(const string& order, const string& contract) {
   int status = 0;
+  #ifdef VBFNLO3
+  OLP_Order_VBFNLO(const_cast<char*>(order.c_str()),
+		   const_cast<char*>(contract.c_str()),&status);
+  #else
   OLP_Order(const_cast<char*>(order.c_str()),
 	    const_cast<char*>(contract.c_str()),&status);
+  #endif
   if ( status != 1 )
     throw Exception() << "VBFNLOAmplitude: Failed to sign contract with VBFNLO.\n"
                       << "The BLHA contract file " << contract << "\n"
                       << "may contain further details about the error."
 		      << Exception::runerror;
 }
 
 void VBFNLOAmplitude::setOLPParameter(const string& name, double value) const {
 
   int pStatus = 0;
   double zero = 0.0;
+  #ifdef VBFNLO3
+  OLP_SetParameter_VBFNLO(const_cast<char*>(name.c_str()),&value,&zero,&pStatus);
+  #else
   OLP_SetParameter(const_cast<char*>(name.c_str()),&value,&zero,&pStatus);
+  #endif
   if ( !pStatus )
     throw Exception() << "VBFNLOAmplitude: VBFNLO failed to set parameter '"
 		      << name << "' to " << value << "\n"
 		      << Exception::runerror;
 
 }
 
 void VBFNLOAmplitude::startOLP(const string& contract, int& status) {
 
+  #ifdef VBFNLO3
+  OLP_Start_VBFNLO(const_cast<char*>(contract.c_str()), &status);
+  #else
   OLP_Start(const_cast<char*>(contract.c_str()), &status);
+  #endif
 
   map<long,Energy>::const_iterator it=reshuffleMasses().find(ParticleID::b);
   double bmass;
   if(it==reshuffleMasses().end())
     bmass = getParticleData(ParticleID::b)->hardProcessMass()/GeV;
   else
     bmass = it->second/GeV;
+
   setOLPParameter("mass(5)",bmass);
   setOLPParameter("mass(6)",getParticleData(ParticleID::t)->hardProcessMass()/GeV);
 
   setOLPParameter("mass(23)",getParticleData(ParticleID::Z0)->hardProcessMass()/GeV);
   setOLPParameter("mass(24)",getParticleData(ParticleID::Wplus)->hardProcessMass()/GeV);
   setOLPParameter("mass(25)",getParticleData(ParticleID::h0)->hardProcessMass()/GeV);
 
   setOLPParameter("width(23)",getParticleData(ParticleID::Z0)->hardProcessWidth()/GeV);
   setOLPParameter("width(24)",getParticleData(ParticleID::Wplus)->hardProcessWidth()/GeV);
   setOLPParameter("width(25)",getParticleData(ParticleID::h0)->hardProcessWidth()/GeV);
 
   setOLPParameter("alpha",SM().alphaEMMZ());
   setOLPParameter("sw2",SM().sin2ThetaW());
   setOLPParameter("Gf",SM().fermiConstant()*GeV2);
 
   setOLPParameter("Nf",factory()->nLight());
 
   setOLPParameter("alphas",SM().alphaS());
 
   setOLPParameter("ranhelsum",theRanHelSum);
 
   setOLPParameter("anomcoupl",theAnomCoupl);
 
   didStartOLP() = true;
 
 }
 
 void VBFNLOAmplitude::loadVBFNLO() {
   if ( ! DynamicLoader::load(VBFNLOlib_+"/libVBFNLO.so") ) {
     string error1 = DynamicLoader::lastErrorMessage;
     if ( ! DynamicLoader::load(VBFNLOlib_+"/libVBFNLO.dylib") ) {
       string error2 = DynamicLoader::lastErrorMessage;
       if ( ! DynamicLoader::load("libVBFNLO.so") ) {
         string error3 = DynamicLoader::lastErrorMessage;
         if ( ! DynamicLoader::load("libVBFNLO.dylib") ) {
           string error4 = DynamicLoader::lastErrorMessage;
           throw Exception() << "VBFNLOAmplitude: failed to load libVBFNLO.so/dylib\n"
                             << "Error messages are:\n\n"
                             << "* " << VBFNLOlib_ << "/libVBFNLO.so:\n" 
                             << error1 << "\n"
                             << "* " << VBFNLOlib_ << "/libVBFNLO.dylib:\n" 
                             << error2 << "\n"
                             << "* libVBFNLO.so:\n" 
                             << error3 << "\n"
                             << "* libVBFNLO.dylib:\n" 
                             << error4 << "\n"
                             << Exception::runerror;
         }
       }
     }
   }
 }
 
 bool VBFNLOAmplitude::startOLP(const map<pair<Process,int>,int>& procs) {
   loadVBFNLO();
   string orderFileName = factory()->buildStorage() + name() + ".OLPOrder.lh";
   ofstream orderFile(orderFileName.c_str());
 
   olpOrderFileHeader(orderFile);
 
   // add VBFNLO specifics here
 
   olpOrderFileProcesses(orderFile,procs);
 
   orderFile << flush;
 
   orderFile.close();
 
   string contractFileName = factory()->buildStorage() + name() + ".OLPContract.lh";
 
   signOLP(orderFileName, contractFileName);
 
   int status = -1;
-
-  startOLP(contractFileName,status);  
+  
+  startOLP(contractFileName,status);
 
   if ( status != 1 )
     return false;
 
   return true;
 
 
 }
 
 LorentzVector<Complex> VBFNLOAmplitude::plusPolarization(const Lorentz5Momentum& p,
 							 const Lorentz5Momentum& n,
 							 int inc) const {
 
   // shamelessly stolen from the GoSam interface; mind that we can
   // always cast eq (5.7) in the manual into a form that it only uses
   // <M-||M_+> and then switch bvetween eps_+ for an outgoing and
   // eps_- for an incoming gluon.
 
   double pvec[4] = {p.t()/GeV,p.x()/GeV,p.y()/GeV,p.z()/GeV};
   double nvec[4] = {n.t()/GeV,n.x()/GeV,n.y()/GeV,n.z()/GeV};
   double out[8] ={ };
+  #ifdef VBFNLO3 
+  OLP_Polvec_VBFNLO(pvec,nvec,out);
+  #else
   OLP_Polvec(pvec,nvec,out);
+  #endif
 
   LorentzVector<Complex> res;
   Complex a(out[0],out[1]);
   res.setT(a);
   Complex b(out[2],out[3]);
   res.setX(b);
   Complex c(out[4],out[5]);
   res.setY(c);
   Complex d(out[6],out[7]);
   res.setZ(d);
 	
   if (inc<2)
     return res.conjugate();
   else 
     return res;
 
 }
 
 void VBFNLOAmplitude::evalSubProcess() const {
 
   useMe();
 
   double units = pow(lastSHat()/GeV2,mePartonData().size()-4.);
   fillOLPMomenta(lastXComb().meMomenta(),mePartonData(),reshuffleMasses());
   double scale = sqrt(mu2()/GeV2);
 
-  if (hasRunningAlphaS()) setOLPParameter("alphas",lastAlphaS());
-
+  if (hasRunningAlphaS())
+    setOLPParameter("alphas",lastAlphaS());
+  
   double acc = -1.0;
   double out[4]={};
 
   int id = 
     olpId()[ProcessType::oneLoopInterference] ?
     olpId()[ProcessType::oneLoopInterference] :
     olpId()[ProcessType::treeME2];
 
   if (theRanHelSum) {
     vector<double> helicityrn;
     if ( lastHeadMatchboxXComb() ) {
       helicityrn = lastHeadMatchboxXComb()->amplitudeRandomNumbers();
     } else {
       helicityrn = amplitudeRandomNumbers();
     }
     if (helicityrn.size()>0) {
       setOLPParameter("HelicityRN",helicityrn[0]);
     }
   }
 
+  #ifdef VBFNLO3 
+  OLP_EvalSubProcess2_VBFNLO(&id, olpMomenta(), &scale, out, &acc);
+  #else
   OLP_EvalSubProcess2(&id, olpMomenta(), &scale, out, &acc);
+  #endif
 
   if ( olpId()[ProcessType::oneLoopInterference] ) {
     lastTreeME2(out[3]*units);
     lastOneLoopInterference(out[2]*units);
     lastOneLoopPoles(pair<double,double>(out[0]*units,out[1]*units));
   } else if ( olpId()[ProcessType::treeME2] ) {
     lastTreeME2(out[0]*units);
   } else assert(false);
 
 }
 
 void VBFNLOAmplitude::evalColourCorrelator(pair<int,int>) const {
 
   double units = pow(lastSHat()/GeV2,mePartonData().size()-4.);
   fillOLPMomenta(lastXComb().meMomenta(),mePartonData(),reshuffleMasses());
   double scale = sqrt(mu2()/GeV2);
 
-  if (hasRunningAlphaS()) setOLPParameter("alphas",lastAlphaS());
+  if (hasRunningAlphaS())
+    setOLPParameter("alphas",lastAlphaS());
 
   double acc = -1.0;
 
   int n = lastXComb().meMomenta().size();
   colourCorrelatorResults.resize(n*(n-1)/2);
 
   int id = olpId()[ProcessType::colourCorrelatedME2];
 
   if (theRanHelSum) {
     vector<double> helicityrn;
     if ( lastHeadMatchboxXComb() ) {
       helicityrn = lastHeadMatchboxXComb()->amplitudeRandomNumbers();
     } else {
       helicityrn = amplitudeRandomNumbers();
     }
     if (helicityrn.size()>0) {
       setOLPParameter("HelicityRN",helicityrn[0]);
     }
   }
 
+  #ifdef VBFNLO3 
+  OLP_EvalSubProcess2_VBFNLO(&id, olpMomenta(), &scale, &colourCorrelatorResults[0], &acc);
+  #else
   OLP_EvalSubProcess2(&id, olpMomenta(), &scale, &colourCorrelatorResults[0], &acc);
+  #endif
 
   for ( int i = 0; i < n; ++i )
     for ( int j = i+1; j < n; ++j ) {
       lastColourCorrelator(make_pair(i,j),colourCorrelatorResults[i+j*(j-1)/2]*units);
     }
 
 }
 
 void VBFNLOAmplitude::evalSpinColourCorrelator(pair<int,int>) const {
 
   double units = pow(lastSHat()/GeV2,mePartonData().size()-4.);
   fillOLPMomenta(lastXComb().meMomenta(),mePartonData(),reshuffleMasses());
   double scale = sqrt(mu2()/GeV2); 
 
-  if (hasRunningAlphaS()) setOLPParameter("alphas",lastAlphaS());
+  if (hasRunningAlphaS())
+    setOLPParameter("alphas",lastAlphaS());
 
   double acc = -1.0;
 
   int n = lastXComb().meMomenta().size();
   spinColourCorrelatorResults.resize(2*n*n);
 
   int id = olpId()[ProcessType::spinColourCorrelatedME2];
 
   if (theRanHelSum) {
     vector<double> helicityrn;
     if ( lastHeadMatchboxXComb() ) {
       helicityrn = lastHeadMatchboxXComb()->amplitudeRandomNumbers();
     } else {
       helicityrn = amplitudeRandomNumbers();
     }
     if (helicityrn.size()>0) {
       setOLPParameter("HelicityRN",helicityrn[0]);
     }
   }
 
+  #ifdef VBFNLO3 
+  OLP_EvalSubProcess2_VBFNLO(&id, olpMomenta(), &scale, &spinColourCorrelatorResults[0], &acc);
+  #else
   OLP_EvalSubProcess2(&id, olpMomenta(), &scale, &spinColourCorrelatorResults[0], &acc);
+  #endif
 
   for ( int i = 0; i < n; ++i )
     for ( int j = 0; j < n; ++j ) {
       if ( i == j || mePartonData()[i]->id() != 21 )
 	continue;
       Complex scc(spinColourCorrelatorResults[2*i+2*n*j]*units,
 		  spinColourCorrelatorResults[2*i+2*n*j+1]*units);
       lastColourSpinCorrelator(make_pair(i,j),scc);
     }
 
 }
 
 double VBFNLOAmplitude::largeNME2(Ptr<ColourBasis>::tptr cptr) const {
   if ( calculateLargeNME2() )
     evalLargeNSubProcess(cptr);
   return lastLargeNME2();
 }
 
 void VBFNLOAmplitude::evalLargeNSubProcess(Ptr<ColourBasis>::tptr) const {
 
   double units = pow(lastSHat()/GeV2,mePartonData().size()-4.);
   fillOLPMomenta(lastXComb().meMomenta(),mePartonData(),reshuffleMasses());
   double scale = sqrt(mu2()/GeV2);
 
   if (hasRunningAlphaS()) setOLPParameter("alphas",lastAlphaS());
 
   double acc = -1.0;
   double out[4]={};
 
   int id = 
     olpId()[ProcessType::oneLoopInterference] ?
     olpId()[ProcessType::oneLoopInterference] :
     olpId()[ProcessType::treeME2];
 
   if (theRanHelSum) {
     vector<double> helicityrn;
     if ( lastHeadMatchboxXComb() ) {
       helicityrn = lastHeadMatchboxXComb()->amplitudeRandomNumbers();
     } else {
       helicityrn = amplitudeRandomNumbers();
     }
     if (helicityrn.size()>0) {
       setOLPParameter("HelicityRN",helicityrn[0]);
     }
   }
 
   setOLPParameter("Nc",-1); // large-N limit
+  #ifdef VBFNLO3 
+  OLP_EvalSubProcess2_VBFNLO(&id, olpMomenta(), &scale, out, &acc);
+  #else
   OLP_EvalSubProcess2(&id, olpMomenta(), &scale, out, &acc);
+  #endif
   setOLPParameter("Nc",generator()->standardModel()->Nc()); 
 
   if ( olpId()[ProcessType::oneLoopInterference] ) {
     lastLargeNME2(out[3]*units);
     lastOneLoopInterference(out[2]*units);
     lastOneLoopPoles(pair<double,double>(out[0]*units,out[1]*units));
   } else if ( olpId()[ProcessType::treeME2] ) {
     lastLargeNME2(out[0]*units);
   } else assert(false);
 
 }
 
 double VBFNLOAmplitude::largeNColourCorrelatedME2(pair<int,int> ij,
 					          Ptr<ColourBasis>::tptr cptr) const {
 
   double cfac = 1.;
   double Nc = generator()->standardModel()->Nc();
   if ( mePartonData()[ij.first]->iColour() == PDT::Colour8 ) {
     cfac = Nc;
   } else if ( mePartonData()[ij.first]->iColour() == PDT::Colour3 ||
 	      mePartonData()[ij.first]->iColour() == PDT::Colour3bar ) {
     cfac = Nc/2.;
   } else assert(false);
   if ( calculateLargeNColourCorrelator(ij) )
     evalLargeNColourCorrelator(ij,cptr);
   return lastLargeNColourCorrelator(ij)/cfac;
 
 }
 
 void VBFNLOAmplitude::evalLargeNColourCorrelator(pair<int,int>,
                                                  Ptr<ColourBasis>::tptr) const {
 
   double units = pow(lastSHat()/GeV2,mePartonData().size()-4.);
   fillOLPMomenta(lastXComb().meMomenta(),mePartonData(),reshuffleMasses());
   double scale = sqrt(mu2()/GeV2);
 
   if (hasRunningAlphaS()) setOLPParameter("alphas",lastAlphaS());
 
   double acc = -1.0;
 
   int n = lastXComb().meMomenta().size();
   colourCorrelatorResults.resize(n*(n-1)/2);
 
   int id = olpId()[ProcessType::colourCorrelatedME2];
 
   if (theRanHelSum) {
     vector<double> helicityrn;
     if ( lastHeadMatchboxXComb() ) {
       helicityrn = lastHeadMatchboxXComb()->amplitudeRandomNumbers();
     } else {
       helicityrn = amplitudeRandomNumbers();
     }
     if (helicityrn.size()>0) {
       setOLPParameter("HelicityRN",helicityrn[0]);
     }
   }
 
   setOLPParameter("Nc",-1); // large-N limit
+  #ifdef VBFNLO3
+  OLP_EvalSubProcess2_VBFNLO(&id, olpMomenta(), &scale, &colourCorrelatorResults[0], &acc);
+  #else
   OLP_EvalSubProcess2(&id, olpMomenta(), &scale, &colourCorrelatorResults[0], &acc);
+  #endif
   setOLPParameter("Nc",generator()->standardModel()->Nc()); 
 
   for ( int i = 0; i < n; ++i )
     for ( int j = i+1; j < n; ++j ) {
       lastLargeNColourCorrelator(make_pair(i,j),colourCorrelatorResults[i+j*(j-1)/2]*units);
     }
 
 }
 
 void VBFNLOAmplitude::doinit() {
   loadVBFNLO();
   MatchboxOLPME::doinit();
 }
 
 void VBFNLOAmplitude::doinitrun() {
   loadVBFNLO();
   MatchboxOLPME::doinitrun();
 }
 
 void VBFNLOAmplitude::persistentOutput(PersistentOStream & os) const {
   os << colourCorrelatorResults << spinColourCorrelatorResults << theRanHelSum << theAnomCoupl << VBFNLOlib_;
 }
 
 void VBFNLOAmplitude::persistentInput(PersistentIStream & is, int) {
   is >> colourCorrelatorResults >> spinColourCorrelatorResults >> theRanHelSum >> theAnomCoupl >> VBFNLOlib_;
 }
 
 
 // The following static variable is needed for the type
 // description system in ThePEG.
 DescribeClass<VBFNLOAmplitude,MatchboxOLPME>
   describeHerwigVBFNLOAmplitude("Herwig::VBFNLOAmplitude", "HwMatchboxVBFNLO.so");
 
 void VBFNLOAmplitude::Init() {
 
   static ClassDocumentation<VBFNLOAmplitude> documentation
     ("VBFNLOAmplitude implements an interface to VBFNLO.",
      "Matrix elements have been calculated using VBFNLO "
      "(Ref.~\\cite{VBFNLO} and process-specific references)\n",
      "%\\cite{VBFNLO}\n"
      "\\bibitem{Arnold:2008rz}\n"
      "K.~Arnold, M.~Bahr, G.~Bozzi, F.~Campanario, C.~Englert, T.~Figy, "
      "N.~Greiner and C.~Hackstein {\\it et al.},\n"
      "``VBFNLO: A Parton level Monte Carlo for processes with electroweak bosons,''\n"
      "Comput.\\ Phys.\\ Commun.\\  {\\bf 180} (2009) 1661\n"
      "[arXiv:0811.4559 [hep-ph]];\n"
      "%%CITATION = ARXIV:0811.4559;%%\n"
      "J.~Baglio, J.~Bellm, F.~Campanario, B.~Feigl, J.~Frank, T.~Figy, "
      "M.~Kerner and L.~D.~Ninh {\\it et al.},\n"
      "``Release Note - VBFNLO 2.7.0,''\n"
      "arXiv:1404.3940 [hep-ph].\n"
      "%%CITATION = ARXIV:1404.3940;%%\n");
 
   static Switch<VBFNLOAmplitude,bool> interfaceRandomHelicitySummation
     ("RandomHelicitySummation", "Switch for random helicity summation of leptons and photons",
       &VBFNLOAmplitude::theRanHelSum, false, false, false);
   static SwitchOption interfaceRandomHelicitySummationYes
     (interfaceRandomHelicitySummation, 
      "Yes", 
      "Perform random helicity summation", 
      true);
   static SwitchOption interfaceRandomHelicitySummationNo
     (interfaceRandomHelicitySummation, 
      "No", 
      "Sum over all helicity combinations", 
      false);
 
   static Switch<VBFNLOAmplitude,bool> interfaceAnomalousCouplings
     ("AnomalousCouplings", "Switch for anomalous couplings",
       &VBFNLOAmplitude::theAnomCoupl, false, false, false);
   static SwitchOption interfaceAnomalousCouplingsYes
     (interfaceAnomalousCouplings, 
      "Yes", 
      "Switch anomalous couplings on", 
      true);
   static SwitchOption interfaceAnomalousCouplingsNo
     (interfaceAnomalousCouplings, 
      "No", 
      "Switch anomalous couplings off", 
      false);
 
 }
 
diff --git a/MatrixElement/Matchbox/External/VBFNLO/VBFNLOPhasespace.cc b/MatrixElement/Matchbox/External/VBFNLO/VBFNLOPhasespace.cc
--- a/MatrixElement/Matchbox/External/VBFNLO/VBFNLOPhasespace.cc
+++ b/MatrixElement/Matchbox/External/VBFNLO/VBFNLOPhasespace.cc
@@ -1,277 +1,289 @@
 // -*- C++ -*-
 //
 // VBFNLOPhasespace.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
 // Copyright (C) 2002-2019 The Herwig Collaboration
 //
 // Herwig is licenced under version 3 of the GPL, see COPYING for details.
 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
 //
 //
 // This is the implementation of the non-inlined, non-templated member
 // functions of the VBFNLOPhasespace class.
 //
 
 #include "VBFNLOPhasespace.h"
 #include "ThePEG/Interface/ClassDocumentation.h"
 #include "ThePEG/Interface/Parameter.h"
 #include "ThePEG/Interface/Reference.h"
 #include "ThePEG/Interface/Switch.h"
 #include "ThePEG/EventRecord/Particle.h"
 #include "ThePEG/Repository/UseRandom.h"
 #include "ThePEG/Repository/EventGenerator.h"
 #include "ThePEG/Utilities/DescribeClass.h"
 #include "Herwig/Utilities/GSLBisection.h"
 #include "ThePEG/Utilities/DynamicLoader.h"
 
 #include "ThePEG/Persistency/PersistentOStream.h"
 #include "ThePEG/Persistency/PersistentIStream.h"
 
 #include "Herwig/MatrixElement/Matchbox/Base/MatchboxAmplitude.h"
 
 #include "VBFNLO/utilities/BLHAinterface.h"
 
 #define DEFSTR(s) CPPSTR(s)
 #define CPPSTR(s) #s
 
 using namespace Herwig;
 
 VBFNLOPhasespace::VBFNLOPhasespace() : 
   lastSqrtS(0*GeV), needToReshuffle(false), VBFNLOlib_(DEFSTR(VBFNLOLIB))
 {}
 
 void VBFNLOPhasespace::loadVBFNLO() {
   if ( ! DynamicLoader::load(VBFNLOlib_+"/libVBFNLO.so") ) {
     string error1 = DynamicLoader::lastErrorMessage;
     if ( ! DynamicLoader::load(VBFNLOlib_+"/libVBFNLO.dylib") ) {
       string error2 = DynamicLoader::lastErrorMessage;
       if ( ! DynamicLoader::load("libVBFNLO.so") ) {
         string error3 = DynamicLoader::lastErrorMessage;
         if ( ! DynamicLoader::load("libVBFNLO.dylib") ) {
           string error4 = DynamicLoader::lastErrorMessage;
           throw Exception() << "VBFNLOPhasespace: failed to load libVBFNLO.so/dylib\n"
                             << "Error messages are:\n\n"
                             << "* " << VBFNLOlib_ << "/libVBFNLO.so:\n" 
                             << error1 << "\n"
                             << "* " << VBFNLOlib_ << "/libVBFNLO.dylib:\n" 
                             << error2 << "\n"
                             << "* libVBFNLO.so:\n" 
                             << error3 << "\n"
                             << "* libVBFNLO.dylib:\n" 
                             << error4 << "\n"
                             << Exception::runerror;
         }
       }
     }
   }
 }
 
 VBFNLOPhasespace::~VBFNLOPhasespace() {}
 
 IBPtr VBFNLOPhasespace::clone() const {
   return new_ptr(*this);
 }
 
 IBPtr VBFNLOPhasespace::fullclone() const {
   return new_ptr(*this);
 }
 
 void VBFNLOPhasespace::setXComb(tStdXCombPtr xco) {
 
   MatchboxPhasespace::setXComb(xco);
 // test for resuffling
   needToReshuffle = false;
   if ( xco ) {
     for ( cPDVector::const_iterator d = mePartonData().begin();
 	  d != mePartonData().end(); ++d ) {
 // Higgs is massive -> does not need reshuffling
       if ( ( (**d).id() != ParticleID::h0 ) && ( (**d).hardProcessMass() != ZERO ) ) {
 	needToReshuffle = true;
 	break;
       }
     }
   }
 
 // set CMS energy 
   int pStatus = 0;
   double zero = 0.0;
 
   double value = sqrt(lastXCombPtr()->lastS())/GeV;
   if (value && (value != lastSqrtS/GeV)) {
     lastSqrtS = value*GeV;
     string name = "sqrtS";
+    #ifdef VBFNLO3
+    OLP_SetParameter_VBFNLO(const_cast<char*>(name.c_str()),&value,&zero,&pStatus);
+    #else
     OLP_SetParameter(const_cast<char*>(name.c_str()),&value,&zero,&pStatus);
+    #endif
     if ( !pStatus )
       throw Exception() << "VBFNLOPhasespace::setXComb(): VBFNLO failed to set parameter '"
                         << name << "' to " << value << "\n"
                         << Exception::runerror;
   }
 
 }
 
 double VBFNLOPhasespace::generateTwoToNKinematics(const double* random,
 						  vector<Lorentz5Momentum>& momenta) {
 
   double weight;
 
   int id = 
     olpId()[ProcessType::oneLoopInterference] ?
     olpId()[ProcessType::oneLoopInterference] :
     olpId()[ProcessType::treeME2];
 
   double* p = new double[4*momenta.size()];
 
+  #ifdef VBFNLO3
+  OLP_PhaseSpacePoint_VBFNLO(&id, const_cast<double*>(random), const_cast<double*>(random+1), p, &weight);
+  #else
   OLP_PhaseSpacePoint(&id, const_cast<double*>(random), const_cast<double*>(random+1), p, &weight);
+  #endif
 
   if (weight < 0) {
     throw Exception() << "VBFNLOPhasespace::generateTwoToNKinematics(): Negative weight in VBFNLOPhaseSpace\n"
 		      << Exception::runerror;
   }
 
   if (weight == 0) {
     delete[] p;
     return 0;
   }
 
   for ( size_t i = 0; i < momenta.size(); ++i ) {
     momenta[i].setT(p[4*i]  *GeV);
     momenta[i].setX(p[4*i+1]*GeV);
     momenta[i].setY(p[4*i+2]*GeV);
     momenta[i].setZ(p[4*i+3]*GeV);
     momenta[i].rescaleMass();
   }
 
   delete[] p;
 
   Energy beamenergy = sqrt(lastXCombPtr()->lastS())/2.;
   double x1 = momenta[0].e()/beamenergy;
   double x2 = momenta[1].e()/beamenergy;
   Energy2 thisSHat = (momenta[0] + momenta[1]).m2();
 
   // reshuffle so that particles have correct mass
   if ( needToReshuffle ) {
 
     // boost final-state into partonic CMS
     Boost toCMS = (momenta[0]+momenta[1]).findBoostToCM();
     for ( size_t i = 2; i < momenta.size(); ++i ) {
       momenta[i].boost(toCMS);
     }
 
     // copied from MatchboxRambo phasespace
     double xi;
 
     ReshuffleEquation solve(sqrt(thisSHat),mePartonData().begin()+2,mePartonData().end(),
           		  momenta.begin()+2,momenta.end());
 
     GSLBisection solver(1e-10,1e-8,10000);
 
     try {
       xi = solver.value(solve,0.0,1.1);
     } catch (GSLBisection::GSLerror) {
       return 0.;
     } catch (GSLBisection::IntervalError) {
       return 0.;
     }
 
     weight *= pow(xi,3.*(momenta.size()-3.));
 
     Energy num = ZERO;
     Energy den = ZERO;
 
     cPDVector::const_iterator d = mePartonData().begin()+2;
     for ( vector<Lorentz5Momentum>::iterator k = momenta.begin()+2;
           k != momenta.end(); ++k, ++d ) {
       num += (*k).vect().mag2()/(*k).t();
       Energy q = (*k).t();
       (*k).setT(sqrt(sqr((**d).hardProcessMass())+xi*xi*sqr((*k).t())));
       (*k).setVect(xi*(*k).vect());
       weight *= q/(*k).t();
       den += (*k).vect().mag2()/(*k).t();
       (*k).setMass((**d).hardProcessMass());
     }
 
     // unboost
     for ( size_t i = 2; i < momenta.size(); ++i ) {
       momenta[i].boost(-toCMS);
     }
   }
 
   if ( !matchConstraints(momenta) )
     return 0.;
 
   lastXCombPtr()->lastX1X2(make_pair(x1,x2));
   lastXCombPtr()->lastSHat(thisSHat);
 
   weight /= pow(thisSHat/GeV2,momenta.size()-4); 
   weight /= x1*x2;
 
   fillDiagramWeights();
 
   return weight;
 
 }
 
 int VBFNLOPhasespace::nDimPhasespace(int nFinal) const {
   return 3*nFinal;
 
 //get this from within VBFNLO
   int pStatus = 0;
   double value, zero;
   string name = "PSdimension";
+  #ifdef VBFNLO3
+  OLP_GetParameter_VBFNLO(const_cast<char*>(name.c_str()),&value,&zero,&pStatus);
+  #else
   OLP_GetParameter(const_cast<char*>(name.c_str()),&value,&zero,&pStatus);
+  #endif
   if ( pStatus != 1) {
     throw Exception() << "VBFNLOPhasespace::nDimPhasespace(): Cannot get phasespace dimension in VBFNLOPhaseSpace\n"
 		      << "error code: " << pStatus << "\n"
 		      << Exception::runerror;
   }
   // one additional number (first) needed for channel selection
   // one additional number (last) needed for global phi integration
   return value+2; 
 }
 
 Energy VBFNLOPhasespace::ReshuffleEquation::operator() (double xi) const {
   cPDVector::const_iterator d = dataBegin;
   vector<Lorentz5Momentum>::const_iterator p = momentaBegin;
   Energy res = -w;
   for ( ; d != dataEnd; ++d, ++p ) {
     res += sqrt(sqr((**d).hardProcessMass()) +
 		xi*xi*sqr(p->t()));
   }
   return res;
 }
 
 void VBFNLOPhasespace::doinit() {
   loadVBFNLO();
   MatchboxPhasespace::doinit();
 }
 
 void VBFNLOPhasespace::doinitrun() {
   loadVBFNLO();
   MatchboxPhasespace::doinitrun();
 }
 
 void VBFNLOPhasespace::persistentOutput(PersistentOStream & os) const {
   os << needToReshuffle << theLastXComb;
 }
 
 void VBFNLOPhasespace::persistentInput(PersistentIStream & is, int) {
   is >> needToReshuffle >> theLastXComb;
 }
 
 
 // *** Attention *** The following static variable is needed for the type
 // description system in ThePEG. Please check that the template arguments
 // are correct (the class and its base class), and that the constructor
 // arguments are correct (the class name and the name of the dynamically
 // loadable library where the class implementation can be found).
 DescribeClass<VBFNLOPhasespace,MatchboxPhasespace>
   describeHerwigVBFNLOPhasespace("Herwig::VBFNLOPhasespace", "HwMatchboxVBFNLO.so");
 
 void VBFNLOPhasespace::Init() {
 
   static ClassDocumentation<VBFNLOPhasespace> documentation
     ("VBFNLOPhasespace is an interface to the internal phasespace generator "
      "of VBFNLO. It uses the information passed via the BLHA interface to "
      "obtain information on the required channels.");
 
 }
 
diff --git a/m4/herwig.m4 b/m4/herwig.m4
--- a/m4/herwig.m4
+++ b/m4/herwig.m4
@@ -1,1009 +1,1019 @@
 dnl ##### THEPEG #####
 AC_DEFUN([HERWIG_CHECK_THEPEG],
 [
 defaultlocation="${prefix}"
 test "x$defaultlocation" = xNONE && defaultlocation="${ac_default_prefix}"
 AC_MSG_CHECKING([for libThePEG in])
 AC_ARG_WITH(thepeg,
         AC_HELP_STRING([--with-thepeg=DIR],[location of ThePEG installation]),
         [],
 	[with_thepeg="${defaultlocation}"])
 AC_MSG_RESULT([$with_thepeg])
 
 if test "x$with_thepeg" = "xno"; then
 	AC_MSG_ERROR([Cannot build Herwig without ThePEG. Please set --with-thepeg.])
 fi
 
 THEPEGLDFLAGS="-L${with_thepeg}/lib/ThePEG"
 
 THEPEGHASLHAPDF="no"
 if test -e ${with_thepeg}/lib/ThePEG/ThePEGLHAPDF.so ; then
    THEPEGHASLHAPDF="yes"
 fi
 if test "${host_cpu}" == "x86_64" -a -e ${with_thepeg}/lib64/ThePEG/libThePEG.so ; then
   THEPEGLDFLAGS="-L${with_thepeg}/lib64/ThePEG"
   if test -e ${with_thepeg}/lib64/ThePEG/ThePEGLHAPDF.so ; then
       THEPEGHASLHAPDF="yes"
   fi
 fi
 
 if test "x$THEPEGHASLHAPDF" == "xno" ; then
    AC_MSG_ERROR([Herwig requires ThePEG to be build with lhapdf.])
 fi
 
 THEPEGHASFASTJET="no"
 if test -e ${with_thepeg}/lib/ThePEG/FastJetFinder.so ; then
    THEPEGHASFASTJET="yes"
 fi
 if test "${host_cpu}" == "x86_64" -a -e ${with_thepeg}/lib64/ThePEG/libThePEG.so ; then
   THEPEGLDFLAGS="-L${with_thepeg}/lib64/ThePEG"
   if test -e ${with_thepeg}/lib64/ThePEG/FastJetFinder.so ; then
       THEPEGHASFASTJET="yes"
   fi
 fi
 
 if test "x$THEPEGHASFASTJET" == "xno" ; then
    AC_MSG_ERROR([Herwig requires ThePEG to be build with FastJet.])
 fi
 
 THEPEGPATH="${with_thepeg}"
 
 oldldflags="$LDFLAGS"
 oldlibs="$LIBS"
 
 LDFLAGS="$LDFLAGS $THEPEGLDFLAGS"
 AC_CHECK_LIB([ThePEG],[debugThePEG],[],
 	[AC_MSG_ERROR([No ThePEG libraries in $THEPEGLDFLAGS. Please set --with-thepeg.])])
 
 AC_SUBST([THEPEGLIB],[-lThePEG])
 AC_SUBST(THEPEGLDFLAGS)
 AC_SUBST(THEPEGPATH)
 AC_SUBST(THEPEGHASLHAPDF)
 AC_SUBST(THEPEGHASFASTJET)
 
 LIBS="$oldlibs"
 LDFLAGS="$oldldflags"
 
 AC_MSG_CHECKING([for ThePEG headers in])
 AC_ARG_WITH([thepeg-headers],
         AC_HELP_STRING([--with-thepeg-headers=DIR],[location of ThePEG include directory]),
         [],
 	[with_thepeg_headers="${with_thepeg}/include"])
 AC_MSG_RESULT([$with_thepeg_headers])
 
 if test "x$with_thepeg_headers" = "xno"; then
 	AC_MSG_ERROR([Cannot build Herwig without ThePEG headers. Please set --with-thepeg-headers.])
 fi
 
 THEPEGINCLUDE="-I$with_thepeg_headers"
 
 oldcppflags="$CPPFLAGS"
 CPPFLAGS="$CPPFLAGS $THEPEGINCLUDE"
 AC_CHECK_HEADER([ThePEG/Config/ThePEG.h],[],
 	[AC_MSG_ERROR([No ThePEG headers in $with_thepeg_headers. Please set --with-thepeg-headers.])])
 CPPFLAGS="$oldcppflags"
 
 AC_SUBST(THEPEGINCLUDE)
 
 AC_MSG_CHECKING([for HepMCAnalysis.so in ThePEG])
 
 THEPEGHASHEPMC="no"
 if test -e ${with_thepeg}/lib/ThePEG/HepMCAnalysis.so ; then
    THEPEGHASHEPMC="yes"
 fi
 if test "${host_cpu}" == "x86_64" -a -e ${with_thepeg}/lib64/ThePEG/libThePEG.so ; then
   THEPEGLDFLAGS="-L${with_thepeg}/lib64/ThePEG"
   if test -e ${with_thepeg}/lib64/ThePEG/HepMCAnalysis.so ; then
     THEPEGHASHEPMC="yes"
   fi
 fi
 
 if test "x$THEPEGHASHEPMC" == "xno" ; then
   CREATE_HEPMC="# create"
   AC_MSG_RESULT([not found])
 else
   CREATE_HEPMC="create"
   AC_MSG_RESULT([found])
 fi
 
 AC_SUBST([CREATE_HEPMC])
 
 AC_MSG_CHECKING([for RivetAnalysis.so in ThePEG])
 
 THEPEGHASRIVET="no"
 if test -e ${with_thepeg}/lib/ThePEG/RivetAnalysis.so ; then
    THEPEGHASRIVET="yes"
 fi
 if test "${host_cpu}" == "x86_64" -a -e ${with_thepeg}/lib64/ThePEG/libThePEG.so ; then
   THEPEGLDFLAGS="-L${with_thepeg}/lib64/ThePEG"
   if test -e ${with_thepeg}/lib64/ThePEG/RivetAnalysis.so ; then
     THEPEGHASRIVET="yes"
   fi
 fi
 
 if test "x$THEPEGHASRIVET" == "xno" ; then
   CREATE_RIVET="# create"
   AC_MSG_RESULT([not found])
 else
   CREATE_RIVET="create"
   AC_MSG_RESULT([found])
 fi
 
 AM_CONDITIONAL(HAVE_RIVET,[test x$THEPEGHASRIVET = xyes])
 AC_SUBST([CREATE_RIVET])
 ])
 
 dnl ##### LOOPTOOLS #####
 AC_DEFUN([HERWIG_LOOPTOOLS],
 [
 AC_REQUIRE([AC_PROG_FC])
 AC_REQUIRE([AC_FC_LIBRARY_LDFLAGS])
 AC_REQUIRE([AC_PROG_CC])
 AC_REQUIRE([HERWIG_COMPILERFLAGS])
 
 AC_MSG_CHECKING([if Looptools build works])
 enable_looptools=yes
 
 if test "x$GCC" = "xyes"; then
    case "${host}" in
       x86_64-*|*-darwin1*)
 	AM_FCFLAGS="$AM_FCFLAGS -fdefault-integer-8"
       	;;
    esac
 
    AC_LANG_PUSH([Fortran])
    	oldFCFLAGS="$FCFLAGS"
    	FCFLAGS="$AM_FCFLAGS"
    	AC_COMPILE_IFELSE(
 	   	AC_LANG_PROGRAM([],[      print *[,]"Hello"]),
 		[],
 		[AC_MSG_RESULT([no])
  		 AC_MSG_ERROR([needs gfortran on 64bit machines])]
 	)
 	FCFLAGS="$oldFCFLAGS"
   AC_LANG_POP([Fortran])
 fi
 AC_MSG_RESULT([$enable_looptools])
 
 AC_LANG_PUSH([Fortran])
 AC_MSG_CHECKING([checking if fortran compiler compiles argument mismatches])
 AC_COMPILE_IFELSE(AC_LANG_SOURCE([[
       program temp
       call a(1.0D0)
       end program
       subroutine a(b)
       double complex b
       end]]),
       [AC_MSG_RESULT([yes])],
       [oldFCFLAGS="$FCFLAGS"
       FCFLAGS="-std=legacy"
       AC_MSG_CHECKING([checking if fortran compiler compiles argument mismatches with -std=legacy])
       AC_COMPILE_IFELSE(AC_LANG_SOURCE([[
       program temp
       double precision b
       double complex c
       b = 1.0D0
       c  =1.0D0
       call a(b)
       call a(c)
       end program
       subroutine a(b)
       double complex b
       end]]),
       [AC_MSG_RESULT([yes])
        AM_FCFLAGS="$AM_FCFLAGS -std=legacy"],
       [AC_MSG_RESULT([no])
       AC_MSG_ERROR([fortran compiler won't compile LoopTools])])
      FCFLAGS="$oldFCFLAGS -std=legacy"]
 )
 
 AC_MSG_CHECKING([checking if fortran compiler compiles long lines])
 AC_COMPILE_IFELSE(AC_LANG_SOURCE([[
        program temp
        write (*,*) 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
        end program]]),
        [AC_MSG_RESULT([yes])],
        [AC_MSG_RESULT([no])
        oldFCFLAGS="$FCFLAGS"
        FCFLAGS="-ffixed-line-length-none"
        AC_MSG_CHECKING([checking if fortran compiler compiles long lines with -ffixed-line-length-none])
        AC_COMPILE_IFELSE(AC_LANG_SOURCE([[
        program temp
        write (*,*) 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
        end program]]),
        [AC_MSG_RESULT([yes])
        AM_FCFLAGS="$AM_FCFLAGS -ffixed-line-length-none"
        FCFLAGS="$oldFCFLAGS -ffixed-line-length-none"],
        [FCFLAGS="-132"
        AC_MSG_CHECKING([checking if fortran compiler compiles long lines with -132])
        AC_COMPILE_IFELSE(AC_LANG_SOURCE([[
        program temp
        write (*,*) 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
        end program]]),
        [AC_MSG_RESULT([yes])
        AM_FCFLAGS="$AM_FCFLAGS -132"
        FCFLAGS="$oldFCFLAGS -132"],
        [AC_MSG_RESULT([no])
        AC_MSG_ERROR([fortran compiler won't compile LoopTools])])])
       ]
 )
 
 
 
 
 
 AC_LANG_POP([Fortran])
 
 
 AC_SUBST([F77],[$FC])
 AC_SUBST([FFLAGS],[$FCFLAGS])
 AC_SUBST([AM_FFLAGS],[$AM_FCFLAGS])
 AC_SUBST([FLIBS],[$FCLIBS])
 ])
 
 dnl ##### VBFNLO #####
 AC_DEFUN([HERWIG_CHECK_VBFNLO],
 [
 AC_MSG_CHECKING([for VBFNLO])
 
 AC_ARG_WITH([vbfnlo],
     AS_HELP_STRING([--with-vbfnlo=DIR], [Installation path of VBFNLO]),
     [],
     [with_vbfnlo=no]
 
 )
 
 AC_MSG_RESULT([$with_vbfnlo])
 
 AS_IF([test "x$with_vbfnlo" != "xno"],
       [AC_CHECK_FILES(
       ${with_vbfnlo}/lib/VBFNLO/libVBFNLO.so,
       [have_vbfnlo=lib], [have_vbfnlo=no])],
       [have_vbfnlo=no])
 
 AS_IF([test "x$with_vbfnlo" != "xno" -a "x$have_vbfnlo" = "xno" ],
       [AC_CHECK_FILES(
       ${with_vbfnlo}/lib64/VBFNLO/libVBFNLO.so,
       [have_vbfnlo=lib64], [have_vbfnlo=no])])
 
 AS_IF([test "x$with_vbfnlo" != "xno" -a "x$have_vbfnlo" = "xno" ],
       [AC_CHECK_FILES(
       ${with_vbfnlo}/lib/VBFNLO/libVBFNLO.dylib,
       [have_vbfnlo=lib], [have_vbfnlo=no])])
 
 AS_IF([test "x$with_vbfnlo" != "xno" -a "x$have_vbfnlo" = "xno" ],
       [AC_CHECK_FILES(
       ${with_vbfnlo}/lib64/VBFNLO/libVBFNLO.dylib,
       [have_vbfnlo=lib64], [have_vbfnlo=no])])
 
 AS_IF([test "x$have_vbfnlo" = "xlib"],
       [VBFNLOLIBS=${with_vbfnlo}/lib/VBFNLO
       AC_SUBST(VBFNLOLIBS)
       ])
 
 AS_IF([test "x$have_vbfnlo" = "xlib64"],
       [VBFNLOLIBS=${with_vbfnlo}/lib64/VBFNLO
       AC_SUBST(VBFNLOLIBS)
       ])
 
 AS_IF([test "x$with_vbfnlo" != "xno" -a "x$have_vbfnlo" = "xno"],
       [AC_MSG_ERROR([vbfnlo requested but not found])])
 
 AM_CONDITIONAL(HAVE_VBFNLO,[test "x$have_vbfnlo" = "xlib" -o "x$have_vbfnlo" = "xlib64"])
 
+AS_IF([test "x$with_vbfnlo" != "xno"],
+[AC_MSG_CHECKING([for VBFNLO version >= 3.0.0])
+tmp_vbfnloversion=[$(${with_vbfnlo}/bin/vbfnlo --version | awk '{print $2}')]
+AX_COMPARE_VERSION([${tmp_vbfnloversion}],[lt],[3.0.0],
+                   [have_vbfnlo3=no],
+                   [have_vbfnlo3=yes])
+
+AM_CONDITIONAL(HAVE_VBFNLO3, [test "x$have_vbfnlo3" = "xyes"])
+])
+
 if test "x$have_vbfnlo" = "xlib" -o "x$have_vbfnlo" = "xlib64" ; then
         AC_REQUIRE([AC_PROG_SED])
         VBFNLOINCLUDE=${with_vbfnlo}/include
 	AC_SUBST(VBFNLOINCLUDE)
         VBFNLOLIB=$(echo ${with_vbfnlo}/${have_vbfnlo}/VBFNLO | $SED -e 's%/\+%/%g')
         AC_SUBST(VBFNLOLIB)
      	LOAD_VBFNLO="library"
      	CREATE_VBFNLO="create"
      	INSERT_VBFNLO="insert"
      	SET_VBFNLO="set"
      	DO_VBFNLO="do"
      	MKDIR_VBFNLO="mkdir"
 else
      	LOAD_VBFNLO="# library"
 	CREATE_VBFNLO="# create"
      	INSERT_VBFNLO="# insert"
      	SET_VBFNLO="# set"
      	DO_VBFNLO="# do"
      	MKDIR_VBFNLO="# mkdir"
 fi
 
 AC_SUBST([LOAD_VBFNLO])
 AC_SUBST([CREATE_VBFNLO])
 AC_SUBST([INSERT_VBFNLO])
 AC_SUBST([SET_VBFNLO])
 AC_SUBST([DO_VBFNLO])
 AC_SUBST([MKDIR_VBFNLO])
 
 ])
 
 dnl ##### njet #####
 AC_DEFUN([HERWIG_CHECK_NJET],
 [
 AC_MSG_CHECKING([for njet])
 
 AC_ARG_WITH([njet],
     AS_HELP_STRING([--with-njet=DIR], [Installation path of njet]),
     [],
     [with_njet=no]
 
 )
 
 AC_MSG_RESULT([$with_njet])
 
 AS_IF([test "x$with_njet" != "xno"],
       [AC_CHECK_FILES(
       ${with_njet}/lib/libnjet2.so,
       [have_njet=lib], [have_njet=no])],
       [have_njet=no])
 
 AS_IF([test "x$with_njet" != "xno" -a "x$have_njet" = "xno" ],
       [AC_CHECK_FILES(
       ${with_njet}/lib64/libnjet2.so,
       [have_njet=lib64], [have_njet=no])])
 
 AS_IF([test "x$with_njet" != "xno" -a "x$have_njet" = "xno" ],
       [AC_CHECK_FILES(
       ${with_njet}/lib/libnjet2.dylib,
       [have_njet=lib], [have_njet=no])])
 
 AS_IF([test "x$with_njet" != "xno" -a "x$have_njet" = "xno" ],
       [AC_CHECK_FILES(
       ${with_njet}/lib/libnjet3.so,
       [have_njet=lib], [have_njet=no])])
 
 AS_IF([test "x$with_njet" != "xno" -a "x$have_njet" = "xno" ],
       [AC_CHECK_FILES(
       ${with_njet}/lib64/libnjet3.so,
       [have_njet=lib], [have_njet=no])])
 
 AS_IF([test "x$with_njet" != "xno" -a "x$have_njet" = "xno" ],
       [AC_CHECK_FILES(
       ${with_njet}/lib/libnjet3.dylib,
       [have_njet=lib], [have_njet=no])])
 
 AS_IF([test "x$with_njet" != "xno" ],
       [AC_CHECK_FILES(
       ${with_njet}/include/njet.h,
       [njet_include=include], [njet_include=include/njet])])
 
 AS_IF([test "x$have_njet" = "xlib"],
       [NJETLIBPATH=${with_njet}/lib
       AC_SUBST(NJETLIBPATH)
       NJETINCLUDEPATH=${with_njet}/$njet_include
       AC_SUBST(NJETINCLUDEPATH)
       NJETPREFIX=${with_njet}
       AC_SUBST(NJETPREFIX)
       ])
 
 AS_IF([test "x$have_njet" = "xlib64"],
       [NJETLIBPATH=${with_njet}/lib64
       AC_SUBST(NJETLIBPATH)
       NJETINCLUDEPATH=${with_njet}/$njet_include
       AC_SUBST(NJETINCLUDEPATH)
       NJETPREFIX=${with_njet}
       AC_SUBST(NJETPREFIX)
       ])
 
 AS_IF([test "x$with_njet" != "xno"  -a "x$have_njet" = "xno"],
       [AC_MSG_ERROR([njet requested but not found])])
 
 AM_CONDITIONAL(HAVE_NJET,[test "x$have_njet" = "xlib" -o "x$have_njet" = "xlib64"])
 
 AS_IF([test "x$with_njet" != "xno"],[AC_MSG_CHECKING([for Njet version])
 tmp_njetversion=[$(${with_njet}/bin/njet.py --version 2>&1 | grep -oE '[0-9]{4}$')]
 AS_IF([test -z "$tmp_njetversion"],
       [tmp_njetversion=1023])
       AC_MSG_RESULT([${tmp_njetversion}])
       NJET_VERSION=${tmp_njetversion}
       AC_SUBST(NJET_VERSION)
 ])
 
 if test "x$have_njet" = "xlib" -o "x$have_njet" = "xlib64" ; then
      	LOAD_NJET="library"
      	CREATE_NJET="create"
      	INSERT_NJET="insert"
      	DO_NJET="do"
 else
      	LOAD_NJET="# library"
       CREATE_NJET="# create"
      	INSERT_NJET="# insert"
      	DO_NJET="# do"
 fi
 
 AC_SUBST([LOAD_NJET])
 AC_SUBST([CREATE_NJET])
 AC_SUBST([INSERT_NJET])
 AC_SUBST([DO_NJET])
 
 ])
 
 
 
 dnl ##### gosam #####
 AC_DEFUN([HERWIG_CHECK_GOSAM],
 [
 AC_MSG_CHECKING([for GoSam])
 
 AC_ARG_WITH([gosam],
     AS_HELP_STRING([--with-gosam=DIR], [Installation path of GoSam]),
     [],
     [with_gosam=no]
 )
 
 AC_MSG_RESULT([$with_gosam])
 
 AS_IF([test "x$with_gosam" != "xno"],
       [AC_CHECK_FILES(
       ${with_gosam}/bin/gosam.py,
       [have_gosam=lib], [have_gosam=no])],
       [have_gosam=no])
 
 AS_IF([test "x$have_gosam" = "xlib"],
       [GOSAMPREFIX=${with_gosam}
       AC_SUBST(GOSAMPREFIX)
       ])
 
 AS_IF([test "x$with_gosam" != "xno"  -a "x$have_gosam" = "xno"],
       [AC_MSG_ERROR([GoSam requested but not found])])
 
 AS_IF([test "x$with_gosam" != "xno"],
 [AC_MSG_CHECKING([for GoSam version >= 2.0.4])
 tmp_gosamversion=[$(${with_gosam}/bin/gosam.py --version | grep 'GoSam.*rev' | cut -d' ' -f2)]
 AX_COMPARE_VERSION([${tmp_gosamversion}],[lt],[2.0.4],
                    [AC_MSG_RESULT([no])
                     AC_MSG_ERROR([Herwig requires GoSam 2.0.4 or later, found ${tmp_gosamversion}])],
                    [AC_MSG_RESULT([yes])])])
 
 AM_CONDITIONAL(HAVE_GOSAM,[test "x$have_gosam" = "xlib" ])
 
 if test "x$have_gosam" = "xlib"  ; then
      	LOAD_GOSAM="library"
      	CREATE_GOSAM="create"
      	INSERT_GOSAM="insert"
      	DO_GOSAM="do"
 else
      	LOAD_GOSAM="# library"
 	CREATE_GOSAM="# create"
      	INSERT_GOSAM="# insert"
      	DO_GOSAM="# do"
 fi
 
 AC_SUBST([LOAD_GOSAM])
 AC_SUBST([CREATE_GOSAM])
 AC_SUBST([INSERT_GOSAM])
 AC_SUBST([DO_GOSAM])
 
 
 ])
 
 
 dnl ##### gosam-contrib #####
 AC_DEFUN([HERWIG_CHECK_GOSAM_CONTRIB],
 [
 AC_MSG_CHECKING([for gosam-contrib])
 
 AC_ARG_WITH([gosam-contrib],
     AS_HELP_STRING([--with-gosam-contrib=DIR], [Installation path of gosam-contrib]),
     [],
     [with_gosam_contrib=no]
 )
 
 AC_MSG_RESULT([$with_gosam_contrib])
 
 AS_IF([test "x$with_gosam_contrib" = "xno" -a "x$with_gosam" != "xno"],
       [AC_CHECK_FILES(
       ${with_gosam}/lib/libsamurai.so,
       [with_gosam_contrib=${with_gosam}], [])
 ])
 
 AS_IF([test "x$with_gosam_contrib" = "xno" -a "x$with_gosam" != "xno"],
       [AC_CHECK_FILES(
       ${with_gosam}/lib64/libsamurai.so,
       [with_gosam_contrib=${with_gosam}], [])
 ])
 
 AS_IF([test "x$with_gosam_contrib" = "xno" -a "x$with_gosam" != "xno"],
       [AC_CHECK_FILES(
       ${with_gosam}/lib/libsamurai.dylib,
       [with_gosam_contrib=${with_gosam}], [])
 ])
 
 AS_IF([test "x$with_gosam_contrib" = "xno" -a "x$with_gosam" != "xno"],
       [AC_CHECK_FILES(
       ${with_gosam}/lib64/libsamurai.dylib,
       [with_gosam_contrib=${with_gosam}], [])
 ])
 
 AS_IF([test "x$with_gosam_contrib" = "xno" -a "x$with_gosam" != "xno"],
       [AC_MSG_ERROR([GoSam requested without requesting GoSam-Contrib])])
 
 AS_IF([test "x$with_gosam_contrib" != "xno"],
       [AC_CHECK_FILES(
       ${with_gosam_contrib}/lib/libsamurai.so,
       [have_gosam_contrib=lib], [have_gosam_contrib=no])],
       [have_gosam_contrib=no])
 
 AS_IF([test "x$with_gosam_contrib" != "xno" -a "x$have_gosam_contrib" = "xno" ],
       [AC_CHECK_FILES(
       ${with_gosam_contrib}/lib64/libsamurai.so,
       [have_gosam_contrib=lib64], [have_gosam_contrib=no])])
 
 AS_IF([test "x$with_gosam_contrib" != "xno" -a "x$have_gosam_contrib" = "xno" ],
       [AC_CHECK_FILES(
       ${with_gosam_contrib}/lib/libsamurai.dylib,
       [have_gosam_contrib=lib], [have_gosam_contrib=no])])
 
 AS_IF([test "x$with_gosam_contrib" != "xno" -a "x$have_gosam_contrib" = "xno" ],
       [AC_CHECK_FILES(
       ${with_gosam_contrib}/lib64/libsamurai.dylib,
       [have_gosam_contrib=lib64], [have_gosam_contrib=no])])
 
 
 
 
 
 
 
 AS_IF([test "x$have_gosam_contrib" != "xno"],
       [GOSAMCONTRIBPREFIX=${with_gosam_contrib}
       AC_SUBST(GOSAMCONTRIBPREFIX)
       ])
 
 AS_IF([test "x$have_gosam_contrib" = "xlib"],
       [GOSAMCONTRIBLIBS=${with_gosam_contrib}/lib
       AC_SUBST(GOSAMCONTRIBLIBS)
       ])
 
 AS_IF([test "x$have_gosam_contrib" = "xlib64"],
       [GOSAMCONTRIBLIBS=${with_gosam_contrib}/lib64
       AC_SUBST(GOSAMCONTRIBLIBS)
       ])
 
 AS_IF([test "x$with_gosam_contrib" != "xno"  -a "x$have_gosam_contrib" = "xno"],
       [AC_MSG_ERROR([GoSam-Contrib requested but not found])])
 
 AM_CONDITIONAL(HAVE_GOSAM_CONTRIB,[test "x$have_gosam_contrib" = "xlib" -o "x$have_gosam_contrib" = "xlib64"])
 
 if test "x$have_gosam_contrib" = "xlib" -o "x$have_gosam_contrib" = "xlib64" ; then
         LOAD_GOSAM_CONTRIB="library"
         CREATE_GOSAM_CONTRIB="create"
         INSERT_GOSAM_CONTRIB="insert"
 else
         LOAD_GOSAM_CONTRIB="# library"
         CREATE_GOSAM_CONTRIB="# create"
         INSERT_GOSAM_CONTRIB="# insert"
 fi
 
 AC_SUBST([LOAD_GOSAM_CONTRIB])
 AC_SUBST([CREATE_GOSAM_CONTRIB])
 AC_SUBST([INSERT_GOSAM_CONTRIB])
 
 
 ])
 
 
 dnl ##### OpenLoops #####
 AC_DEFUN([HERWIG_CHECK_OPENLOOPS],
 [
 AC_MSG_CHECKING([for OpenLoops])
 
 AC_ARG_WITH([openloops],
     AS_HELP_STRING([--with-openloops=DIR], [Installation path of OpenLoops]),
     [],
     [with_openloops=no]
 
 )
 
 AC_MSG_RESULT([$with_openloops])
 
 AS_IF([test "x$with_openloops" != "xno"],
       [AC_CHECK_FILES(
       ${with_openloops}/lib/libopenloops.so,
       [have_openloops=lib], [have_openloops=no])],
       [have_openloops=no])
 
 AS_IF([test "x$with_openloops" != "xno" -a "x$have_openloops" = "xno" ],
       [AC_CHECK_FILES(
       ${with_openloops}/lib/libopenloops.dylib,
       [have_openloops=lib], [have_openloops=no])])
 
 AS_IF([test "x$with_openloops" != "xno" -a "x$have_openloops" = "xno" ],
       [AC_CHECK_FILES(
       ${with_openloops}/lib64/libopenloops.so,
       [have_openloops=lib64], [have_openloops=no])])
 
 
 AS_IF([test "x$with_openloops" != "xno" -a "x$have_openloops" = "xno" ],
       [AC_CHECK_FILES(
       ${with_openloops}/lib64/libopenloops.dylib,
       [have_openloops=lib64], [have_openloops=no])])
 
 
 
 
 
 AS_IF([test "x$have_openloops" = "xlib"],
       [OPENLOOPSLIBS=${with_openloops}/lib
       AC_SUBST(OPENLOOPSLIBS)
       ])
 
 AS_IF([test "x$have_openloops" = "xlib64"],
       [OPENLOOPSLIBS=${with_openloops}/lib64
       AC_SUBST(OPENLOOPSLIBS)
       ])
 
 AS_IF([test "x$with_openloops" != "xno" -a "x$have_openloops" = "xno"],
       [AC_MSG_ERROR([OpenLoops requested but not found])])
 
 AM_CONDITIONAL(HAVE_OPENLOOPS,[test "x$have_openloops" = "xlib" -o "x$have_openloops" = "xlib64"])
 
 if test "x$have_openloops" = "xlib" -o "x$have_openloops" = "xlib64" ; then
         OPENLOOPSPREFIX=${with_openloops}
      	LOAD_OPENLOOPS="library"
      	CREATE_OPENLOOPS="create"
      	INSERT_OPENLOOPS="insert"
      	SET_OPENLOOPS="set"
      	DO_OPENLOOPS="do"
      	MKDIR_OPENLOOPS="mkdir"
 else
      	LOAD_OPENLOOPS="# library"
 	CREATE_OPENLOOPS="# create"
      	INSERT_OPENLOOPS="# insert"
      	SET_OPENLOOPS="# set"
      	DO_OPENLOOPS="# do"
      	MKDIR_OPENLOOPS="# mkdir"
 fi
 
 AC_SUBST([OPENLOOPSPREFIX])
 AC_SUBST([LOAD_OPENLOOPS])
 AC_SUBST([CREATE_OPENLOOPS])
 AC_SUBST([INSERT_OPENLOOPS])
 AC_SUBST([SET_OPENLOOPS])
 AC_SUBST([DO_OPENLOOPS])
 AC_SUBST([MKDIR_OPENLOOPS])
 
 ])
 
 #########################################
 
 dnl ##### madgraph #####
 AC_DEFUN([HERWIG_CHECK_MADGRAPH],
 [
 AC_MSG_CHECKING([for MadGraph])
 
 AC_ARG_WITH([madgraph],
     AS_HELP_STRING([--with-madgraph=DIR], [Installation path of MadGraph]),
     [],
     [with_madgraph=no]
 )
 
 AC_MSG_RESULT([$with_madgraph])
 
 AS_IF([test "x$with_madgraph" != "xno"],
       [AC_CHECK_FILES(
       ${with_madgraph}/bin/mg5_aMC,
       [have_madgraph=yes], [have_madgraph=no])],
       [have_madgraph=no])
 
 AS_IF([test "x$have_madgraph" = "xyes"],
       [MADGRAPHPREFIX=${with_madgraph}
       AC_SUBST(MADGRAPHPREFIX)
       ])
 
 AS_IF([test "x$with_madgraph" != "xno"  -a "x$have_madgraph" = "xno"],
       [AC_MSG_ERROR([MadGraph requested but not found])])
 
 AM_CONDITIONAL(HAVE_MADGRAPH,[test "x$have_madgraph" = "xyes" ])
 
 if test "x$have_madgraph" = "xyes"  ; then
      	LOAD_MADGRAPH="library"
      	CREATE_MADGRAPH="create"
      	INSERT_MADGRAPH="insert"
      	SET_MADGRAPH="set"
      	DO_MADGRAPH="do"
 else
      	LOAD_MADGRAPH="# library"
 	CREATE_MADGRAPH="# create"
      	INSERT_MADGRAPH="# insert"
      	SET_MADGRAPH="# set"
      	DO_MADGRAPH="# do"
 fi
 
 AC_SUBST([LOAD_MADGRAPH])
 AC_SUBST([CREATE_MADGRAPH])
 AC_SUBST([INSERT_MADGRAPH])
 AC_SUBST([SET_MADGRAPH])
 AC_SUBST([DO_MADGRAPH])
 
 ])
 
 
 AC_DEFUN([HERWIG_CHECK_PYTHIA],
 [
 dnl check if a directory is specified for Pythia
 AC_ARG_WITH(pythia,
             [AC_HELP_STRING([--with-pythia=dir],
                             [Assume the given directory for Pythia])])
 
 dnl search for the pythia-config script
 if test "$with_pythia" = ""; then
    AC_PATH_PROG(pythiaconfig, pythia8-config, no)
 else
    AC_PATH_PROG(pythiaconfig, pythia8-config, no, ${with_pythia}/bin)
 fi
 
 if test "${pythiaconfig}" = "no"; then
    AC_MSG_CHECKING(Pythia)
    AC_MSG_RESULT(no);
    PYTHIA8LIB=
 #   $2
 else
    PYTHIA8DATA=`${pythiaconfig} --datadir`/xmldoc
    PYTHIA8LIB="-L`${pythiaconfig} --libdir` -lpythia8"
 fi
 
 AC_SUBST(PYTHIA8DATA)
 AC_SUBST(PYTHIA8LIB)
 
 ])
 
 dnl CHECK PYTHIA END
 
 dnl ##### EvtGen #####
 AC_DEFUN([HERWIG_CHECK_EVTGEN],
 [
 AC_MSG_CHECKING([for evtgen])
 
 AC_ARG_WITH([evtgen],
     AS_HELP_STRING([--with-evtgen=DIR], [Installation path of EvtGen]),
     [],
     [with_evtgen=no]
 )
 
 AC_MSG_RESULT([$with_evtgen])
 
 AS_IF([test "x$with_evtgen" != "xno"],
       [AC_CHECK_FILES(
       ${with_evtgen}/lib/libEvtGenExternal.so,
       [have_evtgen=lib], [have_evtgen=no])],
       [have_evtgen=no])
 
 AS_IF([test "x$with_evtgen" != "xno" -a "x$have_evtgen" = "xno"],
       [AC_CHECK_FILES(
       ${with_evtgen}/lib64/libEvtGenExternal.so,
       [have_evtgen=lib64], [have_evtgen=no])])
 
 AS_IF([test "x$with_evtgen" != "xno" -a "x$have_evtgen" = "xno" ],
       [AC_CHECK_FILES(
       ${with_evtgen}/lib/libEvtGenExternal.dylib,
       [have_evtgen=lib], [have_evtgen=no])])
 
 AS_IF([test "x$have_evtgen" = "xlib" -o "x$have_evtgen" = "xlib64" ],
       [EVTGENPREFIX=${with_evtgen}
       AC_SUBST(EVTGENPREFIX)
       ])
       
 AS_IF([test "x$have_evtgen" = "xlib" -o "x$have_evtgen" = "xlib64" ],
       [AC_CHECK_FILES(
       ${with_evtgen}/share/evt.pdl,
       [EVTGENSHARE=${with_evtgen}/share], [EVTGENSHARE=${with_evtgen}/share/EvtGen])
        AC_SUBST(EVTGENSHARE)])
 
 AS_IF([test "x$with_evtgen" != "xno"  -a "x$have_evtgen" = "xno"],
       [AC_MSG_ERROR([EvtGen requested but not found])])
 
 AC_SUBST([EVTGENINCLUDE],[-I$EVTGENPREFIX/include])
 
 AM_CONDITIONAL(HAVE_EVTGEN,[test "x$have_evtgen" = "xlib" -o "x$have_evtgen" = "xlib64"])
 
 if test "x$have_evtgen" = "xlib"  ; then
      	LOAD_EVTGEN_DECAYS="read EvtGenBDecays.in"
      	LOAD_EVTGEN_DECAYER="read EvtGenDecayer.in"
 	EVTGENLIBS="-L$with_evtgen/lib -lEvtGen -lEvtGenExternal"
 elif test "x$have_evtgen" = "xlib64"  ; then
       LOAD_EVTGEN_DECAYS="read EvtGenBDecays.in"
       LOAD_EVTGEN_DECAYER="read EvtGenDecayer.in"
       EVTGENLIBS="-L$with_evtgen/lib64 -lEvtGen -lEvtGenExternal"
 else
      	LOAD_EVTGEN_DECAYS="read HerwigBDecays.in"
      	LOAD_EVTGEN_DECAYER="#read EvtGenDecayer.in"
 	EVTGENLIBS=""
 fi
 
 AC_SUBST([LOAD_EVTGEN_DECAYS])
 AC_SUBST([LOAD_EVTGEN_DECAYER])
 AC_SUBST([EVTGENLIBS])
 
 
 ])
 
 dnl ###### GSL ######
 AC_DEFUN([HERWIG_CHECK_GSL],
 [
 AC_MSG_CHECKING([for gsl location])
 GSLINCLUDE=""
 GSLLIBS=""
 
 AC_ARG_WITH(gsl,
         AC_HELP_STRING([--with-gsl=DIR],[location of gsl installation @<:@default=system libs@:>@]),
         [],
 	[with_gsl=system])
 
 if test "x$with_gsl" = "xno"; then
 AC_MSG_ERROR([libgsl is required. Please install the GNU scientific library and header files.])
 fi
 
 if test "x$with_gsl" = "xsystem"; then
 	AC_MSG_RESULT([in system libraries])
 	oldlibs="$LIBS"
 	AC_CHECK_LIB(m,main)
 	AC_CHECK_LIB(gslcblas,main)
 	AC_CHECK_LIB(gsl,main,[],
 			[
 			AC_MSG_ERROR([Cannot find libgsl. Please install the GNU scientific library and header files or use --with-gsl=.])
 			]
 		     )
 	GSLLIBS="$LIBS"
 	GSLPATH="$with_gsl"
 	LIBS=$oldlibs
 else
 	if test "`uname -m`" = "x86_64" -a -e "$with_gsl/lib64/libgsl.a" -a -d "$with_gsl/include/gsl"; then
 		AC_MSG_RESULT([found in $with_gsl])
 		GSLLIBS="-L$with_gsl/lib64 -R$with_gsl/lib64 -lgslcblas -lgsl"
 		GSLINCLUDE="-I$with_gsl/include"
 		GSLPATH="$with_gsl"
 	elif test -e "$with_gsl/lib/libgsl.a" -a -d "$with_gsl/include/gsl"; then
 		AC_MSG_RESULT([found in $with_gsl])
 		GSLLIBS="-L$with_gsl/lib -R$with_gsl/lib -lgslcblas -lgsl"
 		GSLINCLUDE="-I$with_gsl/include"
 		GSLPATH="$with_gsl"
 	else
 		AC_MSG_RESULT([not found])
 		AC_MSG_ERROR([Can't find $with_gsl/lib/libgsl.a or the headers in $with_gsl/include])
 	fi
 fi
 
 AC_SUBST(GSLINCLUDE)
 AC_SUBST(GSLLIBS)
 AC_SUBST(GSLPATH)
 ])
 
 dnl ##### COMPILERFLAGS #####
 AC_DEFUN([HERWIG_COMPILERFLAGS],
 [
 AC_REQUIRE([HERWIG_CHECK_GSL])
 AC_REQUIRE([HERWIG_CHECK_THEPEG])
 AC_REQUIRE([BOOST_REQUIRE])
 AC_REQUIRE([AX_COMPILER_VENDOR])
 
 AM_CPPFLAGS="-I\$(top_builddir)/include $THEPEGINCLUDE \$(GSLINCLUDE) \$(BOOST_CPPFLAGS)"
 
 AC_MSG_CHECKING([for debugging mode])
 AC_ARG_ENABLE(debug,
         AC_HELP_STRING([--enable-debug],[debug mode, use --enable-debug=slow for additional options that slow down the run.]),
         [],
         [enable_debug=no]
         )
 AC_MSG_RESULT([$enable_debug])
 
 if test "x$enable_debug" = "xno"; then
 	debugflags=""
 else
 	debugflags="-g"
 fi
 
 dnl -Wfloat-equal -fvisibility-inlines-hidden -Wctor-dtor-privacy -Weffc++
 if test -n "$GCC"; then
 	warnflags="-pedantic -Wall -Wextra -Wno-overloaded-virtual"
 
 	if test "x$enable_debug" = "xslow"; then
 		debugflags="$debugflags -fno-inline"
 		AM_CPPFLAGS="$AM_CPPFLAGS -D_GLIBCXX_DEBUG"
 	fi
 fi
 
 dnl do an actual capability check on ld instead of this workaround
 case "${host}" in
   *-darwin*)
      ;;
   *)
      AM_LDFLAGS="-Wl,--enable-new-dtags"
      ;;
 esac
 
 case "${ax_cv_cxx_compiler_vendor}" in
      gnu)
         AM_CXXFLAGS="-pedantic -Wall -W -Wno-use-after-free"
         ;;
      clang)
         AM_CXXFLAGS="-pedantic -Wall -Wno-overloaded-virtual -Wno-unused-function -Wno-unused-parameter"
 dnl  -Wno-unneeded-internal-declaration
         ;;
      intel)
         AM_CXXFLAGS="-strict-ansi -Wall -wd13000,1418,981,444,383,1599,1572,2259,980"
         ;;
 esac
 
 
 
 AC_SUBST(AM_CPPFLAGS)
 AC_SUBST(AM_CFLAGS,  ["$warnflags $debugflags"])
 AC_SUBST(AM_CXXFLAGS,["$AM_CXXFLAGS $warnflags $debugflags"])
 AC_SUBST(AM_FCFLAGS,  ["$debugflags"])
 AC_SUBST(AM_LDFLAGS)
 ])
 
 AC_DEFUN([HERWIG_ENABLE_MODELS],
 [
 AC_MSG_CHECKING([if BSM models should be built])
 
 AC_ARG_ENABLE(models,
         AC_HELP_STRING([--disable-models],[Turn off compilation of BSM models.]),
         [],
         [enable_models=yes]
         )
 AC_MSG_RESULT([$enable_models])
 
 LOAD_BSM=""
 if test "$enable_models" = "yes"; then
 LOAD_BSM="read BSMlibs.in"
 fi
 AC_SUBST(LOAD_BSM)
 
 AM_CONDITIONAL(WANT_BSM,[test "$enable_models" = "yes"])
 ])
 
 AC_DEFUN([HERWIG_OVERVIEW],
 [
 FCSTRING=`$FC --version | head -1`
 CXXSTRING=`$CXX --version | head -1`
 CCSTRING=`$CC --version | head -1`
 if test "x$PYTHON" != "x:"
 then
    python_was_found="yes, using Python $PYTHON_VERSION"
 else
    python_was_found="no, requires Python >= 2.6"
 fi
 
 cat << _HW_EOF_ > config.herwig
 *****************************************************
 *** $PACKAGE_STRING configuration summary
 *** Please include this information in bug reports!
 ***--------------------------------------------------
 *** Prefix:		$prefix
 ***
 *** BSM models:		$enable_models
 *** UFO converter:	${python_was_found}
 ***
 *** Herwig debug mode:	$enable_debug
 ***
 *** ThePEG:		$with_thepeg
 *** ThePEG headers:	$with_thepeg_headers
 ***
 *** GoSam:		$with_gosam
 *** GoSam-Contrib:      $with_gosam_contrib
 *** MadGraph:        	$with_madgraph
 *** njet:		$with_njet ${NJET_VERSION}
 *** OpenLoops:		$with_openloops
 *** VBFNLO:		$with_vbfnlo
 ***
 *** EvtGen:		$with_evtgen
 *** GSL:		$with_gsl
 *** boost:              ${BOOST_CPPFLAGS:-system}
 *** Fastjet:		${fjconfig}
 ***
 *** Host:		$host
 *** CC:			$CCSTRING
 *** CXX:		$CXXSTRING
 *** FC:			$FCSTRING
 ***
 *** CXXFLAGS:		$CXXFLAGS
 *** FCFLAGS:            $FCFLAGS
 *****************************************************
 _HW_EOF_
 ])