diff --git a/include/HEJ/jets.hh b/include/HEJ/jets.hh
index 93a5381..d33da22 100644
--- a/include/HEJ/jets.hh
+++ b/include/HEJ/jets.hh
@@ -1,341 +1,399 @@
 /**
  *  \authors   The HEJ collaboration (see AUTHORS for details)
  *  \date      2019
  *  \copyright GPLv2 or later
  */
 /** \file
  *  \brief Functions computing the square of current contractions in pure jets.
  *
  *  This file contains all the necessary functions to compute the
  *  current contractions for all valid pure jet HEJ processes, which
  *  so far is FKL and unordered processes. It will also contain some
  *  pure jet ME components used in other process ME calculations
  *
  *  @TODO add a namespace
  */
 #pragma once
 
 #include <complex>
 #include <ostream>
 
 #include <CLHEP/Vector/LorentzVector.h>
 
 typedef std::complex<double> COM;
 typedef COM current[4];
 typedef CLHEP::HepLorentzVector HLV;
 
 //! Square of qQ->qQ Pure Jets Scattering Current
 /**
  *  @param p1out     Momentum of final state quark
  *  @param p1in      Momentum of initial state quark
  *  @param p2out     Momentum of final state quark
  *  @param p2in      Momentum of intial state quark
  *  @returns         Square of the current contractions for qQ->qQ Scattering
  */
 double ME_qQ (HLV p1out, HLV p1in, HLV p2out, HLV p2in);
 
 //! Square of qQbar->qQbar Pure Jets Scattering Current
 /**
  *  @param p1out     Momentum of final state quark
  *  @param p1in      Momentum of initial state quark
  *  @param p2out     Momentum of final state anti-quark
  *  @param p2in      Momentum of intial state anti-quark
  *  @returns         Square of the current contractions for qQbar->qQbar Scattering
  *
  *  @note this can be used for qbarQ->qbarQ Scattering by inputting arguments
  *        appropriately.
  */
 double ME_qQbar (HLV p1out, HLV p1in, HLV p2out, HLV p2in);
 
 //! Square of qbarQbar->qbarQbar Pure Jets Scattering Current
 /**
  *  @param p1out     Momentum of final state anti-quark
  *  @param p1in      Momentum of initial state anti-quark
  *  @param p2out     Momentum of final state anti-quark
  *  @param p2in      Momentum of intial state anti-quark
  *  @returns         Square of the current contractions for qbarQbar->qbarQbar Scattering
  */
 double ME_qbarQbar (HLV p1out, HLV p1in, HLV p2out, HLV p2in);
 
 //! Square of qg->qg Pure Jets Scattering Current
 /**
  *  @param p1out     Momentum of final state quark
  *  @param p1in      Momentum of initial state quark
  *  @param p2out     Momentum of final state gluon
  *  @param p2in      Momentum of intial state gluon
  *  @returns         Square of the current contractions for qg->qg Scattering
  *
  *  @note this can be used for gq->gq Scattering by inputting arguments
  *        appropriately.
  */
 double ME_qg (HLV p1out, HLV p1in, HLV p2out, HLV p2in);
 
 //! Square of qbarg->qbarg Pure Jets Scattering Current
 /**
  *  @param p1out     Momentum of final state anti-quark
  *  @param p1in      Momentum of initial state anti-quark
  *  @param p2out     Momentum of final state gluon
  *  @param p2in      Momentum of intial state gluon
  *  @returns         Square of the current contractions for qbarg->qbarg Scattering
  *
  *  @note this can be used for gqbar->gqbar Scattering by inputting arguments
  *        appropriately.
  */
 double ME_qbarg (HLV p1out, HLV p1in, HLV p2out, HLV p2in);
 
 //! Square of gg->gg Pure Jets Scattering Current
 /**
  *  @param p1out     Momentum of final state gluon
  *  @param p1in      Momentum of initial state gluon
  *  @param p2out     Momentum of final state gluon
  *  @param p2in      Momentum of intial state gluon
  *  @returns         Square of the current contractions for gg->gg Scattering
  */
 double ME_gg (HLV p1out, HLV p1in, HLV p2out, HLV p2in);
 
 //Unordered Backwards contributions:
 //! Square of qQ->qQ Pure Jets Scattering Current
 /**
  *  @param p1out     Momentum of final state quark
  *  @param p1in      Momentum of initial state quark
  *  @param pg        Momentum of unordered gluon
  *  @param p2out     Momentum of final state quark
  *  @param p2in      Momentum of intial state quark
  *  @returns         Square of the current contractions for qQ->qQ Scattering
  */
 double ME_unob_qQ (HLV pg, HLV p1out, HLV p1in, HLV p2out, HLV p2in);
 
 //! Square of qbarQ->qbarQ Pure Jets Unordered backwards Scattering Current
 /**
  *  @param p1out     Momentum of final state anti-quark
  *  @param p1in      Momentum of initial state anti-quark
  *  @param pg        Momentum of unordered gluon
  *  @param p2out     Momentum of final state quark
  *  @param p2in      Momentum of intial state quark
  *  @returns         Square of the current contractions for qbarQ->qbarQ Scattering
  *
  *  @note this can be used for unof contributions by inputting
  *        arguments appropriately.
  */
 double ME_unob_qbarQ (HLV pg, HLV p1out, HLV p1in, HLV p2out, HLV p2in);
 
 //! Square of qQbar->qQbar Pure Jets Unordered backwards Scattering Current
 /**
  *  @param p1out     Momentum of final state quark
  *  @param p1in      Momentum of initial state quark
  *  @param pg        Momentum of unordered gluon
  *  @param p2out     Momentum of final state anti-quark
  *  @param p2in      Momentum of intial state anti-quark
  *  @returns         Square of the current contractions for qQbar->qQbar Scattering
  *
  *  @note this can be used for unof contributions by inputting
  *        arguments appropriately.
  */
 double ME_unob_qQbar (HLV pg, HLV p1out, HLV p1in, HLV p2out, HLV p2in);
 
 //! Square of qbarQbar->qbarQbar Pure Jets Unordered backwards Scattering Current
 /**
  *  @param p1out     Momentum of final state anti-quark
  *  @param p1in      Momentum of initial state anti-quark
  *  @param pg        Momentum of unordered gluon
  *  @param p2out     Momentum of final state anti-quark
  *  @param p2in      Momentum of intial state anti-quark
  *  @returns         Square of the current contractions for qbarQbar->qbarQbar Scattering
  *
  *  @note this can be used for unof contributions by inputting
  *        arguments appropriately.
  */
 double ME_unob_qbarQbar (HLV pg, HLV p1out, HLV p1in, HLV p2out, HLV p2in);
 
 //! Square of qg->qg Pure Jets Unordered backwards Scattering Current
 /**
  *  @param p1out     Momentum of final state gluon
  *  @param p1in      Momentum of initial state gluon
  *  @param pg        Momentum of unordered gluon
  *  @param p2out     Momentum of final state quark
  *  @param p2in      Momentum of intial state quark
  *  @returns         Square of the current contractions for qg->qg Scattering
  *
  *  @note this can be used for unof contributions by inputting
  *        arguments appropriately.
  */
 double ME_unob_qg (HLV pg, HLV p1out, HLV p1in, HLV p2out, HLV p2in);
 
 //! Square of qbarg->qbarg Pure Jets Unordered backwards Scattering Current
 /**
  *  @param p1out     Momentum of final state gluon
  *  @param p1in      Momentum of initial state gluon
  *  @param pg        Momentum of unordered gluon
  *  @param p2out     Momentum of final state anti-quark
  *  @param p2in      Momentum of intial state anti-quark
  *  @returns         Square of the current contractions for qbarg->qbarg Scattering
  *
  *  @note this can be used for unof contributions by inputting
  *        arguments appropriately.
  */
 double ME_unob_qbarg (HLV pg, HLV p1out, HLV p1in, HLV p2out, HLV p2in);
 
