diff --git a/Models/Feynrules/python/slha2herwig b/Models/Feynrules/python/slha2herwig
--- a/Models/Feynrules/python/slha2herwig
+++ b/Models/Feynrules/python/slha2herwig
@@ -1,111 +1,112 @@
 #! /usr/bin/env python
 from __future__ import division
+from __future__ import print_function
 import os, sys, argparse, re, string
 
 comment_pat = re.compile('\s*#.*$')
 block_pat = re.compile('^\s*block\s+(\w+)',flags=re.I)
 decay_pat = re.compile('^\s*decay\s+(\w+)\s+([-+\.\w]+)',flags=re.I)
 
 data_pat = re.compile('^\s*((\d+\s+)+)(-?\d\S*)\s*$')
 whitespace = re.compile('\s+')
 
 
 PARAMS = {}
 
 # set up the option parser for command line input 
 parser = argparse.ArgumentParser(
 	description='Modify a ThePEG model file with parameters from a matching SLHA file.'
 )
 parser.add_argument(
 	'modelfile', 
 	metavar='ThePEG_model', 
 	help='ThePEG model file to use as template. Must have "# SLHA #"" annotations.'
 )
 parser.add_argument(
 	'slhafile', 
 	metavar='SLHA_file', 
 	help='SLHA spectrum file.'
 )
 parser.add_argument(
     '-o','--output',
     default="FRModel_slha.model",
     help="Name for the output file"
 )
 
 args = parser.parse_args()
 
 with open(args.slhafile) as f:
 	currentblock = None
 	for line in f:
 		line = comment_pat.sub('',line.rstrip())
 		if not line: continue
 		m = block_pat.match(line)
 		d = decay_pat.match(line)
 		if m:
 			currentblock = m.group(1).upper()
 		elif d:
 			currentblock = None
 			label = 'DECAY_%s' % d.group(1)
 			data = float(d.group(2))
 			PARAMS[label] = data
 		elif currentblock is not None:
 			d = data_pat.match(line)
 			if d:
 				index = whitespace.sub('_',d.group(1).rstrip())
 				try:
 					data  = float(d.group(3))
 				except ValueError:
 					continue
 				label = '%s_%s' % (currentblock, index)
 				#if label in PARAMS:
 				PARAMS[label] = data
 
 
 template = open(args.modelfile)
 output   = open(args.output,'w')
 
 line = template.readline()
 while line:
 	split = line.split("${")
 	if (len(split) == 1 ) :
 		output.write(line)
 	else :
 		outputLine = split[0]
 		for i in range(1,len(split)) :
 			split2 = split[i].split("}")
 			key = split2[0]
 			if key in PARAMS :
 				outputLine += str(PARAMS[key]) + split2[1]
 			else :
 				name, suffix = key.rsplit('_',1)
 				if suffix == 'ABS':
 					mass = PARAMS[name]
 					try:
 						mass = mass.real
 					except:
 						pass
 					outputLine += str(abs(mass)) + split2[1]
 				elif suffix == 'CTAU':
 					hbarc = 197.3269631e-15
 					if(name in PARAMS) :
 						width = PARAMS[name]
 						ctau = (hbarc / width) if width != 0 else 0
 					else :
 						ctau = 0
 					outputLine += str(ctau) + split2[1]
 				elif suffix == 'WCUT':
 					if(name in PARAMS) :
 						width = PARAMS[name]
 					else :
 						width = 0.
 					wcut = 10.0 * width
 					outputLine += str(wcut) + split2[1]
 				elif name == 'DECAY':
 					outputLine += str(0.) + split2[1]
 				else :
-					print 'Parameter ',key,'not set in SLHA file, keeping default'
+					print ('Parameter ',key,'not set in SLHA file, keeping default')
 					outputLine = '#' + outputLine + "${" + split2[0] + "}" + split2[1]
 		output.write(outputLine)
 	line = template.readline()
 output.write("\n")