+//! Square of gQ->qbarqQ Pure Jets Extremal qqx backwards Scattering Current
+/**
+ *  @param pgin      Momentum of incoming gluon
+ *  @param pqout     Momentum of Quark from split
+ *  @param pqbarout  Momentum of Anti-quark from split
+ *  @param p2out     Momentum of Outgoing forwards leg
+ *  @param p2in      Momentum of Incoming forwards leg
+ *  @returns         Square of the current contractions for gQ->qbarqg Scattering
+ *
+ *  @note this can be used for Exqqxf contributions by inputting
+ *        arguments appropriately.
+ */
+double ME_Exqqx_qbarqQ(HLV pgin, HLV pqout, HLV pqbarout, HLV p2out, HLV p2in);
+
+//! Square of gQ->qqbarQ Pure Jets Extremal qqx backwards Scattering Current
+/**
+ *  @param pgin      Momentum of incoming gluon
+ *  @param pqout     Momentum of Quark from split
+ *  @param pqbarout  Momentum of Anti-quark from split
+ *  @param p2out     Momentum of Outgoing forwards leg
+ *  @param p2in      Momentum of Incoming forwards leg
+ *  @returns         Square of the current contractions for gQ->qqbarg Scattering
+ *
+ *  @note this can be used for Exqqxf contributions by inputting
+ *        arguments appropriately.
+ */
+double ME_Exqqx_qqbarQ(HLV pgin, HLV pqout, HLV pqbarout, HLV p2out, HLV p2in);
+
+//! Square of gg->qbarqg Pure Jets Extremal qqx backwards Scattering Current
+/**
+ *  @param pgin      Momentum of incoming gluon
+ *  @param pqout     Momentum of Quark from split
+ *  @param pqbarout  Momentum of Anti-quark from split
+ *  @param p2out     Momentum of Outgoing forwards leg
+ *  @param p2in      Momentum of Incoming forwards leg
+ *  @returns         Square of the current contractions for gg->qbarqg Scattering
+ *
+ *  @note this can be used for Exqqxf contributions by inputting
+ *        arguments appropriately.
+ */
+double ME_Exqqx_qbarqg(HLV pgin, HLV pqout, HLV pqbarout, HLV p2out, HLV p2in);
+
+//! Square of gg->qqbarg Pure Jets Extremal qqx backwards Scattering Current
+/**
+ *  @param pgin      Momentum of incoming gluon
+ *  @param pqout     Momentum of Quark from split
+ *  @param pqbarout  Momentum of Anti-quark from split
+ *  @param p2out     Momentum of Outgoing forwards leg
+ *  @param p2in      Momentum of Incoming forwards leg
+ *  @returns         Square of the current contractions for gg->qqbarg Scattering
+ *
+ *  @note this can be used for Exqqxf contributions by inputting
+ *        arguments appropriately.
+ */
+double ME_Exqqx_qqbarg(HLV pgin, HLV pqout, HLV pqbarout, HLV p2out, HLV p2in);
+
+
+
 /** \class CCurrent jets.hh "include/HEJ/jets.hh"
  *  \brief This is the a new class structure for currents.
  */
 class CCurrent
 {
 public:
     CCurrent(COM sc0, COM sc1, COM sc2, COM sc3)
     :c0(sc0),c1(sc1),c2(sc2),c3(sc3)
     {};
     CCurrent(const HLV p)
     {
         c0=p.e();
         c1=p.px();
         c2=p.py();
         c3=p.pz();
     };
     CCurrent()
     {};
     CCurrent operator+(const CCurrent& other);
     CCurrent operator-(const CCurrent& other);
     CCurrent operator*(const double x);
     CCurrent operator*(const COM x);
     CCurrent operator/(const double x);
     CCurrent operator/(const COM x);
 
     friend std::ostream& operator<<(std::ostream& os, const CCurrent& cur);
     COM dot(HLV p1);
     COM dot(CCurrent p1);
     COM c0,c1,c2,c3;
 };
 
 /* std::ostream& operator <<(std::ostream& os, const CCurrent& cur); */
 CCurrent operator * ( double x, CCurrent& m);
 CCurrent operator * ( COM x, CCurrent& m);
 CCurrent operator / ( double x, CCurrent& m);
 CCurrent operator / ( COM x, CCurrent& m);
 
 //! Current <incoming state | mu | outgoing state>
 /**
  * This is a wrapper function around \see joi() note helicity flip to
  * give same answer.
  */
 void jio(HLV pin, bool helin, HLV pout, bool helout, current &cur);
 
 //! Current <outgoing state | mu | outgoing state>
 /**
  * @param pi              bra state momentum
  * @param heli            helicity of pi
  * @param pj              ket state momentum
  * @param helj            helicity of pj. (must be same as heli)
  * @param cur             reference to current which is saved.
  *
  * This function is for building <i (out)| mu |j (out)> currents. It
  * must be called with pi as the bra, and pj as the ket.
  *
  * @TODO Remove heli/helj and just have helicity of current as argument.
  */
 void joo(HLV pi, bool heli, HLV pj, bool helj, current &cur);
 
 //! Current <outgoing state | mu | incoming state>
 /**
  * @param pout            bra state momentum
  * @param helout          helicity of pout
  * @param pin             ket state momentum
  * @param helin           helicity of pin. (must be same as helout)
  * @param cur             reference to current which is saved.
  *
  * This function is for building <out| mu |in> currents. It must be
  * called with pout as the bra, and pin as the ket. jio calls this
  * with flipped helicity
  *
  * @TODO Remove helout/helin and just have helicity of current as argument.
  */
 void joi(HLV pout, bool helout, HLV pin, bool helin, current &cur);
 
 //! Current <outgoing state | mu | incoming state>
 /**
  * This is a wrapper function around the void function of the same name. \see joi
  *
  * @TODO This is never used
  */
 CCurrent joi (HLV pout, bool helout, HLV pin, bool helin);
 
 //! Current <incoming state | mu | outgoing state>
 /**
  * This is a wrapper function around the void function of the same name. \see jio
  */
 CCurrent jio (HLV pout, bool helout, HLV pin, bool helin);
 
 //! Current <outgoing state | mu | outgoing state>
 /**
  * This is a wrapper function around the void function of the same name. \see joo
  */
 CCurrent joo (HLV pout, bool helout, HLV pin, bool helin);
 
 inline COM cdot(const current & j1, const current & j2)
 {
   return j1[0]*j2[0]-j1[1]*j2[1]-j1[2]*j2[2]-j1[3]*j2[3];
 }
 
 inline COM cdot(const HLV & p, const current & j1) {
   return j1[0]*p.e()-j1[1]*p.x()-j1[2]*p.y()-j1[3]*p.z();
 }
 
 inline void cmult(const COM & factor, const current & j1, current &cur)
 {
   cur[0]=factor*j1[0];
   cur[1]=factor*j1[1];
   cur[2]=factor*j1[2];
   cur[3]=factor*j1[3];
 }
 
 // WHY!?!
 inline void cadd(const current & j1, const current & j2, const current & j3,
           const current & j4, const current & j5, current &sum)
 {
   sum[0]=j1[0]+j2[0]+j3[0]+j4[0]+j5[0];
   sum[1]=j1[1]+j2[1]+j3[1]+j4[1]+j5[1];
   sum[2]=j1[2]+j2[2]+j3[2]+j4[2]+j5[2];
   sum[3]=j1[3]+j2[3]+j3[3]+j4[3]+j5[3];
 }
 
 inline void cadd(const current & j1, const current & j2, const current & j3,
           const current & j4, current &sum) {
   sum[0] = j1[0] + j2[0] + j3[0] + j4[0];
   sum[1] = j1[1] + j2[1] + j3[1] + j4[1];
   sum[2] = j1[2] + j2[2] + j3[2] + j4[2];
   sum[3] = j1[3] + j2[3] + j3[3] + j4[3];
 }
 
 inline void cadd(const current & j1, const current & j2, const current & j3,
          current &sum)
 {
   sum[0]=j1[0]+j2[0]+j3[0];
   sum[1]=j1[1]+j2[1]+j3[1];
   sum[2]=j1[2]+j2[2]+j3[2];
   sum[3]=j1[3]+j2[3]+j3[3];
 }
 
 inline void cadd(const current & j1, const current & j2, current &sum)
 {
   sum[0]=j1[0]+j2[0];
   sum[1]=j1[1]+j2[1];
   sum[2]=j1[2]+j2[2];
   sum[3]=j1[3]+j2[3];
 }
 
 inline double abs2(const COM & a)
 {
     return (a*conj(a)).real();
 }
 
 inline double vabs2(const CCurrent & cur)
 {
     return abs2(cur.c0)-abs2(cur.c1)-abs2(cur.c2)-abs2(cur.c3);
 }
 
 inline double vre(const CCurrent & a, const CCurrent & b)
 {
   return real(a.c0*conj(b.c0)-a.c1*conj(b.c1)-a.c2*conj(b.c2)-a.c3*conj(b.c3));
 }
 //! @TODO These are not currents and should be moved elsewhere.
 double K_g(double p1minus, double paminus);
 double K_g(HLV const & pout, HLV const & pin);