-print "Output written as : ",args.output
+print ("Output written as : ",args.output)
diff --git a/Models/Feynrules/python/ufo2peg/helpers.py b/Models/Feynrules/python/ufo2peg/helpers.py
--- a/Models/Feynrules/python/ufo2peg/helpers.py
+++ b/Models/Feynrules/python/ufo2peg/helpers.py
@@ -1,312 +1,316 @@
 from __future__ import print_function
 from string import Template
 from os import path
 import sys,cmath,glob
 import re
 
 """
 Helper functions for the Herwig Feynrules converter
 """
 
 class CheckUnique:
     """Uniqueness checker.
     
     An object of this class remembers the value it was called with first.
     Any subsequent call to it will only succeed if the same value is passed again.
     For example,
 
     >>> f = CheckUnique()
     >>> f(5)
     >>> f(5)
     >>> f(4)
     Traceback (most recent call last):
         ...
     AssertionError
     """
     def __init__(self):
         self.val = None
 
     def __call__(self,val):
         """Store value on first call, then compare."""
         if self.val is None:
             self.val = val
         else:
             assert( val == self.val )
 
 
 
 def is_number(s):
     """Check if a value is a number."""
     try:
         float(s)
     except ValueError:
         return False
     return True
 
 
 
 def getTemplate(name):
     """Create a python string template from a file."""
     templatename = '{name}.template'.format(name=name)
     # assumes the template files sit next to this script
     moduledir = path.dirname(path.abspath(__file__))
     templatepath = path.join(moduledir,templatename)
     with open(templatepath, 'r') as f:
         templateText = f.read()
     return Template( templateText )
 
 def writeFile(filename, text):
     """Write text to a filename."""
     with open(filename,'w') as f:
         f.write(text)
 
 def coupling_orders(vertex, coupling, defns):
     # if more  than one take QCD over QED and then lowest order in QED
     if type(coupling) is list:
         print('not sure this happens')
         quit()
         qed = 0
         qcd = 0
         for coup in coupling :
             qed1 = coup.order.get('QED',0)
             qcd1 = coup.order.get('QCD',0)
             if qcd1 != 0:
                 if qcd == 0 or (qcd1 != 0 and qcd1 < qcd):
                     qcd=qcd1
                     qed=qed1
             else:
                 if qed == 0 or (qed1 != 0 and qed1 < qed):
                     qed=qed1
     else:
         output={}
         for ctype in defns :
             output[ctype]=coupling.order.get(ctype,0)
     return output
 
 def def_from_model(FR,s):
     """Return a C++ line that defines parameter s as coming from the model file."""
     if("hw_kine" in s) :return ""
     stype = typemap(getattr(FR.parameters,s).type)
     return '{t} {s} = model_->{s}();'.format(t=stype,s=s)
 
 _typemap = {'complex':'Complex',
             'real':'double'}
 
 def typemap(s):
     return _typemap[s]
 
 def add_brackets(expr, syms):
     result = expr
     for s in syms:
         pattern = r'({symb})(\W|$)'.format(symb=s)
         result = re.sub(pattern, r'\1()\2', result)
     return result
 
 
 
 
 def banner():
     return """\
 ===============================================================================================================
 ______                  ______        _                 __ _   _                        _                      
 |  ___|                 | ___ \      | |               / /| | | |                      (_)          _      _   
 | |_  ___  _   _  _ __  | |_/ /_   _ | |  ___  ___    / / | |_| |  ___  _ __ __      __ _   __ _  _| |_  _| |_ 
 |  _|/ _ \| | | || \_ \ |    /| | | || | / _ \/ __|  / /  |  _  | / _ \| \__|\ \ /\ / /| | / _` ||_   _||_   _|
 | | |  __/| |_| || | | || |\ \| |_| || ||  __/\__ \ / /   | | | ||  __/| |    \ V  V / | || (_| |  |_|    |_|  
 \_|  \___| \__, ||_| |_|\_| \_|\__,_||_| \___||___//_/    \_| |_/ \___||_|     \_/\_/  |_| \__, |              
             __/ |                                                                           __/ |              
            |___/                                                                           |___/               
 ===============================================================================================================
 generating model/vertex/.model/.in files
 please be patient!
 ===============================================================================================================
 """
 
 
 
 
 #################### ??? #######################
 
 
 # function that replaces alphaS (aS)-dependent variables
 # with their explicit form which also contains strongCoupling
 def aStoStrongCoup(stringin, paramstoreplace, paramstoreplace_expressions):
     #print stringin
     for xx in range(0,len(paramstoreplace)):
         #print paramstoreplace[xx], paramstoreplace_expressions[xx]
         stringout = stringin.replace(paramstoreplace[xx], '(' +  PyMathToThePEGMath(paramstoreplace_expressions[xx],allparams) + ')')
     stringout = stringout.replace('aS', '(sqr(strongCoupling(q2))/(4.0*Constants::pi))')
     #print 'resulting string', stringout
     return stringout
 
 
 # function that replaces alphaEW (aEW)-dependent variables
 # with their explicit form which also contains weakCoupling
 def aEWtoWeakCoup(stringin, paramstoreplace, paramstoreplace_expressions):
     #print stringin
     for xx in range(0,len(paramstoreplace)):
         #print paramstoreplace[xx], paramstoreplace_expressions[xx]
         stringout = stringin.replace(paramstoreplace[xx], '(' +  PyMathToThePEGMath(paramstoreplace_expressions[xx],allparams) + ')')
     stringout = stringout.replace('aEWM1', '(1/(sqr(electroMagneticCoupling(q2))/(4.0*Constants::pi)))')
     #print 'resulting string', stringout
     return stringout
 
 
 
 
 if __name__ == "__main__":
     import doctest
     doctest.testmod()
 
 
 if False:
     
 # Check if the Vertex is self-conjugate or not
     pdgcode = [0,0,0,0]
     notsmvertex = False
     vhasw = 0
     vhasz = 0
     vhasf = 0
     vhasg = 0
     vhash = 0
     vhasp = 0
 #   print 'printing particles in vertex'
     for i in range(len(v.particles)):
 #       print v.particles[i].pdg_code
         pdgcode[i] = v.particles[i].pdg_code
         if pdgcode[i] == 23:
             vhasz += 1
         if pdgcode[i] == 22:
             vhasp += 1
         if pdgcode[i] == 25:
             vhash += 1
         if pdgcode[i] == 21:
             vhasg += 1
         if pdgcode[i] == 24:
             vhasw += 1
         if abs(pdgcode[i]) < 7 or (abs(pdgcode[i]) > 10 and abs(pdgcode[i]) < 17):
             vhasf += 1
         if pdgcode[i] not in SMPARTICLES:
             notsmvertex = True
         
 
 #  treat replacement of SM vertices with BSM vertices?               
     if notsmvertex == False:
         if( (vhasf == 2 and vhasz == 1) or (vhasf == 2 and vhasw == 1) or (vhasf == 2 and vhash == 1) or (vhasf == 2 and vhasg == 1) or (vhasf == 2 and vhasp == 0) or (vhasg == 3) or (vhasg == 4) or (vhasw == 2 and vhash == 1) or (vhasw == 3) or (vhasw == 4) or (vhash == 1 and vhasg == 2) or (vhash == 1 and vhasp == 2)):
             #print 'VERTEX INCLUDED IN STANDARD MODEL!'
             v.include = 0
             notincluded += 1
             #continue
             
     
     selfconjugate = 0
     for j in range(len(pdgcode)):
         for k in range(len(pdgcode)):
                if  j != k and j != 0 and abs(pdgcode[j]) == abs(pdgcode[k]):
                    selfconjugate = 1
                    #print 'self-conjugate vertex'
 #        print pdgcode[j]
 
 # if the Vertex is not self-conjugate, then add the conjugate vertex
 # automatically
     scfac = [1,1,1,1]
     if selfconjugate == 0:
         #first find the self-conjugate particles
         for u in range(len(v.particles)):
               if v.particles[u].selfconjugate == 0:
                   scfac[u] = -1
 #                  print 'particle ', v.particles[u].pdg_code, ' found not to be self-conjugate'
                   
     if selfconjugate == 0:
         plistarray[1] += str(scfac[1] * v.particles[1].pdg_code) + ',' + str(scfac[0] * v.particles[0].pdg_code) + ',' + str(scfac[2] * v.particles[2].pdg_code)
-        if len(v.particles) is 4:                                                                                                                      
+        if len(v.particles) == 4:                                                                                                                      
             plistarray[1] += ',' + str(scfac[3] * v.particles[3].pdg_code)
         #print 'Conjugate vertex:', plistarray[1]
 
 
 class SkipThisVertex(Exception):
     pass
 
 def extractAntiSymmetricIndices(instring,funct) :
     terms = instring.strip(funct).strip(")").split(",")
     sign=1.
     for iy in range(0,len(terms)) :
         for ix in range(-1,-len(terms)+iy,-1) :
             swap = False
             if(len(terms[ix])==1 and len(terms[ix-1])==1) :
                 swap = int(terms[ix])<int(terms[ix-1])
             elif(len(terms[ix])==2 and len(terms[ix-1])==2) :
                 swap = int(terms[ix][1])<int(terms[ix-1][1])
             elif(len(terms[ix])==1 and len(terms[ix-1])==2) :
                 swap = True
             if(swap) :
                 sign *=-1.
                 terms[ix],terms[ix-1] = terms[ix-1],terms[ix]
     return (terms,sign)
 
 def isGoldstone(p) :
     """check if particle is a Goldstone"""
     def gstest(name):
         try:
             return getattr(p,name)
         except AttributeError:
             return False
     # names of goldstone bosons
     gsnames = ['goldstone','goldstoneboson','GoldstoneBoson']
     if any(map(gstest, gsnames)):
         return True
     return False
 
 def isGhost(p) :
     """Check if particle is a ghost"""
     try:
         getattr(p,'GhostNumber')
     except AttributeError:
         return False
     return p.GhostNumber != 0
     
 def convertToPython3(ufodir) :
     # find all the python files
     fNames=glob.glob(path.abspath(ufodir)+"/*.py")
     mNames=[]
     for i in range(0,len(fNames)) :
         mNames.append(path.split(fNames[i])[-1].replace(".py",""))
     # convert them
     for fName in fNames :
         convertFileToPython3(fName,mNames)
 
 def convertFileToPython3(fName,names) :
     output=""
     inFile=open(fName)
     line=inFile.readline()
     isInit = "__init__.py" in fName
     tNames=[]
     for val in names : tNames.append(val)
     while line :
         # iteritems -> items
         line=line.replace("iteritems","items")
         # fix imports 
         if("import" in line) :
             for val in names :
                 if("import %s" %val in line) :
-                    line=line.replace("import %s"  %val,
-                                      "from . import %s" %val)
+                    if("from ." not in line) :
+                        line=line.replace("import %s"  %val,
+                                          "from . import %s" %val)
                     if(val in tNames) : tNames.remove(val)
                 if("from %s" %val in line) :
                     line=line.replace("from %s"  %val,
                                       "from .%s" %val)
+        # and raise
+        elif "raise" in line and "," in line :
+            line = line.replace(",","(").rstrip() + ")\n"
         # add brackets to print statements
         if("print" in line) :
             if line.strip()[0:5] == "print" :
                 line=line.strip("\n").replace("print","print(")+")\n"
         output += line
         line=inFile.readline()
     inFile.close()
     if(isInit) :
         if "__init__" in tNames : tNames.remove("__init__")
         temp=""
         for val in tNames :
             temp+= "from . import %s\n" % val
         output = temp+output
     with open(fName,'w') as dest:
         dest.write(output)